[clang-format] Add options for indenting preprocessor directives

[curdeius]

Summary

This concerns bug #17362 (https://bugs.llvm.org//show_bug.cgi?id=17362).

2 styles for indenting are added: before and after hash.
3 methods:

• None (default): equivalent to current behaviour of clang-format
• All: indents all directives
• Inner: recognizes include guards and ignores them during indentation

Indentation level uses IndentWidth style parameter.

For instance, and indented code with include guards:

#ifndef INCLUDE_GUARD
#define INCLUDE_GUARD
#define A // not indented with Inner method
#ifdef B
# undef B
#else
# define C
#endif
#endif // INCLUDE_GUARD

I've tried to make the detection of include guards as correct as possible, but if you know of any edge cases that are not taken into account, I'm all ears.

[curdeius]

Fix omitted dereference.

[djasper]

Thank you for working on this. Unfortunately, this is done at the wrong level:

• You are using a separate pass, which means that as soon as the preprocessor directives exceed the column limit, they won't be wrapped correctly.
• You aren't using Clang's Lexer to separate PP directives into tokens, which might work in the short term, but seems really fragile and a maintenance headache.

The approach to do this properly would be to:

• Extend UnwrappedLineParser to properly report the level of preprocessor directives. My guess is that it might suffice to initialize Parser.Line->Level with PPBranchLevel in the constructor of ScopedLineState.
• Once the level is reported correctly, UnwrappedLineFormatter's formatFirstToken function can be changed to add the spaces required for that level either before or after the "#" for preprocessor directives.

Happy to help more if you are up for taking this on.

[curdeius]

Thanks Daniel.

I'll give it a try using the proposed approach and update you soon(ish).

[curdeius]

Superseded by rL312125.

docs/ClangFormatStyleOptions.rst

-==========================
-Clang-Format Style Options
-==========================
-
-:doc:`ClangFormatStyleOptions` describes configurable formatting style options
-supported by :doc:`LibFormat` and :doc:`ClangFormat`.
-
-When using :program:`clang-format` command line utility or
-``clang::format::reformat(...)`` functions from code, one can either use one of
-the predefined styles (LLVM, Google, Chromium, Mozilla, WebKit) or create a
-custom style by configuring specific style options.
-
-
-Configuring Style with clang-format
-===================================
-
-:program:`clang-format` supports two ways to provide custom style options:
-directly specify style configuration in the ``-style=`` command line option or
-use ``-style=file`` and put style configuration in the ``.clang-format`` or
-``_clang-format`` file in the project directory.
-
-When using ``-style=file``, :program:`clang-format` for each input file will
-try to find the ``.clang-format`` file located in the closest parent directory
-of the input file. When the standard input is used, the search is started from
-the current directory.
-
-The ``.clang-format`` file uses YAML format:
-
-.. code-block:: yaml
-
-  key1: value1
-  key2: value2
-  # A comment.
-  ...
-
-The configuration file can consist of several sections each having different
-``Language:`` parameter denoting the programming language this section of the
-configuration is targeted at. See the description of the **Language** option
-below for the list of supported languages. The first section may have no
-language set, it will set the default style options for all lanugages.
-Configuration sections for specific language will override options set in the
-default section.
-
-When :program:`clang-format` formats a file, it auto-detects the language using
-the file name. When formatting standard input or a file that doesn't have the
-extension corresponding to its language, ``-assume-filename=`` option can be
-used to override the file name :program:`clang-format` uses to detect the
-language.
-
-An example of a configuration file for multiple languages:
-
-.. code-block:: yaml
-
-  ---
-  # We'll use defaults from the LLVM style, but with 4 columns indentation.
-  BasedOnStyle: LLVM
-  IndentWidth: 4
-  ---
-  Language: Cpp
-  # Force pointers to the type for C++.
-  DerivePointerAlignment: false
-  PointerAlignment: Left
-  ---
-  Language: JavaScript
-  # Use 100 columns for JS.
-  ColumnLimit: 100
-  ---
-  Language: Proto
-  # Don't format .proto files.
-  DisableFormat: true
-  ...
-
-An easy way to get a valid ``.clang-format`` file containing all configuration
-options of a certain predefined style is:
-
-.. code-block:: console
-
-  clang-format -style=llvm -dump-config > .clang-format
-
-When specifying configuration in the ``-style=`` option, the same configuration
-is applied for all input files. The format of the configuration is:
-
-.. code-block:: console
-
-  -style='{key1: value1, key2: value2, ...}'
-
-
-Disabling Formatting on a Piece of Code
-=======================================
-
-Clang-format understands also special comments that switch formatting in a
-delimited range. The code between a comment ``// clang-format off`` or
-``/* clang-format off */`` up to a comment ``// clang-format on`` or
-``/* clang-format on */`` will not be formatted. The comments themselves
-will be formatted (aligned) normally.
-
-.. code-block:: c++
-
-  int formatted_code;
-  // clang-format off
-      void    unformatted_code  ;
-  // clang-format on
-  void formatted_code_again;
-
-
-Configuring Style in Code
-=========================
-
-When using ``clang::format::reformat(...)`` functions, the format is specified
-by supplying the `clang::format::FormatStyle
-<http://clang.llvm.org/doxygen/structclang_1_1format_1_1FormatStyle.html>`_
-structure.
-
-
-Configurable Format Style Options
-=================================
-
-This section lists the supported style options. Value type is specified for
-each option. For enumeration types possible values are specified both as a C++
-enumeration member (with a prefix, e.g. ``LS_Auto``), and as a value usable in
-the configuration (without a prefix: ``Auto``).
-
-
-**BasedOnStyle** (``string``)
-  The style used for all options not specifically set in the configuration.
-
-  This option is supported only in the :program:`clang-format` configuration
-  (both within ``-style='{...}'`` and the ``.clang-format`` file).
-
-  Possible values:
-
-  * ``LLVM``
-    A style complying with the `LLVM coding standards
-    <http://llvm.org/docs/CodingStandards.html>`_
-  * ``Google``
-    A style complying with `Google's C++ style guide
-    <http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml>`_
-  * ``Chromium``
-    A style complying with `Chromium's style guide
-    <http://www.chromium.org/developers/coding-style>`_
-  * ``Mozilla``
-    A style complying with `Mozilla's style guide
-    <https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style>`_
-  * ``WebKit``
-    A style complying with `WebKit's style guide
-    <http://www.webkit.org/coding/coding-style.html>`_
-
-.. START_FORMAT_STYLE_OPTIONS
-
-**AccessModifierOffset** (``int``)
-  The extra indent or outdent of access modifiers, e.g. ``public:``.
-
-**AlignAfterOpenBracket** (``BracketAlignmentStyle``)
-  If ``true``, horizontally aligns arguments after an open bracket.
-
-  This applies to round brackets (parentheses), angle brackets and square
-  brackets.
-
-  Possible values:
-
-  * ``BAS_Align`` (in configuration: ``Align``)
-    Align parameters on the open bracket, e.g.:
-
-    .. code-block:: c++
-
-      someLongFunction(argument1,
-                       argument2);
-
-  * ``BAS_DontAlign`` (in configuration: ``DontAlign``)
-    Don't align, instead use ``ContinuationIndentWidth``, e.g.:
-
-    .. code-block:: c++
-
-      someLongFunction(argument1,
-          argument2);
-
-  * ``BAS_AlwaysBreak`` (in configuration: ``AlwaysBreak``)
-    Always break after an open bracket, if the parameters don't fit
-    on a single line, e.g.:
-
-    .. code-block:: c++
-
-      someLongFunction(
-          argument1, argument2);
-
-
-
-**AlignConsecutiveAssignments** (``bool``)
-  If ``true``, aligns consecutive assignments.
-
-  This will align the assignment operators of consecutive lines. This
-  will result in formattings like
-
-  .. code-block:: c++
-
-    int aaaa = 12;
-    int b    = 23;
-    int ccc  = 23;
-
-**AlignConsecutiveDeclarations** (``bool``)
-  If ``true``, aligns consecutive declarations.
-
-  This will align the declaration names of consecutive lines. This
-  will result in formattings like
-
-  .. code-block:: c++
-
-    int         aaaa = 12;
-    float       b = 23;
-    std::string ccc = 23;
-
-**AlignEscapedNewlinesLeft** (``bool``)
-  If ``true``, aligns escaped newlines as far left as possible.
-  Otherwise puts them into the right-most column.
-
-  .. code-block:: c++
-
-    true:
-    #define A   \
-      int aaaa; \
-      int b;    \
-      int dddddddddd;
-
-    false:
-    #define A                                                                      \
-      int aaaa;                                                                    \
-      int b;                                                                       \
-      int dddddddddd;
-
-**AlignOperands** (``bool``)
-  If ``true``, horizontally align operands of binary and ternary
-  expressions.
-
-  Specifically, this aligns operands of a single expression that needs to be
-  split over multiple lines, e.g.:
-
-  .. code-block:: c++
-
-    int aaa = bbbbbbbbbbbbbbb +
-              ccccccccccccccc;
-
-**AlignTrailingComments** (``bool``)
-  If ``true``, aligns trailing comments.
-
-  .. code-block:: c++
-
-    true:                                   false:
-    int a;     // My comment a      vs.     int a; // My comment a
-    int b = 2; // comment  b                int b = 2; // comment about b
-
-**AllowAllParametersOfDeclarationOnNextLine** (``bool``)
-  Allow putting all parameters of a function declaration onto
-  the next line even if ``BinPackParameters`` is ``false``.
-
-  .. code-block:: c++
-
-    true:                                   false:
-    myFunction(foo,                 vs.     myFunction(foo, bar, plop);
-               bar,
-               plop);
-
-**AllowShortBlocksOnASingleLine** (``bool``)
-  Allows contracting simple braced statements to a single line.
-
-  E.g., this allows ``if (a) { return; }`` to be put on a single line.
-
-**AllowShortCaseLabelsOnASingleLine** (``bool``)
-  If ``true``, short case labels will be contracted to a single line.
-
-  .. code-block:: c++
-
-    true:                                   false:
-    switch (a) {                    vs.     switch (a) {
-    case 1: x = 1; break;                   case 1:
-    case 2: return;                           x = 1;
-    }                                         break;
-                                            case 2:
-                                              return;
-                                            }
-
-**AllowShortFunctionsOnASingleLine** (``ShortFunctionStyle``)
-  Dependent on the value, ``int f() { return 0; }`` can be put on a
-  single line.
-
-  Possible values:
-
-  * ``SFS_None`` (in configuration: ``None``)
-    Never merge functions into a single line.
-
-  * ``SFS_Empty`` (in configuration: ``Empty``)
-    Only merge empty functions.
-
-    .. code-block:: c++
-
-      void f() { bar(); }
-      void f2() {
-        bar2();
-      }
-
-  * ``SFS_Inline`` (in configuration: ``Inline``)
-    Only merge functions defined inside a class. Implies "empty".
-
-    .. code-block:: c++
-
-      class Foo {
-        void f() { foo(); }
-      };
-
-  * ``SFS_All`` (in configuration: ``All``)
-    Merge all functions fitting on a single line.
-
-    .. code-block:: c++
-
-      class Foo {
-        void f() { foo(); }
-      };
-      void f() { bar(); }
-
-
-
-**AllowShortIfStatementsOnASingleLine** (``bool``)
-  If ``true``, ``if (a) return;`` can be put on a single line.
-
-**AllowShortLoopsOnASingleLine** (``bool``)
-  If ``true``, ``while (true) continue;`` can be put on a single
-  line.
-
-**AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``)
-  The function definition return type breaking style to use.  This
-  option is **deprecated** and is retained for backwards compatibility.
-
-  Possible values:
-
-  * ``DRTBS_None`` (in configuration: ``None``)
-    Break after return type automatically.
-    ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
-
-  * ``DRTBS_All`` (in configuration: ``All``)
-    Always break after the return type.
-
-  * ``DRTBS_TopLevel`` (in configuration: ``TopLevel``)
-    Always break after the return types of top-level functions.
-
-
-
-**AlwaysBreakAfterReturnType** (``ReturnTypeBreakingStyle``)
-  The function declaration return type breaking style to use.
-
-  Possible values:
-
-  * ``RTBS_None`` (in configuration: ``None``)
-    Break after return type automatically.
-    ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
-
-    .. code-block:: c++
-
-      class A {
-        int f() { return 0; };
-      };
-      int f();
-      int f() { return 1; }
-
-  * ``RTBS_All`` (in configuration: ``All``)
-    Always break after the return type.
-
-    .. code-block:: c++
-
-      class A {
-        int
-        f() {
-          return 0;
-        };
-      };
-      int
-      f();
-      int
-      f() {
-        return 1;
-      }
-
-  * ``RTBS_TopLevel`` (in configuration: ``TopLevel``)
-    Always break after the return types of top-level functions.
-
-    .. code-block:: c++
-
-      class A {
-        int f() { return 0; };
-      };
-      int
-      f();
-      int
-      f() {
-        return 1;
-      }
-
-  * ``RTBS_AllDefinitions`` (in configuration: ``AllDefinitions``)
-    Always break after the return type of function definitions.
-
-    .. code-block:: c++
-
-      class A {
-        int
-        f() {
-          return 0;
-        };
-      };
-      int f();
-      int
-      f() {
-        return 1;
-      }
-
-  * ``RTBS_TopLevelDefinitions`` (in configuration: ``TopLevelDefinitions``)
-    Always break after the return type of top-level definitions.
-
-    .. code-block:: c++
-
-      class A {
-        int f() { return 0; };
-      };
-      int f();
-      int
-      f() {
-        return 1;
-      }
-
-
-
-**AlwaysBreakBeforeMultilineStrings** (``bool``)
-  If ``true``, always break before multiline string literals.
-
-  This flag is mean to make cases where there are multiple multiline strings
-  in a file look more consistent. Thus, it will only take effect if wrapping
-  the string at that point leads to it being indented
-  ``ContinuationIndentWidth`` spaces from the start of the line.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     aaaa =                         vs.     aaaa = "bbbb"
-         "bbbb"                                    "cccc";
-         "cccc";
-
-**AlwaysBreakTemplateDeclarations** (``bool``)
-  If ``true``, always break after the ``template<...>`` of a template
-  declaration.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     template <typename T>          vs.     template <typename T> class C {};
-     class C {};
-
-**BinPackArguments** (``bool``)
-  If ``false``, a function call's arguments will either be all on the
-  same line or will have one line each.
-
-  .. code-block:: c++
-
-    true:
-    void f() {
-      f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
-        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
-    }
-
-    false:
-    void f() {
-      f(aaaaaaaaaaaaaaaaaaaa,
-        aaaaaaaaaaaaaaaaaaaa,
-        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
-    }
-
-**BinPackParameters** (``bool``)
-  If ``false``, a function declaration's or function definition's
-  parameters will either all be on the same line or will have one line each.
-
-  .. code-block:: c++
-
-    true:
-    void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
-           int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
-
-    false:
-    void f(int aaaaaaaaaaaaaaaaaaaa,
-           int aaaaaaaaaaaaaaaaaaaa,
-           int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
-
-**BraceWrapping** (``BraceWrappingFlags``)
-  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.
-
-  Nested configuration flags:
-
-
-  * ``bool AfterClass`` Wrap class definitions.
-
-  .. code-block:: c++
-
-    true:
-    class foo {};
-
-    false:
-    class foo
-    {};
-
-  * ``bool AfterControlStatement`` Wrap control statements (``if``/``for``/``while``/``switch``/..).
-
-  .. code-block:: c++
-
-    true:
-    if (foo())
-    {
-    } else
-    {}
-    for (int i = 0; i < 10; ++i)
-    {}
-
-    false:
-    if (foo()) {
-    } else {
-    }
-    for (int i = 0; i < 10; ++i) {
-    }
-
-  * ``bool AfterEnum`` Wrap enum definitions.
-
-  .. code-block:: c++
-
-    true:
-    enum X : int
-    {
-      B
-    };
-
-    false:
-    enum X : int { B };
-
-  * ``bool AfterFunction`` Wrap function definitions.
-
-  .. code-block:: c++
-
-    true:
-    void foo()
-    {
-      bar();
-      bar2();
-    }
-
-    false:
-    void foo() {
-      bar();
-      bar2();
-    }
-
-  * ``bool AfterNamespace`` Wrap namespace definitions.
-
-  .. code-block:: c++
-
-    true:
-    namespace
-    {
-    int foo();
-    int bar();
-    }
-
-    false:
-    namespace {
-    int foo();
-    int bar();
-    }
-
-  * ``bool AfterObjCDeclaration`` Wrap ObjC definitions (``@autoreleasepool``, interfaces, ..).
-
-  * ``bool AfterStruct`` Wrap struct definitions.
-
-  .. code-block:: c++
-
-    true:
-    struct foo
-    {
-      int x;
-    }
-
-    false:
-    struct foo {
-      int x;
-    }
-
-  * ``bool AfterUnion`` Wrap union definitions.
-
-  .. code-block:: c++
-
-    true:
-    union foo
-    {
-      int x;
-    }
-
-    false:
-    union foo {
-      int x;
-    }
-
-  * ``bool BeforeCatch`` Wrap before ``catch``.
-
-  .. code-block:: c++
-
-    true:
-    try {
-      foo();
-    }
-    catch () {
-    }
-
-    false:
-    try {
-      foo();
-    } catch () {
-    }
-
-  * ``bool BeforeElse`` Wrap before ``else``.
-
-  .. code-block:: c++
-
-    true:
-    if (foo()) {
-    }
-    else {
-    }
-
-    false:
-    if (foo()) {
-    } else {
-    }
-
-  * ``bool IndentBraces`` Indent the wrapped braces themselves.
-
-
-**BreakAfterJavaFieldAnnotations** (``bool``)
-  Break after each annotation on a field in Java files.
-
-**BreakBeforeBinaryOperators** (``BinaryOperatorStyle``)
-  The way to wrap binary operators.
-
-  Possible values:
-
-  * ``BOS_None`` (in configuration: ``None``)
-    Break after operators.
-
-    .. code-block:: c++
-
-       LooooooooooongType loooooooooooooooooooooongVariable =
-           someLooooooooooooooooongFunction();
-
-       bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
-                            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
-                        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
-                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
-                        ccccccccccccccccccccccccccccccccccccccccc;
-
-  * ``BOS_NonAssignment`` (in configuration: ``NonAssignment``)
-    Break before operators that aren't assignments.
-
-    .. code-block:: c++
-
-       LooooooooooongType loooooooooooooooooooooongVariable =
-           someLooooooooooooooooongFunction();
-
-       bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                           > ccccccccccccccccccccccccccccccccccccccccc;
-
-  * ``BOS_All`` (in configuration: ``All``)
-    Break before operators.
-
-    .. code-block:: c++
-
-       LooooooooooongType loooooooooooooooooooooongVariable
-           = someLooooooooooooooooongFunction();
-
-       bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-                           > ccccccccccccccccccccccccccccccccccccccccc;
-
-
-
-**BreakBeforeBraces** (``BraceBreakingStyle``)
-  The brace breaking style to use.
-
-  Possible values:
-
-  * ``BS_Attach`` (in configuration: ``Attach``)
-    Always attach braces to surrounding context.
-
-    .. code-block:: c++
-
-      try {
-        foo();
-      } catch () {
-      }
-      void foo() { bar(); }
-      class foo {};
-      if (foo()) {
-      } else {
-      }
-      enum X : int { A, B };
-
-  * ``BS_Linux`` (in configuration: ``Linux``)
-    Like ``Attach``, but break before braces on function, namespace and
-    class definitions.
-
-    .. code-block:: c++
-
-      try {
-        foo();
-      } catch () {
-      }
-      void foo() { bar(); }
-      class foo
-      {
-      };
-      if (foo()) {
-      } else {
-      }
-      enum X : int { A, B };
-
-  * ``BS_Mozilla`` (in configuration: ``Mozilla``)
-    Like ``Attach``, but break before braces on enum, function, and record
-    definitions.
-
-    .. code-block:: c++
-
-      try {
-        foo();
-      } catch () {
-      }
-      void foo() { bar(); }
-      class foo
-      {
-      };
-      if (foo()) {
-      } else {
-      }
-      enum X : int { A, B };
-
-  * ``BS_Stroustrup`` (in configuration: ``Stroustrup``)
-    Like ``Attach``, but break before function definitions, ``catch``, and
-    ``else``.
-
-    .. code-block:: c++
-
-      try {
-        foo();
-      } catch () {
-      }
-      void foo() { bar(); }
-      class foo
-      {
-      };
-      if (foo()) {
-      } else {
-      }
-      enum X : int
-      {
-        A,
-        B
-      };
-
-  * ``BS_Allman`` (in configuration: ``Allman``)
-    Always break before braces.
-
-    .. code-block:: c++
-
-      try {
-        foo();
-      }
-      catch () {
-      }
-      void foo() { bar(); }
-      class foo {
-      };
-      if (foo()) {
-      }
-      else {
-      }
-      enum X : int { A, B };
-
-  * ``BS_GNU`` (in configuration: ``GNU``)
-    Always break before braces and add an extra level of indentation to
-    braces of control statements, not to those of class, function
-    or other definitions.
-
-    .. code-block:: c++
-
-      try
-        {
-          foo();
-        }
-      catch ()
-        {
-        }
-      void foo() { bar(); }
-      class foo
-      {
-      };
-      if (foo())
-        {
-        }
-      else
-        {
-        }
-      enum X : int
-      {
-        A,
-        B
-      };
-
-  * ``BS_WebKit`` (in configuration: ``WebKit``)
-    Like ``Attach``, but break before functions.
-
-    .. code-block:: c++
-
-      try {
-        foo();
-      } catch () {
-      }
-      void foo() { bar(); }
-      class foo {
-      };
-      if (foo()) {
-      } else {
-      }
-      enum X : int { A, B };
-
-  * ``BS_Custom`` (in configuration: ``Custom``)
-    Configure each individual brace in `BraceWrapping`.
-
-
-
-**BreakBeforeInheritanceComma** (``bool``)
-  If ``true``, in the class inheritance expression clang-format will
-  break before ``:`` and ``,`` if there is multiple inheritance.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     class MyClass                  vs.     class MyClass : public X, public Y {
-         : public X                         };
-         , public Y {
-     };
-
-**BreakBeforeTernaryOperators** (``bool``)
-  If ``true``, ternary operators will be placed after line breaks.
-
-  .. code-block:: c++
-
-     true:
-     veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
-         ? firstValue
-         : SecondValueVeryVeryVeryVeryLong;
-
-     true:
-     veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
-         firstValue :
-         SecondValueVeryVeryVeryVeryLong;
-
-**BreakConstructorInitializersBeforeComma** (``bool``)
-  Always break constructor initializers before commas and align
-  the commas with the colon.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     SomeClass::Constructor()       vs.     SomeClass::Constructor() : a(a),
-         : a(a)                                                   b(b),
-         , b(b)                                                   c(c) {}
-         , c(c) {}
-
-**BreakStringLiterals** (``bool``)
-  Allow breaking string literals when formatting.
-
-**ColumnLimit** (``unsigned``)
-  The column limit.
-
-  A column limit of ``0`` means that there is no column limit. In this case,
-  clang-format will respect the input's line breaking decisions within
-  statements unless they contradict other rules.
-
-**CommentPragmas** (``std::string``)
-  A regular expression that describes comments with special meaning,
-  which should not be split into lines or otherwise changed.
-
-  .. code-block:: c++
-
-     // CommentPragmas: '^ FOOBAR pragma:'
-     // Will leave the following line unaffected
-     #include <vector> // FOOBAR pragma: keep
-
-**ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``)
-  If the constructor initializers don't fit on a line, put each
-  initializer on its own line.
-
-  .. code-block:: c++
-
-    true:
-    SomeClass::Constructor()
-        : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
-      return 0;
-    }
-
-    false:
-    SomeClass::Constructor()
-        : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
-          aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
-      return 0;
-    }
-
-**ConstructorInitializerIndentWidth** (``unsigned``)
-  The number of characters to use for indentation of constructor
-  initializer lists.
-
-**ContinuationIndentWidth** (``unsigned``)
-  Indent width for line continuations.
-
-**Cpp11BracedListStyle** (``bool``)
-  If ``true``, format braced lists as best suited for C++11 braced
-  lists.
-
-  Important differences:
-  - No spaces inside the braced list.
-  - No line break before the closing brace.
-  - Indentation with the continuation indent, not with the block indent.
-
-  Fundamentally, C++11 braced lists are formatted exactly like function
-  calls would be formatted in their place. If the braced list follows a name
-  (e.g. a type or variable name), clang-format formats as if the ``{}`` were
-  the parentheses of a function call with that name. If there is no name,
-  a zero-length name is assumed.
-
-**DerivePointerAlignment** (``bool``)
-  If ``true``, analyze the formatted file for the most common
-  alignment of ``&`` and ``*``. ``PointerAlignment`` is then used only as
-  fallback.
-
-**DisableFormat** (``bool``)
-  Disables formatting completely.
-
-**ExperimentalAutoDetectBinPacking** (``bool``)
-  If ``true``, clang-format detects whether function calls and
-  definitions are formatted with one parameter per line.
-
-  Each call can be bin-packed, one-per-line or inconclusive. If it is
-  inconclusive, e.g. completely on one line, but a decision needs to be
-  made, clang-format analyzes whether there are other bin-packed cases in
-  the input file and act accordingly.
-
-  NOTE: This is an experimental flag, that might go away or be renamed. Do
-  not use this in config files, etc. Use at your own risk.
-
-**FixNamespaceComments** (``bool``)
-  If ``true``, clang-format adds missing namespace end comments and
-  fixes invalid existing ones.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     namespace a {                  vs.     namespace a {
-     foo();                                 foo();
-     } // namespace a;                      }
-
-**ForEachMacros** (``std::vector<std::string>``)
-  A vector of macros that should be interpreted as foreach loops
-  instead of as function calls.
-
-  These are expected to be macros of the form:
-
-  .. code-block:: c++
-
-    FOREACH(<variable-declaration>, ...)
-      <loop-body>
-
-  In the .clang-format configuration file, this can be configured like:
-
-  .. code-block:: yaml
-
-    ForEachMacros: ['RANGES_FOR', 'FOREACH']
-
-  For example: BOOST_FOREACH.
-
-**IncludeCategories** (``std::vector<IncludeCategory>``)
-  Regular expressions denoting the different ``#include`` categories
-  used for ordering ``#includes``.
-
-  These regular expressions are matched against the filename of an include
-  (including the <> or "") in order. The value belonging to the first
-  matching regular expression is assigned and ``#includes`` are sorted first
-  according to increasing category number and then alphabetically within
-  each category.
-
-  If none of the regular expressions match, INT_MAX is assigned as
-  category. The main header for a source file automatically gets category 0.
-  so that it is generally kept at the beginning of the ``#includes``
-  (http://llvm.org/docs/CodingStandards.html#include-style). However, you
-  can also assign negative priorities if you have certain headers that
-  always need to be first.
-
-  To configure this in the .clang-format file, use:
-
-  .. code-block:: yaml
-
-    IncludeCategories:
-      - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-        Priority:        2
-      - Regex:           '^(<|"(gtest|isl|json)/)'
-        Priority:        3
-      - Regex:           '.*'
-        Priority:        1
-
-**IncludeIsMainRegex** (``std::string``)
-  Specify a regular expression of suffixes that are allowed in the
-  file-to-main-include mapping.
-
-  When guessing whether a #include is the "main" include (to assign
-  category 0, see above), use this regex of allowed suffixes to the header
-  stem. A partial match is done, so that:
-  - "" means "arbitrary suffix"
-  - "$" means "no suffix"
-
-  For example, if configured to "(_test)?$", then a header a.h would be seen
-  as the "main" include in both a.cc and a_test.cc.
-
-**IndentCaseLabels** (``bool``)
-  Indent case labels one level from the switch statement.
-
-  When ``false``, use the same indentation level as for the switch statement.
-  Switch statement body is always indented one level more than case labels.
-
-**IndentWidth** (``unsigned``)
-  The number of columns to use for indentation.
-
-  .. code-block:: c++
-
-     IndentWidth: 3
-     void f() {
-        someFunction();
-        if (true, false) {
-           f();
-        }
-     }
-
-**IndentWrappedFunctionNames** (``bool``)
-  Indent if a function definition or declaration is wrapped after the
-  type.
-
-**JavaScriptQuotes** (``JavaScriptQuoteStyle``)
-  The JavaScriptQuoteStyle to use for JavaScript strings.
-
-  Possible values:
-
-  * ``JSQS_Leave`` (in configuration: ``Leave``)
-    Leave string quotes as they are.
-
-    .. code-block:: js
-
-       string1 = "foo";
-       string2 = 'bar';
-
-  * ``JSQS_Single`` (in configuration: ``Single``)
-    Always use single quotes.
-
-    .. code-block:: js
-
-       string1 = 'foo';
-       string2 = 'bar';
-
-  * ``JSQS_Double`` (in configuration: ``Double``)
-    Always use double quotes.
-
-    .. code-block:: js
-
-       string1 = "foo";
-       string2 = "bar";
-
-
-
-**JavaScriptWrapImports** (``bool``)
-  Whether to wrap JavaScript import/export statements.
-
-  .. code-block:: js
-
-     true:
-     import {
-         VeryLongImportsAreAnnoying,
-         VeryLongImportsAreAnnoying,
-         VeryLongImportsAreAnnoying,
-     } from 'some/module.js'
-
-     false:
-     import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
-
-**KeepEmptyLinesAtTheStartOfBlocks** (``bool``)
-  If true, empty lines at the start of blocks are kept.
-
-**Language** (``LanguageKind``)
-  Language, this format style is targeted at.
-
-  Possible values:
-
-  * ``LK_None`` (in configuration: ``None``)
-    Do not use.
-
-  * ``LK_Cpp`` (in configuration: ``Cpp``)
-    Should be used for C, C++.
-
-  * ``LK_Java`` (in configuration: ``Java``)
-    Should be used for Java.
-
-  * ``LK_JavaScript`` (in configuration: ``JavaScript``)
-    Should be used for JavaScript.
-
-  * ``LK_ObjC`` (in configuration: ``ObjC``)
-    Should be used for Objective-C, Objective-C++.
-
-  * ``LK_Proto`` (in configuration: ``Proto``)
-    Should be used for Protocol Buffers
-    (https://developers.google.com/protocol-buffers/).
-
-  * ``LK_TableGen`` (in configuration: ``TableGen``)
-    Should be used for TableGen code.
-
-
-
-**MacroBlockBegin** (``std::string``)
-  A regular expression matching macros that start a block.
-
-  .. code-block:: c++
-
-     # With:
-     MacroBlockBegin: "^NS_MAP_BEGIN|\
-     NS_TABLE_HEAD$"
-     MacroBlockEnd: "^\
-     NS_MAP_END|\
-     NS_TABLE_.*_END$"
-
-     NS_MAP_BEGIN
-       foo();
-     NS_MAP_END
-
-     NS_TABLE_HEAD
-       bar();
-     NS_TABLE_FOO_END
-
-     # Without:
-     NS_MAP_BEGIN
-     foo();
-     NS_MAP_END
-
-     NS_TABLE_HEAD
-     bar();
-     NS_TABLE_FOO_END
-
-**MacroBlockEnd** (``std::string``)
-  A regular expression matching macros that end a block.
-
-**MaxEmptyLinesToKeep** (``unsigned``)
-  The maximum number of consecutive empty lines to keep.
-
-  .. code-block:: c++
-
-     MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
-     int f() {                              int f() {
-       int = 1;                                 int i = 1;
-                                                i = foo();
-       i = foo();                               return i;
-                                            }
-       return i;
-     }
-
-**NamespaceIndentation** (``NamespaceIndentationKind``)
-  The indentation used for namespaces.
-
-  Possible values:
-
-  * ``NI_None`` (in configuration: ``None``)
-    Don't indent in namespaces.
-
-    .. code-block:: c++
-
-       namespace out {
-       int i;
-       namespace in {
-       int i;
-       }
-       }
-
-  * ``NI_Inner`` (in configuration: ``Inner``)
-    Indent only in inner namespaces (nested in other namespaces).
-
-    .. code-block:: c++
-
-       namespace out {
-       int i;
-       namespace in {
-         int i;
-       }
-       }
-
-  * ``NI_All`` (in configuration: ``All``)
-    Indent in all namespaces.
-
-    .. code-block:: c++
-
-       namespace out {
-         int i;
-         namespace in {
-           int i;
-         }
-       }
-
-
-
-**ObjCBlockIndentWidth** (``unsigned``)
-  The number of characters to use for indentation of ObjC blocks.
-
-**ObjCSpaceAfterProperty** (``bool``)
-  Add a space after ``@property`` in Objective-C, i.e. use
-  ``@property (readonly)`` instead of ``@property(readonly)``.
-
-**ObjCSpaceBeforeProtocolList** (``bool``)
-  Add a space in front of an Objective-C protocol list, i.e. use
-  ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
-
-**PenaltyBreakBeforeFirstCallParameter** (``unsigned``)
-  The penalty for breaking a function call after ``call(``.
-
-**PenaltyBreakComment** (``unsigned``)
-  The penalty for each line break introduced inside a comment.
-
-**PenaltyBreakFirstLessLess** (``unsigned``)
-  The penalty for breaking before the first ``<<``.
-
-**PenaltyBreakString** (``unsigned``)
-  The penalty for each line break introduced inside a string literal.
-
-**PenaltyExcessCharacter** (``unsigned``)
-  The penalty for each character outside of the column limit.
-
-**PenaltyReturnTypeOnItsOwnLine** (``unsigned``)
-  Penalty for putting the return type of a function onto its own
-  line.
-
-**PointerAlignment** (``PointerAlignmentStyle``)
-  Pointer and reference alignment style.
-
-  Possible values:
-
-  * ``PAS_Left`` (in configuration: ``Left``)
-    Align pointer to the left.
-
-    .. code-block:: c++
-
-      int* a;
-
-  * ``PAS_Right`` (in configuration: ``Right``)
-    Align pointer to the right.
-
-    .. code-block:: c++
-
-      int *a;
-
-  * ``PAS_Middle`` (in configuration: ``Middle``)
-    Align pointer in the middle.
-
-    .. code-block:: c++
-
-      int * a;
-
-
-
-**ReflowComments** (``bool``)
-  If ``true``, clang-format will attempt to re-flow comments.
-
-  .. code-block:: c++
-
-     false:
-     // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
-     /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
-
-     true:
-     // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
-     // information
-     /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
-      * information */
-
-**SortIncludes** (``bool``)
-  If ``true``, clang-format will sort ``#includes``.
-
-  .. code-block:: c++
-
-     false:                                 true:
-     #include "b.h"                 vs.     #include "a.h"
-     #include "a.h"                         #include "b.h"
-
-**SpaceAfterCStyleCast** (``bool``)
-  If ``true``, a space is inserted after C style casts.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     (int)i;                        vs.     (int) i;
-
-**SpaceAfterTemplateKeyword** (``bool``)
-  If ``true``, a space will be inserted after the 'template' keyword.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     template <int> void foo();     vs.     template<int> void foo();
-
-**SpaceBeforeAssignmentOperators** (``bool``)
-  If ``false``, spaces will be removed before assignment operators.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     int a = 5;                     vs.     int a=5;
-     a += 42                                a+=42;
-
-**SpaceBeforeParens** (``SpaceBeforeParensOptions``)
-  Defines in which cases to put a space before opening parentheses.
-
-  Possible values:
-
-  * ``SBPO_Never`` (in configuration: ``Never``)
-    Never put a space before opening parentheses.
-
-    .. code-block:: c++
-
-       void f() {
-         if(true) {
-           f();
-         }
-       }
-
-  * ``SBPO_ControlStatements`` (in configuration: ``ControlStatements``)
-    Put a space before opening parentheses only after control statement
-    keywords (``for/if/while...``).
-
-    .. code-block:: c++
-
-       void f() {
-         if (true) {
-           f();
-         }
-       }
-
-  * ``SBPO_Always`` (in configuration: ``Always``)
-    Always put a space before opening parentheses, except when it's
-    prohibited by the syntax rules (in function-like macro definitions) or
-    when determined by other style rules (after unary operators, opening
-    parentheses, etc.)
-
-    .. code-block:: c++
-
-       void f () {
-         if (true) {
-           f ();
-         }
-       }
-
-
-
-**SpaceInEmptyParentheses** (``bool``)
-  If ``true``, spaces may be inserted into ``()``.
-
-  .. code-block:: c++
-
-     true:                                false:
-     void f( ) {                    vs.   void f() {
-       int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
-       if (true) {                          if (true) {
-         f( );                                f();
-       }                                    }
-     }                                    }
-
-**SpacesBeforeTrailingComments** (``unsigned``)
-  The number of spaces before trailing line comments
-  (``//`` - comments).
-
-  This does not affect trailing block comments (``/*`` - comments) as
-  those commonly have different usage patterns and a number of special
-  cases.
-
-  .. code-block:: c++
-
-     SpacesBeforeTrailingComments: 3
-     void f() {
-       if (true) {   // foo1
-         f();        // bar
-       }             // foo
-     }
-
-**SpacesInAngles** (``bool``)
-  If ``true``, spaces will be inserted after ``<`` and before ``>``
-  in template argument lists.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     static_cast< int >(arg);       vs.     static_cast<int>(arg);
-     std::function< void(int) > fct;        std::function<void(int)> fct;
-
-**SpacesInCStyleCastParentheses** (``bool``)
-  If ``true``, spaces may be inserted into C style casts.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     x = ( int32 )y                 vs.     x = (int32)y
-
-**SpacesInContainerLiterals** (``bool``)
-  If ``true``, spaces are inserted inside container literals (e.g.
-  ObjC and Javascript array and dict literals).
-
-  .. code-block:: js
-
-     true:                                  false:
-     var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
-     f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
-
-**SpacesInParentheses** (``bool``)
-  If ``true``, spaces will be inserted after ``(`` and before ``)``.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
-
-**SpacesInSquareBrackets** (``bool``)
-  If ``true``, spaces will be inserted after ``[`` and before ``]``.
-  Lambdas or unspecified size array declarations will not be affected.
-
-  .. code-block:: c++
-
-     true:                                  false:
-     int a[ 5 ];                    vs.     int a[5];
-     std::unique_ptr<int[]> foo() {} // Won't be affected
-
-**Standard** (``LanguageStandard``)
-  Format compatible with this standard, e.g. use ``A<A<int> >``
-  instead of ``A<A<int>>`` for ``LS_Cpp03``.
-
-  Possible values:
-
-  * ``LS_Cpp03`` (in configuration: ``Cpp03``)
-    Use C++03-compatible syntax.
-
-  * ``LS_Cpp11`` (in configuration: ``Cpp11``)
-    Use features of C++11 (e.g. ``A<A<int>>`` instead of ``A<A<int> >``).
-
-  * ``LS_Auto`` (in configuration: ``Auto``)
-    Automatic detection based on the input.
-
-
-
-**TabWidth** (``unsigned``)
-  The number of columns used for tab stops.
-
-**UseTab** (``UseTabStyle``)
-  The way to use tab characters in the resulting file.
-
-  Possible values:
-
-  * ``UT_Never`` (in configuration: ``Never``)
-    Never use tab.
-
-  * ``UT_ForIndentation`` (in configuration: ``ForIndentation``)
-    Use tabs only for indentation.
-
-  * ``UT_ForContinuationAndIndentation`` (in configuration: ``ForContinuationAndIndentation``)
-    Use tabs only for line continuation and indentation.
-
-  * ``UT_Always`` (in configuration: ``Always``)
-    Use tabs whenever we need to fill whitespace that spans at least from
-    one tab stop to the next one.
-
-
-
-.. END_FORMAT_STYLE_OPTIONS
-
-Adding additional style options
-===============================
-
-Each additional style option adds costs to the clang-format project. Some of
-these costs affect the clang-format development itself, as we need to make
-sure that any given combination of options work and that new features don't
-break any of the existing options in any way. There are also costs for end users
-as options become less discoverable and people have to think about and make a
-decision on options they don't really care about.
-
-The goal of the clang-format project is more on the side of supporting a
-limited set of styles really well as opposed to supporting every single style
-used by a codebase somewhere in the wild. Of course, we do want to support all
-major projects and thus have established the following bar for adding style
-options. Each new style option must ..
-
-  * be used in a project of significant size (have dozens of contributors)
-  * have a publicly accessible style guide
-  * have a person willing to contribute and maintain patches
-
-Examples
-========
-
-A style similar to the `Linux Kernel style
-<https://www.kernel.org/doc/Documentation/CodingStyle>`_:
-
-.. code-block:: yaml
-
-  BasedOnStyle: LLVM
-  IndentWidth: 8
-  UseTab: Always
-  BreakBeforeBraces: Linux
-  AllowShortIfStatementsOnASingleLine: false
-  IndentCaseLabels: false
-
-The result is (imagine that tabs are used for indentation here):
-
-.. code-block:: c++
-
-  void test()
-  {
-          switch (x) {
-          case 0:
-          case 1:
-                  do_something();
-                  break;
-          case 2:
-                  do_something_else();
-                  break;
-          default:
-                  break;
-          }
-          if (condition)
-                  do_something_completely_different();
-
-          if (x == y) {
-                  q();
-          } else if (x > y) {
-                  w();
-          } else {
-                  r();
-          }
-  }
-
-A style similar to the default Visual Studio formatting style:
-
-.. code-block:: yaml
-
-  UseTab: Never
-  IndentWidth: 4
-  BreakBeforeBraces: Allman
-  AllowShortIfStatementsOnASingleLine: false
-  IndentCaseLabels: false
-  ColumnLimit: 0
-
-The result is:
-
-.. code-block:: c++
-
-  void test()
-  {
-      switch (suffix)
-      {
-      case 0:
-      case 1:
-          do_something();
-          break;
-      case 2:
-          do_something_else();
-          break;
-      default:
-          break;
-      }
-      if (condition)
-          do_somthing_completely_different();
-
-      if (x == y)
-      {
-          q();
-      }
-      else if (x > y)
-      {
-          w();
-      }
-      else
-      {
-          r();
-      }
-  }
+==========================
+Clang-Format Style Options
+==========================
+
+:doc:`ClangFormatStyleOptions` describes configurable formatting style options
+supported by :doc:`LibFormat` and :doc:`ClangFormat`.
+
+When using :program:`clang-format` command line utility or
+``clang::format::reformat(...)`` functions from code, one can either use one of
+the predefined styles (LLVM, Google, Chromium, Mozilla, WebKit) or create a
+custom style by configuring specific style options.
+
+
+Configuring Style with clang-format
+===================================
+
+:program:`clang-format` supports two ways to provide custom style options:
+directly specify style configuration in the ``-style=`` command line option or
+use ``-style=file`` and put style configuration in the ``.clang-format`` or
+``_clang-format`` file in the project directory.
+
+When using ``-style=file``, :program:`clang-format` for each input file will
+try to find the ``.clang-format`` file located in the closest parent directory
+of the input file. When the standard input is used, the search is started from
+the current directory.
+
+The ``.clang-format`` file uses YAML format:
+
+.. code-block:: yaml
+
+  key1: value1
+  key2: value2
+  # A comment.
+  ...
+
+The configuration file can consist of several sections each having different
+``Language:`` parameter denoting the programming language this section of the
+configuration is targeted at. See the description of the **Language** option
+below for the list of supported languages. The first section may have no
+language set, it will set the default style options for all lanugages.
+Configuration sections for specific language will override options set in the
+default section.
+
+When :program:`clang-format` formats a file, it auto-detects the language using
+the file name. When formatting standard input or a file that doesn't have the
+extension corresponding to its language, ``-assume-filename=`` option can be
+used to override the file name :program:`clang-format` uses to detect the
+language.
+
+An example of a configuration file for multiple languages:
+
+.. code-block:: yaml
+
+  ---
+  # We'll use defaults from the LLVM style, but with 4 columns indentation.
+  BasedOnStyle: LLVM
+  IndentWidth: 4
+  ---
+  Language: Cpp
+  # Force pointers to the type for C++.
+  DerivePointerAlignment: false
+  PointerAlignment: Left
+  ---
+  Language: JavaScript
+  # Use 100 columns for JS.
+  ColumnLimit: 100
+  ---
+  Language: Proto
+  # Don't format .proto files.
+  DisableFormat: true
+  ...
+
+An easy way to get a valid ``.clang-format`` file containing all configuration
+options of a certain predefined style is:
+
+.. code-block:: console
+
+  clang-format -style=llvm -dump-config > .clang-format
+
+When specifying configuration in the ``-style=`` option, the same configuration
+is applied for all input files. The format of the configuration is:
+
+.. code-block:: console
+
+  -style='{key1: value1, key2: value2, ...}'
+
+
+Disabling Formatting on a Piece of Code
+=======================================
+
+Clang-format understands also special comments that switch formatting in a
+delimited range. The code between a comment ``// clang-format off`` or
+``/* clang-format off */`` up to a comment ``// clang-format on`` or
+``/* clang-format on */`` will not be formatted. The comments themselves
+will be formatted (aligned) normally.
+
+.. code-block:: c++
+
+  int formatted_code;
+  // clang-format off
+      void    unformatted_code  ;
+  // clang-format on
+  void formatted_code_again;
+
+
+Configuring Style in Code
+=========================
+
+When using ``clang::format::reformat(...)`` functions, the format is specified
+by supplying the `clang::format::FormatStyle
+<http://clang.llvm.org/doxygen/structclang_1_1format_1_1FormatStyle.html>`_
+structure.
+
+
+Configurable Format Style Options
+=================================
+
+This section lists the supported style options. Value type is specified for
+each option. For enumeration types possible values are specified both as a C++
+enumeration member (with a prefix, e.g. ``LS_Auto``), and as a value usable in
+the configuration (without a prefix: ``Auto``).
+
+
+**BasedOnStyle** (``string``)
+  The style used for all options not specifically set in the configuration.
+
+  This option is supported only in the :program:`clang-format` configuration
+  (both within ``-style='{...}'`` and the ``.clang-format`` file).
+
+  Possible values:
+
+  * ``LLVM``
+    A style complying with the `LLVM coding standards
+    <http://llvm.org/docs/CodingStandards.html>`_
+  * ``Google``
+    A style complying with `Google's C++ style guide
+    <http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml>`_
+  * ``Chromium``
+    A style complying with `Chromium's style guide
+    <http://www.chromium.org/developers/coding-style>`_
+  * ``Mozilla``
+    A style complying with `Mozilla's style guide
+    <https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style>`_
+  * ``WebKit``
+    A style complying with `WebKit's style guide
+    <http://www.webkit.org/coding/coding-style.html>`_
+
+.. START_FORMAT_STYLE_OPTIONS
+
+**AccessModifierOffset** (``int``)
+  The extra indent or outdent of access modifiers, e.g. ``public:``.
+
+**AlignAfterOpenBracket** (``BracketAlignmentStyle``)
+  If ``true``, horizontally aligns arguments after an open bracket.
+
+  This applies to round brackets (parentheses), angle brackets and square
+  brackets.
+
+  Possible values:
+
+  * ``BAS_Align`` (in configuration: ``Align``)
+    Align parameters on the open bracket, e.g.:
+
+    .. code-block:: c++
+
+      someLongFunction(argument1,
+                       argument2);
+
+  * ``BAS_DontAlign`` (in configuration: ``DontAlign``)
+    Don't align, instead use ``ContinuationIndentWidth``, e.g.:
+
+    .. code-block:: c++
+
+      someLongFunction(argument1,
+          argument2);
+
+  * ``BAS_AlwaysBreak`` (in configuration: ``AlwaysBreak``)
+    Always break after an open bracket, if the parameters don't fit
+    on a single line, e.g.:
+
+    .. code-block:: c++
+
+      someLongFunction(
+          argument1, argument2);
+
+
+
+**AlignConsecutiveAssignments** (``bool``)
+  If ``true``, aligns consecutive assignments.
+
+  This will align the assignment operators of consecutive lines. This
+  will result in formattings like
+
+  .. code-block:: c++
+
+    int aaaa = 12;
+    int b    = 23;
+    int ccc  = 23;
+
+**AlignConsecutiveDeclarations** (``bool``)
+  If ``true``, aligns consecutive declarations.
+
+  This will align the declaration names of consecutive lines. This
+  will result in formattings like
+
+  .. code-block:: c++
+
+    int         aaaa = 12;
+    float       b = 23;
+    std::string ccc = 23;
+
+**AlignEscapedNewlinesLeft** (``bool``)
+  If ``true``, aligns escaped newlines as far left as possible.
+  Otherwise puts them into the right-most column.
+
+  .. code-block:: c++
+
+    true:
+    #define A   \
+      int aaaa; \
+      int b;    \
+      int dddddddddd;
+
+    false:
+    #define A                                                                      \
+      int aaaa;                                                                    \
+      int b;                                                                       \
+      int dddddddddd;
+
+**AlignOperands** (``bool``)
+  If ``true``, horizontally align operands of binary and ternary
+  expressions.
+
+  Specifically, this aligns operands of a single expression that needs to be
+  split over multiple lines, e.g.:
+
+  .. code-block:: c++
+
+    int aaa = bbbbbbbbbbbbbbb +
+              ccccccccccccccc;
+
+**AlignTrailingComments** (``bool``)
+  If ``true``, aligns trailing comments.
+
+  .. code-block:: c++
+
+    true:                                   false:
+    int a;     // My comment a      vs.     int a; // My comment a
+    int b = 2; // comment  b                int b = 2; // comment about b
+
+**AllowAllParametersOfDeclarationOnNextLine** (``bool``)
+  Allow putting all parameters of a function declaration onto
+  the next line even if ``BinPackParameters`` is ``false``.
+
+  .. code-block:: c++
+
+    true:                                   false:
+    myFunction(foo,                 vs.     myFunction(foo, bar, plop);
+               bar,
+               plop);
+
+**AllowShortBlocksOnASingleLine** (``bool``)
+  Allows contracting simple braced statements to a single line.
+
+  E.g., this allows ``if (a) { return; }`` to be put on a single line.
+
+**AllowShortCaseLabelsOnASingleLine** (``bool``)
+  If ``true``, short case labels will be contracted to a single line.
+
+  .. code-block:: c++
+
+    true:                                   false:
+    switch (a) {                    vs.     switch (a) {
+    case 1: x = 1; break;                   case 1:
+    case 2: return;                           x = 1;
+    }                                         break;
+                                            case 2:
+                                              return;
+                                            }
+
+**AllowShortFunctionsOnASingleLine** (``ShortFunctionStyle``)
+  Dependent on the value, ``int f() { return 0; }`` can be put on a
+  single line.
+
+  Possible values:
+
+  * ``SFS_None`` (in configuration: ``None``)
+    Never merge functions into a single line.
+
+  * ``SFS_Empty`` (in configuration: ``Empty``)
+    Only merge empty functions.
+
+    .. code-block:: c++
+
+      void f() { bar(); }
+      void f2() {
+        bar2();
+      }
+
+  * ``SFS_Inline`` (in configuration: ``Inline``)
+    Only merge functions defined inside a class. Implies "empty".
+
+    .. code-block:: c++
+
+      class Foo {
+        void f() { foo(); }
+      };
+
+  * ``SFS_All`` (in configuration: ``All``)
+    Merge all functions fitting on a single line.
+
+    .. code-block:: c++
+
+      class Foo {
+        void f() { foo(); }
+      };
+      void f() { bar(); }
+
+
+
+**AllowShortIfStatementsOnASingleLine** (``bool``)
+  If ``true``, ``if (a) return;`` can be put on a single line.
+
+**AllowShortLoopsOnASingleLine** (``bool``)
+  If ``true``, ``while (true) continue;`` can be put on a single
+  line.
+
+**AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``)
+  The function definition return type breaking style to use.  This
+  option is **deprecated** and is retained for backwards compatibility.
+
+  Possible values:
+
+  * ``DRTBS_None`` (in configuration: ``None``)
+    Break after return type automatically.
+    ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
+
+  * ``DRTBS_All`` (in configuration: ``All``)
+    Always break after the return type.
+
+  * ``DRTBS_TopLevel`` (in configuration: ``TopLevel``)
+    Always break after the return types of top-level functions.
+
+
+
+**AlwaysBreakAfterReturnType** (``ReturnTypeBreakingStyle``)
+  The function declaration return type breaking style to use.
+
+  Possible values:
+
+  * ``RTBS_None`` (in configuration: ``None``)
+    Break after return type automatically.
+    ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
+
+    .. code-block:: c++
+
+      class A {
+        int f() { return 0; };
+      };
+      int f();
+      int f() { return 1; }
+
+  * ``RTBS_All`` (in configuration: ``All``)
+    Always break after the return type.
+
+    .. code-block:: c++
+
+      class A {
+        int
+        f() {
+          return 0;
+        };
+      };
+      int
+      f();
+      int
+      f() {
+        return 1;
+      }
+
+  * ``RTBS_TopLevel`` (in configuration: ``TopLevel``)
+    Always break after the return types of top-level functions.
+
+    .. code-block:: c++
+
+      class A {
+        int f() { return 0; };
+      };
+      int
+      f();
+      int
+      f() {
+        return 1;
+      }
+
+  * ``RTBS_AllDefinitions`` (in configuration: ``AllDefinitions``)
+    Always break after the return type of function definitions.
+
+    .. code-block:: c++
+
+      class A {
+        int
+        f() {
+          return 0;
+        };
+      };
+      int f();
+      int
+      f() {
+        return 1;
+      }
+
+  * ``RTBS_TopLevelDefinitions`` (in configuration: ``TopLevelDefinitions``)
+    Always break after the return type of top-level definitions.
+
+    .. code-block:: c++
+
+      class A {
+        int f() { return 0; };
+      };
+      int f();
+      int
+      f() {
+        return 1;
+      }
+
+
+
+**AlwaysBreakBeforeMultilineStrings** (``bool``)
+  If ``true``, always break before multiline string literals.
+
+  This flag is mean to make cases where there are multiple multiline strings
+  in a file look more consistent. Thus, it will only take effect if wrapping
+  the string at that point leads to it being indented
+  ``ContinuationIndentWidth`` spaces from the start of the line.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     aaaa =                         vs.     aaaa = "bbbb"
+         "bbbb"                                    "cccc";
+         "cccc";
+
+**AlwaysBreakTemplateDeclarations** (``bool``)
+  If ``true``, always break after the ``template<...>`` of a template
+  declaration.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     template <typename T>          vs.     template <typename T> class C {};
+     class C {};
+
+**BinPackArguments** (``bool``)
+  If ``false``, a function call's arguments will either be all on the
+  same line or will have one line each.
+
+  .. code-block:: c++
+
+    true:
+    void f() {
+      f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
+    }
+
+    false:
+    void f() {
+      f(aaaaaaaaaaaaaaaaaaaa,
+        aaaaaaaaaaaaaaaaaaaa,
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
+    }
+
+**BinPackParameters** (``bool``)
+  If ``false``, a function declaration's or function definition's
+  parameters will either all be on the same line or will have one line each.
+
+  .. code-block:: c++
+
+    true:
+    void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
+           int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
+
+    false:
+    void f(int aaaaaaaaaaaaaaaaaaaa,
+           int aaaaaaaaaaaaaaaaaaaa,
+           int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
+
+**BraceWrapping** (``BraceWrappingFlags``)
+  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.
+
+  Nested configuration flags:
+
+
+  * ``bool AfterClass`` Wrap class definitions.
+
+  .. code-block:: c++
+
+    true:
+    class foo {};
+
+    false:
+    class foo
+    {};
+
+  * ``bool AfterControlStatement`` Wrap control statements (``if``/``for``/``while``/``switch``/..).
+
+  .. code-block:: c++
+
+    true:
+    if (foo())
+    {
+    } else
+    {}
+    for (int i = 0; i < 10; ++i)
+    {}
+
+    false:
+    if (foo()) {
+    } else {
+    }
+    for (int i = 0; i < 10; ++i) {
+    }
+
+  * ``bool AfterEnum`` Wrap enum definitions.
+
+  .. code-block:: c++
+
+    true:
+    enum X : int
+    {
+      B
+    };
+
+    false:
+    enum X : int { B };
+
+  * ``bool AfterFunction`` Wrap function definitions.
+
+  .. code-block:: c++
+
+    true:
+    void foo()
+    {
+      bar();
+      bar2();
+    }
+
+    false:
+    void foo() {
+      bar();
+      bar2();
+    }
+
+  * ``bool AfterNamespace`` Wrap namespace definitions.
+
+  .. code-block:: c++
+
+    true:
+    namespace
+    {
+    int foo();
+    int bar();
+    }
+
+    false:
+    namespace {
+    int foo();
+    int bar();
+    }
+
+  * ``bool AfterObjCDeclaration`` Wrap ObjC definitions (``@autoreleasepool``, interfaces, ..).
+
+  * ``bool AfterStruct`` Wrap struct definitions.
+
+  .. code-block:: c++
+
+    true:
+    struct foo
+    {
+      int x;
+    }
+
+    false:
+    struct foo {
+      int x;
+    }
+
+  * ``bool AfterUnion`` Wrap union definitions.
+
+  .. code-block:: c++
+
+    true:
+    union foo
+    {
+      int x;
+    }
+
+    false:
+    union foo {
+      int x;
+    }
+
+  * ``bool BeforeCatch`` Wrap before ``catch``.
+
+  .. code-block:: c++
+
+    true:
+    try {
+      foo();
+    }
+    catch () {
+    }
+
+    false:
+    try {
+      foo();
+    } catch () {
+    }
+
+  * ``bool BeforeElse`` Wrap before ``else``.
+
+  .. code-block:: c++
+
+    true:
+    if (foo()) {
+    }
+    else {
+    }
+
+    false:
+    if (foo()) {
+    } else {
+    }
+
+  * ``bool IndentBraces`` Indent the wrapped braces themselves.
+
+
+**BreakAfterJavaFieldAnnotations** (``bool``)
+  Break after each annotation on a field in Java files.
+
+**BreakBeforeBinaryOperators** (``BinaryOperatorStyle``)
+  The way to wrap binary operators.
+
+  Possible values:
+
+  * ``BOS_None`` (in configuration: ``None``)
+    Break after operators.
+
+    .. code-block:: c++
+
+       LooooooooooongType loooooooooooooooooooooongVariable =
+           someLooooooooooooooooongFunction();
+
+       bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
+                            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
+                        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
+                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
+                        ccccccccccccccccccccccccccccccccccccccccc;
+
+  * ``BOS_NonAssignment`` (in configuration: ``NonAssignment``)
+    Break before operators that aren't assignments.
+
+    .. code-block:: c++
+
+       LooooooooooongType loooooooooooooooooooooongVariable =
+           someLooooooooooooooooongFunction();
+
+       bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                           > ccccccccccccccccccccccccccccccccccccccccc;
+
+  * ``BOS_All`` (in configuration: ``All``)
+    Break before operators.
+
+    .. code-block:: c++
+
+       LooooooooooongType loooooooooooooooooooooongVariable
+           = someLooooooooooooooooongFunction();
+
+       bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+                           > ccccccccccccccccccccccccccccccccccccccccc;
+
+
+
+**BreakBeforeBraces** (``BraceBreakingStyle``)
+  The brace breaking style to use.
+
+  Possible values:
+
+  * ``BS_Attach`` (in configuration: ``Attach``)
+    Always attach braces to surrounding context.
+
+    .. code-block:: c++
+
+      try {
+        foo();
+      } catch () {
+      }
+      void foo() { bar(); }
+      class foo {};
+      if (foo()) {
+      } else {
+      }
+      enum X : int { A, B };
+
+  * ``BS_Linux`` (in configuration: ``Linux``)
+    Like ``Attach``, but break before braces on function, namespace and
+    class definitions.
+
+    .. code-block:: c++
+
+      try {
+        foo();
+      } catch () {
+      }
+      void foo() { bar(); }
+      class foo
+      {
+      };
+      if (foo()) {
+      } else {
+      }
+      enum X : int { A, B };
+
+  * ``BS_Mozilla`` (in configuration: ``Mozilla``)
+    Like ``Attach``, but break before braces on enum, function, and record
+    definitions.
+
+    .. code-block:: c++
+
+      try {
+        foo();
+      } catch () {
+      }
+      void foo() { bar(); }
+      class foo
+      {
+      };
+      if (foo()) {
+      } else {
+      }
+      enum X : int { A, B };
+
+  * ``BS_Stroustrup`` (in configuration: ``Stroustrup``)
+    Like ``Attach``, but break before function definitions, ``catch``, and
+    ``else``.
+
+    .. code-block:: c++
+
+      try {
+        foo();
+      } catch () {
+      }
+      void foo() { bar(); }
+      class foo
+      {
+      };
+      if (foo()) {
+      } else {
+      }
+      enum X : int
+      {
+        A,
+        B
+      };
+
+  * ``BS_Allman`` (in configuration: ``Allman``)
+    Always break before braces.
+
+    .. code-block:: c++
+
+      try {
+        foo();
+      }
+      catch () {
+      }
+      void foo() { bar(); }
+      class foo {
+      };
+      if (foo()) {
+      }
+      else {
+      }
+      enum X : int { A, B };
+
+  * ``BS_GNU`` (in configuration: ``GNU``)
+    Always break before braces and add an extra level of indentation to
+    braces of control statements, not to those of class, function
+    or other definitions.
+
+    .. code-block:: c++
+
+      try
+        {
+          foo();
+        }
+      catch ()
+        {
+        }
+      void foo() { bar(); }
+      class foo
+      {
+      };
+      if (foo())
+        {
+        }
+      else
+        {
+        }
+      enum X : int
+      {
+        A,
+        B
+      };
+
+  * ``BS_WebKit`` (in configuration: ``WebKit``)
+    Like ``Attach``, but break before functions.
+
+    .. code-block:: c++
+
+      try {
+        foo();
+      } catch () {
+      }
+      void foo() { bar(); }
+      class foo {
+      };
+      if (foo()) {
+      } else {
+      }
+      enum X : int { A, B };
+
+  * ``BS_Custom`` (in configuration: ``Custom``)
+    Configure each individual brace in `BraceWrapping`.
+
+
+
+**BreakBeforeInheritanceComma** (``bool``)
+  If ``true``, in the class inheritance expression clang-format will
+  break before ``:`` and ``,`` if there is multiple inheritance.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     class MyClass                  vs.     class MyClass : public X, public Y {
+         : public X                         };
+         , public Y {
+     };
+
+**BreakBeforeTernaryOperators** (``bool``)
+  If ``true``, ternary operators will be placed after line breaks.
+
+  .. code-block:: c++
+
+     true:
+     veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
+         ? firstValue
+         : SecondValueVeryVeryVeryVeryLong;
+
+     true:
+     veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
+         firstValue :
+         SecondValueVeryVeryVeryVeryLong;
+
+**BreakConstructorInitializersBeforeComma** (``bool``)
+  Always break constructor initializers before commas and align
+  the commas with the colon.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     SomeClass::Constructor()       vs.     SomeClass::Constructor() : a(a),
+         : a(a)                                                   b(b),
+         , b(b)                                                   c(c) {}
+         , c(c) {}
+
+**BreakStringLiterals** (``bool``)
+  Allow breaking string literals when formatting.
+
+**ColumnLimit** (``unsigned``)
+  The column limit.
+
+  A column limit of ``0`` means that there is no column limit. In this case,
+  clang-format will respect the input's line breaking decisions within
+  statements unless they contradict other rules.
+
+**CommentPragmas** (``std::string``)
+  A regular expression that describes comments with special meaning,
+  which should not be split into lines or otherwise changed.
+
+  .. code-block:: c++
+
+     // CommentPragmas: '^ FOOBAR pragma:'
+     // Will leave the following line unaffected
+     #include <vector> // FOOBAR pragma: keep
+
+**ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``)
+  If the constructor initializers don't fit on a line, put each
+  initializer on its own line.
+
+  .. code-block:: c++
+
+    true:
+    SomeClass::Constructor()
+        : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
+      return 0;
+    }
+
+    false:
+    SomeClass::Constructor()
+        : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
+          aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
+      return 0;
+    }
+
+**ConstructorInitializerIndentWidth** (``unsigned``)
+  The number of characters to use for indentation of constructor
+  initializer lists.
+
+**ContinuationIndentWidth** (``unsigned``)
+  Indent width for line continuations.
+
+**Cpp11BracedListStyle** (``bool``)
+  If ``true``, format braced lists as best suited for C++11 braced
+  lists.
+
+  Important differences:
+  - No spaces inside the braced list.
+  - No line break before the closing brace.
+  - Indentation with the continuation indent, not with the block indent.
+
+  Fundamentally, C++11 braced lists are formatted exactly like function
+  calls would be formatted in their place. If the braced list follows a name
+  (e.g. a type or variable name), clang-format formats as if the ``{}`` were
+  the parentheses of a function call with that name. If there is no name,
+  a zero-length name is assumed.
+
+**DerivePointerAlignment** (``bool``)
+  If ``true``, analyze the formatted file for the most common
+  alignment of ``&`` and ``*``. ``PointerAlignment`` is then used only as
+  fallback.
+
+**DisableFormat** (``bool``)
+  Disables formatting completely.
+
+**ExperimentalAutoDetectBinPacking** (``bool``)
+  If ``true``, clang-format detects whether function calls and
+  definitions are formatted with one parameter per line.
+
+  Each call can be bin-packed, one-per-line or inconclusive. If it is
+  inconclusive, e.g. completely on one line, but a decision needs to be
+  made, clang-format analyzes whether there are other bin-packed cases in
+  the input file and act accordingly.
+
+  NOTE: This is an experimental flag, that might go away or be renamed. Do
+  not use this in config files, etc. Use at your own risk.
+
+**FixNamespaceComments** (``bool``)
+  If ``true``, clang-format adds missing namespace end comments and
+  fixes invalid existing ones.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     namespace a {                  vs.     namespace a {
+     foo();                                 foo();
+     } // namespace a;                      }
+
+**ForEachMacros** (``std::vector<std::string>``)
+  A vector of macros that should be interpreted as foreach loops
+  instead of as function calls.
+
+  These are expected to be macros of the form:
+
+  .. code-block:: c++
+
+    FOREACH(<variable-declaration>, ...)
+      <loop-body>
+
+  In the .clang-format configuration file, this can be configured like:
+
+  .. code-block:: yaml
+
+    ForEachMacros: ['RANGES_FOR', 'FOREACH']
+
+  For example: BOOST_FOREACH.
+
+**IncludeCategories** (``std::vector<IncludeCategory>``)
+  Regular expressions denoting the different ``#include`` categories
+  used for ordering ``#includes``.
+
+  These regular expressions are matched against the filename of an include
+  (including the <> or "") in order. The value belonging to the first
+  matching regular expression is assigned and ``#includes`` are sorted first
+  according to increasing category number and then alphabetically within
+  each category.
+
+  If none of the regular expressions match, INT_MAX is assigned as
+  category. The main header for a source file automatically gets category 0.
+  so that it is generally kept at the beginning of the ``#includes``
+  (http://llvm.org/docs/CodingStandards.html#include-style). However, you
+  can also assign negative priorities if you have certain headers that
+  always need to be first.
+
+  To configure this in the .clang-format file, use:
+
+  .. code-block:: yaml
+
+    IncludeCategories:
+      - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+        Priority:        2
+      - Regex:           '^(<|"(gtest|isl|json)/)'
+        Priority:        3
+      - Regex:           '.*'
+        Priority:        1
+
+**IncludeIsMainRegex** (``std::string``)
+  Specify a regular expression of suffixes that are allowed in the
+  file-to-main-include mapping.
+
+  When guessing whether a #include is the "main" include (to assign
+  category 0, see above), use this regex of allowed suffixes to the header
+  stem. A partial match is done, so that:
+  - "" means "arbitrary suffix"
+  - "$" means "no suffix"
+
+  For example, if configured to "(_test)?$", then a header a.h would be seen
+  as the "main" include in both a.cc and a_test.cc.
+
+**IndentCaseLabels** (``bool``)
+  Indent case labels one level from the switch statement.
+
+  When ``false``, use the same indentation level as for the switch statement.
+  Switch statement body is always indented one level more than case labels.
+
+**IndentWidth** (``unsigned``)
+  The number of columns to use for indentation.
+
+  .. code-block:: c++
+
+     IndentWidth: 3
+     void f() {
+        someFunction();
+        if (true, false) {
+           f();
+        }
+     }
+
+**IndentWrappedFunctionNames** (``bool``)
+  Indent if a function definition or declaration is wrapped after the
+  type.
+
+**JavaScriptQuotes** (``JavaScriptQuoteStyle``)
+  The JavaScriptQuoteStyle to use for JavaScript strings.
+
+  Possible values:
+
+  * ``JSQS_Leave`` (in configuration: ``Leave``)
+    Leave string quotes as they are.
+
+    .. code-block:: js
+
+       string1 = "foo";
+       string2 = 'bar';
+
+  * ``JSQS_Single`` (in configuration: ``Single``)
+    Always use single quotes.
+
+    .. code-block:: js
+
+       string1 = 'foo';
+       string2 = 'bar';
+
+  * ``JSQS_Double`` (in configuration: ``Double``)
+    Always use double quotes.
+
+    .. code-block:: js
+
+       string1 = "foo";
+       string2 = "bar";
+
+
+
+**JavaScriptWrapImports** (``bool``)
+  Whether to wrap JavaScript import/export statements.
+
+  .. code-block:: js
+
+     true:
+     import {
+         VeryLongImportsAreAnnoying,
+         VeryLongImportsAreAnnoying,
+         VeryLongImportsAreAnnoying,
+     } from 'some/module.js'
+
+     false:
+     import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
+
+**KeepEmptyLinesAtTheStartOfBlocks** (``bool``)
+  If true, empty lines at the start of blocks are kept.
+
+**Language** (``LanguageKind``)
+  Language, this format style is targeted at.
+
+  Possible values:
+
+  * ``LK_None`` (in configuration: ``None``)
+    Do not use.
+
+  * ``LK_Cpp`` (in configuration: ``Cpp``)
+    Should be used for C, C++.
+
+  * ``LK_Java`` (in configuration: ``Java``)
+    Should be used for Java.
+
+  * ``LK_JavaScript`` (in configuration: ``JavaScript``)
+    Should be used for JavaScript.
+
+  * ``LK_ObjC`` (in configuration: ``ObjC``)
+    Should be used for Objective-C, Objective-C++.
+
+  * ``LK_Proto`` (in configuration: ``Proto``)
+    Should be used for Protocol Buffers
+    (https://developers.google.com/protocol-buffers/).
+
+  * ``LK_TableGen`` (in configuration: ``TableGen``)
+    Should be used for TableGen code.
+
+
+
+**MacroBlockBegin** (``std::string``)
+  A regular expression matching macros that start a block.
+
+  .. code-block:: c++
+
+     # With:
+     MacroBlockBegin: "^NS_MAP_BEGIN|\
+     NS_TABLE_HEAD$"
+     MacroBlockEnd: "^\
+     NS_MAP_END|\
+     NS_TABLE_.*_END$"
+
+     NS_MAP_BEGIN
+       foo();
+     NS_MAP_END
+
+     NS_TABLE_HEAD
+       bar();
+     NS_TABLE_FOO_END
+
+     # Without:
+     NS_MAP_BEGIN
+     foo();
+     NS_MAP_END
+
+     NS_TABLE_HEAD
+     bar();
+     NS_TABLE_FOO_END
+
+**MacroBlockEnd** (``std::string``)
+  A regular expression matching macros that end a block.
+
+**MaxEmptyLinesToKeep** (``unsigned``)
+  The maximum number of consecutive empty lines to keep.
+
+  .. code-block:: c++
+
+     MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
+     int f() {                              int f() {
+       int = 1;                                 int i = 1;
+                                                i = foo();
+       i = foo();                               return i;
+                                            }
+       return i;
+     }
+
+**NamespaceIndentation** (``NamespaceIndentationKind``)
+  The indentation used for namespaces.
+
+  Possible values:
+
+  * ``NI_None`` (in configuration: ``None``)
+    Don't indent in namespaces.
+
+    .. code-block:: c++
+
+       namespace out {
+       int i;
+       namespace in {
+       int i;
+       }
+       }
+
+  * ``NI_Inner`` (in configuration: ``Inner``)
+    Indent only in inner namespaces (nested in other namespaces).
+
+    .. code-block:: c++
+
+       namespace out {
+       int i;
+       namespace in {
+         int i;
+       }
+       }
+
+  * ``NI_All`` (in configuration: ``All``)
+    Indent in all namespaces.
+
+    .. code-block:: c++
+
+       namespace out {
+         int i;
+         namespace in {
+           int i;
+         }
+       }
+
+
+
+**ObjCBlockIndentWidth** (``unsigned``)
+  The number of characters to use for indentation of ObjC blocks.
+
+**ObjCSpaceAfterProperty** (``bool``)
+  Add a space after ``@property`` in Objective-C, i.e. use
+  ``@property (readonly)`` instead of ``@property(readonly)``.
+
+**ObjCSpaceBeforeProtocolList** (``bool``)
+  Add a space in front of an Objective-C protocol list, i.e. use
+  ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
+
+**PenaltyBreakBeforeFirstCallParameter** (``unsigned``)
+  The penalty for breaking a function call after ``call(``.
+
+**PenaltyBreakComment** (``unsigned``)
+  The penalty for each line break introduced inside a comment.
+
+**PenaltyBreakFirstLessLess** (``unsigned``)
+  The penalty for breaking before the first ``<<``.
+
+**PenaltyBreakString** (``unsigned``)
+  The penalty for each line break introduced inside a string literal.
+
+**PenaltyExcessCharacter** (``unsigned``)
+  The penalty for each character outside of the column limit.
+
+**PenaltyReturnTypeOnItsOwnLine** (``unsigned``)
+  Penalty for putting the return type of a function onto its own
+  line.
+
+**PointerAlignment** (``PointerAlignmentStyle``)
+  Pointer and reference alignment style.
+
+  Possible values:
+
+  * ``PAS_Left`` (in configuration: ``Left``)
+    Align pointer to the left.
+
+    .. code-block:: c++
+
+      int* a;
+
+  * ``PAS_Right`` (in configuration: ``Right``)
+    Align pointer to the right.
+
+    .. code-block:: c++
+
+      int *a;
+
+  * ``PAS_Middle`` (in configuration: ``Middle``)
+    Align pointer in the middle.
+
+    .. code-block:: c++
+
+      int * a;
+
+
+
+**PPDirectiveIndentation ** (``PPDirectiveIndentation Kind``)
+  The indentation used for preprocessor directives.
+
+  Possible values:
+
+  * ``PPDI_None`` (in configuration: ``None``)
+    Don't indent preprocessor directives.
+
+  * ``PPDI_All`` (in configuration: ``All``)
+    Indent all preprocessor directives.
+
+
+
+**ReflowComments** (``bool``)
+  If ``true``, clang-format will attempt to re-flow comments.
+
+  .. code-block:: c++
+
+     false:
+     // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
+     /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
+
+     true:
+     // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
+     // information
+     /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
+      * information */
+
+**SortIncludes** (``bool``)
+  If ``true``, clang-format will sort ``#includes``.
+
+  .. code-block:: c++
+
+     false:                                 true:
+     #include "b.h"                 vs.     #include "a.h"
+     #include "a.h"                         #include "b.h"
+
+**SpaceAfterCStyleCast** (``bool``)
+  If ``true``, a space is inserted after C style casts.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     (int)i;                        vs.     (int) i;
+
+**SpaceAfterTemplateKeyword** (``bool``)
+  If ``true``, a space will be inserted after the 'template' keyword.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     template <int> void foo();     vs.     template<int> void foo();
+
+**SpaceBeforeAssignmentOperators** (``bool``)
+  If ``false``, spaces will be removed before assignment operators.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     int a = 5;                     vs.     int a=5;
+     a += 42                                a+=42;
+
+**SpaceBeforeParens** (``SpaceBeforeParensOptions``)
+  Defines in which cases to put a space before opening parentheses.
+
+  Possible values:
+
+  * ``SBPO_Never`` (in configuration: ``Never``)
+    Never put a space before opening parentheses.
+
+    .. code-block:: c++
+
+       void f() {
+         if(true) {
+           f();
+         }
+       }
+
+  * ``SBPO_ControlStatements`` (in configuration: ``ControlStatements``)
+    Put a space before opening parentheses only after control statement
+    keywords (``for/if/while...``).
+
+    .. code-block:: c++
+
+       void f() {
+         if (true) {
+           f();
+         }
+       }
+
+  * ``SBPO_Always`` (in configuration: ``Always``)
+    Always put a space before opening parentheses, except when it's
+    prohibited by the syntax rules (in function-like macro definitions) or
+    when determined by other style rules (after unary operators, opening
+    parentheses, etc.)
+
+    .. code-block:: c++
+
+       void f () {
+         if (true) {
+           f ();
+         }
+       }
+
+
+
+**SpaceInEmptyParentheses** (``bool``)
+  If ``true``, spaces may be inserted into ``()``.
+
+  .. code-block:: c++
+
+     true:                                false:
+     void f( ) {                    vs.   void f() {
+       int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
+       if (true) {                          if (true) {
+         f( );                                f();
+       }                                    }
+     }                                    }
+
+**SpacesBeforeTrailingComments** (``unsigned``)
+  The number of spaces before trailing line comments
+  (``//`` - comments).
+
+  This does not affect trailing block comments (``/*`` - comments) as
+  those commonly have different usage patterns and a number of special
+  cases.
+
+  .. code-block:: c++
+
+     SpacesBeforeTrailingComments: 3
+     void f() {
+       if (true) {   // foo1
+         f();        // bar
+       }             // foo
+     }
+
+**SpacesInAngles** (``bool``)
+  If ``true``, spaces will be inserted after ``<`` and before ``>``
+  in template argument lists.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     static_cast< int >(arg);       vs.     static_cast<int>(arg);
+     std::function< void(int) > fct;        std::function<void(int)> fct;
+
+**SpacesInCStyleCastParentheses** (``bool``)
+  If ``true``, spaces may be inserted into C style casts.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     x = ( int32 )y                 vs.     x = (int32)y
+
+**SpacesInContainerLiterals** (``bool``)
+  If ``true``, spaces are inserted inside container literals (e.g.
+  ObjC and Javascript array and dict literals).
+
+  .. code-block:: js
+
+     true:                                  false:
+     var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
+     f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
+
+**SpacesInParentheses** (``bool``)
+  If ``true``, spaces will be inserted after ``(`` and before ``)``.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
+
+**SpacesInSquareBrackets** (``bool``)
+  If ``true``, spaces will be inserted after ``[`` and before ``]``.
+  Lambdas or unspecified size array declarations will not be affected.
+
+  .. code-block:: c++
+
+     true:                                  false:
+     int a[ 5 ];                    vs.     int a[5];
+     std::unique_ptr<int[]> foo() {} // Won't be affected
+
+**Standard** (``LanguageStandard``)
+  Format compatible with this standard, e.g. use ``A<A<int> >``
+  instead of ``A<A<int>>`` for ``LS_Cpp03``.
+
+  Possible values:
+
+  * ``LS_Cpp03`` (in configuration: ``Cpp03``)
+    Use C++03-compatible syntax.
+
+  * ``LS_Cpp11`` (in configuration: ``Cpp11``)
+    Use features of C++11 (e.g. ``A<A<int>>`` instead of ``A<A<int> >``).
+
+  * ``LS_Auto`` (in configuration: ``Auto``)
+    Automatic detection based on the input.
+
+
+
+**TabWidth** (``unsigned``)
+  The number of columns used for tab stops.
+
+**UseTab** (``UseTabStyle``)
+  The way to use tab characters in the resulting file.
+
+  Possible values:
+
+  * ``UT_Never`` (in configuration: ``Never``)
+    Never use tab.
+
+  * ``UT_ForIndentation`` (in configuration: ``ForIndentation``)
+    Use tabs only for indentation.
+
+  * ``UT_ForContinuationAndIndentation`` (in configuration: ``ForContinuationAndIndentation``)
+    Use tabs only for line continuation and indentation.
+
+  * ``UT_Always`` (in configuration: ``Always``)
+    Use tabs whenever we need to fill whitespace that spans at least from
+    one tab stop to the next one.
+
+
+
+.. END_FORMAT_STYLE_OPTIONS
+
+Adding additional style options
+===============================
+
+Each additional style option adds costs to the clang-format project. Some of
+these costs affect the clang-format development itself, as we need to make
+sure that any given combination of options work and that new features don't
+break any of the existing options in any way. There are also costs for end users
+as options become less discoverable and people have to think about and make a
+decision on options they don't really care about.
+
+The goal of the clang-format project is more on the side of supporting a
+limited set of styles really well as opposed to supporting every single style
+used by a codebase somewhere in the wild. Of course, we do want to support all
+major projects and thus have established the following bar for adding style
+options. Each new style option must ..
+
+  * be used in a project of significant size (have dozens of contributors)
+  * have a publicly accessible style guide
+  * have a person willing to contribute and maintain patches
+
+Examples
+========
+
+A style similar to the `Linux Kernel style
+<https://www.kernel.org/doc/Documentation/CodingStyle>`_:
+
+.. code-block:: yaml
+
+  BasedOnStyle: LLVM
+  IndentWidth: 8
+  UseTab: Always
+  BreakBeforeBraces: Linux
+  AllowShortIfStatementsOnASingleLine: false
+  IndentCaseLabels: false
+
+The result is (imagine that tabs are used for indentation here):
+
+.. code-block:: c++
+
+  void test()
+  {
+          switch (x) {
+          case 0:
+          case 1:
+                  do_something();
+                  break;
+          case 2:
+                  do_something_else();
+                  break;
+          default:
+                  break;
+          }
+          if (condition)
+                  do_something_completely_different();
+
+          if (x == y) {
+                  q();
+          } else if (x > y) {
+                  w();
+          } else {
+                  r();
+          }
+  }
+
+A style similar to the default Visual Studio formatting style:
+
+.. code-block:: yaml
+
+  UseTab: Never
+  IndentWidth: 4
+  BreakBeforeBraces: Allman
+  AllowShortIfStatementsOnASingleLine: false
+  IndentCaseLabels: false
+  ColumnLimit: 0
+
+The result is:
+
+.. code-block:: c++
+
+  void test()
+  {
+      switch (suffix)
+      {
+      case 0:
+      case 1:
+          do_something();
+          break;
+      case 2:
+          do_something_else();
+          break;
+      default:
+          break;
+      }
+      if (condition)
+          do_somthing_completely_different();
+
+      if (x == y)
+      {
+          q();
+      }
+      else if (x > y)
+      {
+          w();
+      }
+      else
+      {
+          r();
+      }
+  }

include/clang/Format/Format.h

-//===--- Format.h - Format C++ code -----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// Various functions to configurably format source code.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_FORMAT_FORMAT_H
-#define LLVM_CLANG_FORMAT_FORMAT_H
-
-#include "clang/Basic/LangOptions.h"
-#include "clang/Tooling/Core/Replacement.h"
-#include "llvm/ADT/ArrayRef.h"
-#include <system_error>
-
-namespace clang {
-
-class Lexer;
-class SourceManager;
-class DiagnosticConsumer;
-
-namespace vfs {
-class FileSystem;
-}
-
-namespace format {
-
-enum class ParseError { Success = 0, Error, Unsuitable };
-class ParseErrorCategory final : public std::error_category {
-public:
-  const char *name() const noexcept override;
-  std::string message(int EV) const override;
-};
-const std::error_category &getParseCategory();
-std::error_code make_error_code(ParseError e);
-
-/// \brief The ``FormatStyle`` is used to configure the formatting to follow
-/// specific guidelines.
-struct FormatStyle {
-  /// \brief The extra indent or outdent of access modifiers, e.g. ``public:``.
-  int AccessModifierOffset;
-
-  /// \brief Different styles for aligning after open brackets.
-  enum BracketAlignmentStyle {
-    /// \brief Align parameters on the open bracket, e.g.:
-    /// \code
-    ///   someLongFunction(argument1,
-    ///                    argument2);
-    /// \endcode
-    BAS_Align,
-    /// \brief Don't align, instead use ``ContinuationIndentWidth``, e.g.:
-    /// \code
-    ///   someLongFunction(argument1,
-    ///       argument2);
-    /// \endcode
-    BAS_DontAlign,
-    /// \brief Always break after an open bracket, if the parameters don't fit
-    /// on a single line, e.g.:
-    /// \code
-    ///   someLongFunction(
-    ///       argument1, argument2);
-    /// \endcode
-    BAS_AlwaysBreak,
-  };
-
-  /// \brief If ``true``, horizontally aligns arguments after an open bracket.
-  ///
-  /// This applies to round brackets (parentheses), angle brackets and square
-  /// brackets.
-  BracketAlignmentStyle AlignAfterOpenBracket;
-
-  /// \brief If ``true``, aligns consecutive assignments.
-  ///
-  /// This will align the assignment operators of consecutive lines. This
-  /// will result in formattings like
-  /// \code
-  ///   int aaaa = 12;
-  ///   int b    = 23;
-  ///   int ccc  = 23;
-  /// \endcode
-  bool AlignConsecutiveAssignments;
-
-  /// \brief If ``true``, aligns consecutive declarations.
-  ///
-  /// This will align the declaration names of consecutive lines. This
-  /// will result in formattings like
-  /// \code
-  ///   int         aaaa = 12;
-  ///   float       b = 23;
-  ///   std::string ccc = 23;
-  /// \endcode
-  bool AlignConsecutiveDeclarations;
-
-  /// \brief If ``true``, aligns escaped newlines as far left as possible.
-  /// Otherwise puts them into the right-most column.
-  /// \code
-  ///   true:
-  ///   #define A   \
-  ///     int aaaa; \
-  ///     int b;    \
-  ///     int dddddddddd;
-  ///
-  ///   false:
-  ///   #define A                                                                      \
-  ///     int aaaa;                                                                    \
-  ///     int b;                                                                       \
-  ///     int dddddddddd;
-  /// \endcode
-  bool AlignEscapedNewlinesLeft;
-
-  /// \brief If ``true``, horizontally align operands of binary and ternary
-  /// expressions.
-  ///
-  /// Specifically, this aligns operands of a single expression that needs to be
-  /// split over multiple lines, e.g.:
-  /// \code
-  ///   int aaa = bbbbbbbbbbbbbbb +
-  ///             ccccccccccccccc;
-  /// \endcode
-  bool AlignOperands;
-
-  /// \brief If ``true``, aligns trailing comments.
-  /// \code
-  ///   true:                                   false:
-  ///   int a;     // My comment a      vs.     int a; // My comment a
-  ///   int b = 2; // comment  b                int b = 2; // comment about b
-  /// \endcode
-  bool AlignTrailingComments;
-
-  /// \brief Allow putting all parameters of a function declaration onto
-  /// the next line even if ``BinPackParameters`` is ``false``.
-  /// \code
-  ///   true:                                   false:
-  ///   myFunction(foo,                 vs.     myFunction(foo, bar, plop);
-  ///              bar,
-  ///              plop);
-  /// \endcode
-  bool AllowAllParametersOfDeclarationOnNextLine;
-
-  /// \brief Allows contracting simple braced statements to a single line.
-  ///
-  /// E.g., this allows ``if (a) { return; }`` to be put on a single line.
-  bool AllowShortBlocksOnASingleLine;
-
-  /// \brief If ``true``, short case labels will be contracted to a single line.
-  /// \code
-  ///   true:                                   false:
-  ///   switch (a) {                    vs.     switch (a) {
-  ///   case 1: x = 1; break;                   case 1:
-  ///   case 2: return;                           x = 1;
-  ///   }                                         break;
-  ///                                           case 2:
-  ///                                             return;
-  ///                                           }
-  /// \endcode
-  bool AllowShortCaseLabelsOnASingleLine;
-
-  /// \brief Different styles for merging short functions containing at most one
-  /// statement.
-  enum ShortFunctionStyle {
-    /// \brief Never merge functions into a single line.
-    SFS_None,
-    /// \brief Only merge empty functions.
-    /// \code
-    ///   void f() { bar(); }
-    ///   void f2() {
-    ///     bar2();
-    ///   }
-    /// \endcode
-    SFS_Empty,
-    /// \brief Only merge functions defined inside a class. Implies "empty".
-    /// \code
-    ///   class {
-    ///     void f() { foo(); }
-    ///   };
-    /// \endcode
-    SFS_Inline,
-    /// \brief Merge all functions fitting on a single line.
-    /// \code
-    ///   class {
-    ///     void f() { foo(); }
-    ///   };
-    ///   void f() { bar(); }
-    /// \endcode
-    SFS_All,
-  };
-
-  /// \brief Dependent on the value, ``int f() { return 0; }`` can be put on a
-  /// single line.
-  ShortFunctionStyle AllowShortFunctionsOnASingleLine;
-
-  /// \brief If ``true``, ``if (a) return;`` can be put on a single line.
-  bool AllowShortIfStatementsOnASingleLine;
-
-  /// \brief If ``true``, ``while (true) continue;`` can be put on a single
-  /// line.
-  bool AllowShortLoopsOnASingleLine;
-
-  /// \brief Different ways to break after the function definition return type.
-  /// This option is **deprecated** and is retained for backwards compatibility.
-  enum DefinitionReturnTypeBreakingStyle {
-    /// Break after return type automatically.
-    /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
-    DRTBS_None,
-    /// Always break after the return type.
-    DRTBS_All,
-    /// Always break after the return types of top-level functions.
-    DRTBS_TopLevel,
-  };
-
-  /// \brief Different ways to break after the function definition or
-  /// declaration return type.
-  enum ReturnTypeBreakingStyle {
-    /// Break after return type automatically.
-    /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
-    /// \code
-    ///   class A {
-    ///     int f() { return 0; };
-    ///   };
-    ///   int f();
-    ///   int f() { return 1; }
-    /// \endcode
-    RTBS_None,
-    /// Always break after the return type.
-    /// \code
-    ///   class A {
-    ///     int
-    ///     f() {
-    ///       return 0;
-    ///     };
-    ///   };
-    ///   int
-    ///   f();
-    ///   int
-    ///   f() {
-    ///     return 1;
-    ///   }
-    /// \endcode
-    RTBS_All,
-    /// Always break after the return types of top-level functions.
-    /// \code
-    ///   class A {
-    ///     int f() { return 0; };
-    ///   };
-    ///   int
-    ///   f();
-    ///   int
-    ///   f() {
-    ///     return 1;
-    ///   }
-    /// \endcode
-    RTBS_TopLevel,
-    /// Always break after the return type of function definitions.
-    /// \code
-    ///   class A {
-    ///     int
-    ///     f() {
-    ///       return 0;
-    ///     };
-    ///   };
-    ///   int f();
-    ///   int
-    ///   f() {
-    ///     return 1;
-    ///   }
-    /// \endcode
-    RTBS_AllDefinitions,
-    /// Always break after the return type of top-level definitions.
-    /// \code
-    ///   class A {
-    ///     int f() { return 0; };
-    ///   };
-    ///   int f();
-    ///   int
-    ///   f() {
-    ///     return 1;
-    ///   }
-    /// \endcode
-    RTBS_TopLevelDefinitions,
-  };
-
-  /// \brief The function definition return type breaking style to use.  This
-  /// option is **deprecated** and is retained for backwards compatibility.
-  DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
-
-  /// \brief The function declaration return type breaking style to use.
-  ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;
-
-  /// \brief If ``true``, always break before multiline string literals.
-  ///
-  /// This flag is mean to make cases where there are multiple multiline strings
-  /// in a file look more consistent. Thus, it will only take effect if wrapping
-  /// the string at that point leads to it being indented
-  /// ``ContinuationIndentWidth`` spaces from the start of the line.
-  /// \code
-  ///    true:                                  false:
-  ///    aaaa =                         vs.     aaaa = "bbbb"
-  ///        "bbbb"                                    "cccc";
-  ///        "cccc";
-  /// \endcode
-  bool AlwaysBreakBeforeMultilineStrings;
-
-  /// \brief If ``true``, always break after the ``template<...>`` of a template
-  /// declaration.
-  /// \code
-  ///    true:                                  false:
-  ///    template <typename T>          vs.     template <typename T> class C {};
-  ///    class C {};
-  /// \endcode
-  bool AlwaysBreakTemplateDeclarations;
-
-  /// \brief If ``false``, a function call's arguments will either be all on the
-  /// same line or will have one line each.
-  /// \code
-  ///   true:
-  ///   void f() {
-  ///     f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
-  ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
-  ///   }
-  ///
-  ///   false:
-  ///   void f() {
-  ///     f(aaaaaaaaaaaaaaaaaaaa,
-  ///       aaaaaaaaaaaaaaaaaaaa,
-  ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
-  ///   }
-  /// \endcode
-  bool BinPackArguments;
-
-  /// \brief If ``false``, a function declaration's or function definition's
-  /// parameters will either all be on the same line or will have one line each.
-  /// \code
-  ///   true:
-  ///   void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
-  ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
-  ///
-  ///   false:
-  ///   void f(int aaaaaaaaaaaaaaaaaaaa,
-  ///          int aaaaaaaaaaaaaaaaaaaa,
-  ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
-  /// \endcode
-  bool BinPackParameters;
-
-  /// \brief The style of breaking before or after binary operators.
-  enum BinaryOperatorStyle {
-    /// Break after operators.
-    /// \code
-    ///    LooooooooooongType loooooooooooooooooooooongVariable =
-    ///        someLooooooooooooooooongFunction();
-    ///
-    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
-    ///                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
-    ///                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
-    ///                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
-    ///                     ccccccccccccccccccccccccccccccccccccccccc;
-    /// \endcode
-    BOS_None,
-    /// Break before operators that aren't assignments.
-    /// \code
-    ///    LooooooooooongType loooooooooooooooooooooongVariable =
-    ///        someLooooooooooooooooongFunction();
-    ///
-    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                         + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                        > ccccccccccccccccccccccccccccccccccccccccc;
-    /// \endcode
-    BOS_NonAssignment,
-    /// Break before operators.
-    /// \code
-    ///    LooooooooooongType loooooooooooooooooooooongVariable
-    ///        = someLooooooooooooooooongFunction();
-    ///
-    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                         + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    ///                        > ccccccccccccccccccccccccccccccccccccccccc;
-    /// \endcode
-    BOS_All,
-  };
-
-  /// \brief The way to wrap binary operators.
-  BinaryOperatorStyle BreakBeforeBinaryOperators;
-
-  /// \brief Different ways to attach braces to their surrounding context.
-  enum BraceBreakingStyle {
-    /// Always attach braces to surrounding context.
-    /// \code
-    ///   try {
-    ///     foo();
-    ///   } catch () {
-    ///   }
-    ///   void foo() { bar(); }
-    ///   class foo {};
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    ///   enum X : int { A, B };
-    /// \endcode
-    BS_Attach,
-    /// Like ``Attach``, but break before braces on function, namespace and
-    /// class definitions.
-    /// \code
-    ///   try {
-    ///     foo();
-    ///   } catch () {
-    ///   }
-    ///   void foo() { bar(); }
-    ///   class foo
-    ///   {
-    ///   };
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    ///   enum X : int { A, B };
-    /// \endcode
-    BS_Linux,
-    /// Like ``Attach``, but break before braces on enum, function, and record
-    /// definitions.
-    /// \code
-    ///   try {
-    ///     foo();
-    ///   } catch () {
-    ///   }
-    ///   void foo() { bar(); }
-    ///   class foo
-    ///   {
-    ///   };
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    ///   enum X : int { A, B };
-    /// \endcode
-    BS_Mozilla,
-    /// Like ``Attach``, but break before function definitions, ``catch``, and
-    /// ``else``.
-    /// \code
-    ///   try {
-    ///     foo();
-    ///   } catch () {
-    ///   }
-    ///   void foo() { bar(); }
-    ///   class foo
-    ///   {
-    ///   };
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    ///   enum X : int
-    ///   {
-    ///     A,
-    ///     B
-    ///   };
-    /// \endcode
-    BS_Stroustrup,
-    /// Always break before braces.
-    /// \code
-    ///   try {
-    ///     foo();
-    ///   }
-    ///   catch () {
-    ///   }
-    ///   void foo() { bar(); }
-    ///   class foo {
-    ///   };
-    ///   if (foo()) {
-    ///   }
-    ///   else {
-    ///   }
-    ///   enum X : int { A, B };
-    /// \endcode
-    BS_Allman,
-    /// Always break before braces and add an extra level of indentation to
-    /// braces of control statements, not to those of class, function
-    /// or other definitions.
-    /// \code
-    ///   try
-    ///     {
-    ///       foo();
-    ///     }
-    ///   catch ()
-    ///     {
-    ///     }
-    ///   void foo() { bar(); }
-    ///   class foo
-    ///   {
-    ///   };
-    ///   if (foo())
-    ///     {
-    ///     }
-    ///   else
-    ///     {
-    ///     }
-    ///   enum X : int
-    ///   {
-    ///     A,
-    ///     B
-    ///   };
-    /// \endcode
-    BS_GNU,
-    /// Like ``Attach``, but break before functions.
-    /// \code
-    ///   try {
-    ///     foo();
-    ///   } catch () {
-    ///   }
-    ///   void foo() { bar(); }
-    ///   class foo {
-    ///   };
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    ///   enum X : int { A, B };
-    /// \endcode
-    BS_WebKit,
-    /// Configure each individual brace in `BraceWrapping`.
-    BS_Custom
-  };
-
-  /// \brief The brace breaking style to use.
-  BraceBreakingStyle BreakBeforeBraces;
-
-  /// \brief Precise control over the wrapping of braces.
-  /// \code
-  ///   # Should be declared this way:
-  ///   BreakBeforeBraces: Custom
-  ///   BraceWrapping:
-  ///       AfterClass: true
-  /// \endcode
-  struct BraceWrappingFlags {
-    /// \brief Wrap class definitions.
-    /// \code
-    ///   true:
-    ///   class foo {};
-    ///
-    ///   false:
-    ///   class foo
-    ///   {};
-    /// \endcode
-    bool AfterClass;
-    /// \brief Wrap control statements (``if``/``for``/``while``/``switch``/..).
-    /// \code
-    ///   true:
-    ///   if (foo())
-    ///   {
-    ///   } else
-    ///   {}
-    ///   for (int i = 0; i < 10; ++i)
-    ///   {}
-    ///
-    ///   false:
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    ///   for (int i = 0; i < 10; ++i) {
-    ///   }
-    /// \endcode
-    bool AfterControlStatement;
-    /// \brief Wrap enum definitions.
-    /// \code
-    ///   true:
-    ///   enum X : int
-    ///   {
-    ///     B
-    ///   };
-    ///
-    ///   false:
-    ///   enum X : int { B };
-    /// \endcode
-    bool AfterEnum;
-    /// \brief Wrap function definitions.
-    /// \code
-    ///   true:
-    ///   void foo()
-    ///   {
-    ///     bar();
-    ///     bar2();
-    ///   }
-    ///
-    ///   false:
-    ///   void foo() {
-    ///     bar();
-    ///     bar2();
-    ///   }
-    /// \endcode
-    bool AfterFunction;
-    /// \brief Wrap namespace definitions.
-    /// \code
-    ///   true:
-    ///   namespace
-    ///   {
-    ///   int foo();
-    ///   int bar();
-    ///   }
-    ///
-    ///   false:
-    ///   namespace {
-    ///   int foo();
-    ///   int bar();
-    ///   }
-    /// \endcode
-    bool AfterNamespace;
-    /// \brief Wrap ObjC definitions (``@autoreleasepool``, interfaces, ..).
-    bool AfterObjCDeclaration;
-    /// \brief Wrap struct definitions.
-    /// \code
-    ///   true:
-    ///   struct foo
-    ///   {
-    ///     int x;
-    ///   }
-    ///
-    ///   false:
-    ///   struct foo {
-    ///     int x;
-    ///   }
-    /// \endcode
-    bool AfterStruct;
-    /// \brief Wrap union definitions.
-    /// \code
-    ///   true:
-    ///   union foo
-    ///   {
-    ///     int x;
-    ///   }
-    ///
-    ///   false:
-    ///   union foo {
-    ///     int x;
-    ///   }
-    /// \endcode
-    bool AfterUnion;
-    /// \brief Wrap before ``catch``.
-    /// \code
-    ///   true:
-    ///   try {
-    ///     foo();
-    ///   }
-    ///   catch () {
-    ///   }
-    ///
-    ///   false:
-    ///   try {
-    ///     foo();
-    ///   } catch () {
-    ///   }
-    /// \endcode
-    bool BeforeCatch;
-    /// \brief Wrap before ``else``.
-    /// \code
-    ///   true:
-    ///   if (foo()) {
-    ///   }
-    ///   else {
-    ///   }
-    ///
-    ///   false:
-    ///   if (foo()) {
-    ///   } else {
-    ///   }
-    /// \endcode
-    bool BeforeElse;
-    /// \brief Indent the wrapped braces themselves.
-    bool IndentBraces;
-  };
-
-  /// \brief 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.
-  BraceWrappingFlags BraceWrapping;
-
-  /// \brief If ``true``, ternary operators will be placed after line breaks.
-  /// \code
-  ///    true:
-  ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
-  ///        ? firstValue
-  ///        : SecondValueVeryVeryVeryVeryLong;
-  ///
-  ///    true:
-  ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
-  ///        firstValue :
-  ///        SecondValueVeryVeryVeryVeryLong;
-  /// \endcode
-  bool BreakBeforeTernaryOperators;
-
-  /// \brief Always break constructor initializers before commas and align
-  /// the commas with the colon.
-  /// \code
-  ///    true:                                  false:
-  ///    SomeClass::Constructor()       vs.     SomeClass::Constructor() : a(a),
-  ///        : a(a)                                                   b(b),
-  ///        , b(b)                                                   c(c) {}
-  ///        , c(c) {}
-  /// \endcode
-  bool BreakConstructorInitializersBeforeComma;
-
-  /// \brief Break after each annotation on a field in Java files.
-  bool BreakAfterJavaFieldAnnotations;
-
-  /// \brief Allow breaking string literals when formatting.
-  bool BreakStringLiterals;
-
-  /// \brief The column limit.
-  ///
-  /// A column limit of ``0`` means that there is no column limit. In this case,
-  /// clang-format will respect the input's line breaking decisions within
-  /// statements unless they contradict other rules.
-  unsigned ColumnLimit;
-
-  /// \brief A regular expression that describes comments with special meaning,
-  /// which should not be split into lines or otherwise changed.
-  /// \code
-  ///    CommentPragmas: '^ FOOBAR pragma:'
-  ///    // Will leave the following line unaffected
-  ///    #include <vector> // FOOBAR pragma: keep
-  /// \endcode
-  std::string CommentPragmas;
-
-  /// \brief If ``true``, in the class inheritance expression clang-format will
-  /// break before ``:`` and ``,`` if there is multiple inheritance.
-  /// \code
-  ///    true:                                  false:
-  ///    class MyClass                  vs.     class MyClass : public X, public Y {
-  ///        : public X                         };
-  ///        , public Y {
-  ///    };
-  /// \endcode
-  bool BreakBeforeInheritanceComma;
-
-  /// \brief If the constructor initializers don't fit on a line, put each
-  /// initializer on its own line.
-  /// \code
-  ///   true:
-  ///   SomeClass::Constructor()
-  ///       : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
-  ///     return 0;
-  ///   }
-  ///
-  ///   false:
-  ///   SomeClass::Constructor()
-  ///       : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
-  ///         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
-  ///     return 0;
-  ///   }
-  /// \endcode
-  bool ConstructorInitializerAllOnOneLineOrOnePerLine;
-
-  /// \brief The number of characters to use for indentation of constructor
-  /// initializer lists.
-  unsigned ConstructorInitializerIndentWidth;
-
-  /// \brief Indent width for line continuations.
-  unsigned ContinuationIndentWidth;
-
-  /// \brief If ``true``, format braced lists as best suited for C++11 braced
-  /// lists.
-  ///
-  /// Important differences:
-  /// - No spaces inside the braced list.
-  /// - No line break before the closing brace.
-  /// - Indentation with the continuation indent, not with the block indent.
-  ///
-  /// Fundamentally, C++11 braced lists are formatted exactly like function
-  /// calls would be formatted in their place. If the braced list follows a name
-  /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
-  /// the parentheses of a function call with that name. If there is no name,
-  /// a zero-length name is assumed.
-  bool Cpp11BracedListStyle;
-
-  /// \brief If ``true``, analyze the formatted file for the most common
-  /// alignment of ``&`` and ``*``. ``PointerAlignment`` is then used only as
-  /// fallback.
-  bool DerivePointerAlignment;
-
-  /// \brief Disables formatting completely.
-  bool DisableFormat;
-
-  /// \brief If ``true``, clang-format detects whether function calls and
-  /// definitions are formatted with one parameter per line.
-  ///
-  /// Each call can be bin-packed, one-per-line or inconclusive. If it is
-  /// inconclusive, e.g. completely on one line, but a decision needs to be
-  /// made, clang-format analyzes whether there are other bin-packed cases in
-  /// the input file and act accordingly.
-  ///
-  /// NOTE: This is an experimental flag, that might go away or be renamed. Do
-  /// not use this in config files, etc. Use at your own risk.
-  bool ExperimentalAutoDetectBinPacking;
-
-  /// \brief If ``true``, clang-format adds missing namespace end comments and
-  /// fixes invalid existing ones.
-  /// \code
-  ///    true:                                  false:
-  ///    namespace a {                  vs.     namespace a {
-  ///    foo();                                 foo();
-  ///    } // namespace a;                      }
-  /// \endcode
-  bool FixNamespaceComments;
-
-  /// \brief A vector of macros that should be interpreted as foreach loops
-  /// instead of as function calls.
-  ///
-  /// These are expected to be macros of the form:
-  /// \code
-  ///   FOREACH(<variable-declaration>, ...)
-  ///     <loop-body>
-  /// \endcode
-  ///
-  /// In the .clang-format configuration file, this can be configured like:
-  /// \code{.yaml}
-  ///   ForEachMacros: ['RANGES_FOR', 'FOREACH']
-  /// \endcode
-  ///
-  /// For example: BOOST_FOREACH.
-  std::vector<std::string> ForEachMacros;
-
-  /// \brief See documentation of ``IncludeCategories``.
-  struct IncludeCategory {
-    /// \brief The regular expression that this category matches.
-    std::string Regex;
-    /// \brief The priority to assign to this category.
-    int Priority;
-    bool operator==(const IncludeCategory &Other) const {
-      return Regex == Other.Regex && Priority == Other.Priority;
-    }
-  };
-
-  /// \brief Regular expressions denoting the different ``#include`` categories
-  /// used for ordering ``#includes``.
-  ///
-  /// These regular expressions are matched against the filename of an include
-  /// (including the <> or "") in order. The value belonging to the first
-  /// matching regular expression is assigned and ``#includes`` are sorted first
-  /// according to increasing category number and then alphabetically within
-  /// each category.
-  ///
-  /// If none of the regular expressions match, INT_MAX is assigned as
-  /// category. The main header for a source file automatically gets category 0.
-  /// so that it is generally kept at the beginning of the ``#includes``
-  /// (http://llvm.org/docs/CodingStandards.html#include-style). However, you
-  /// can also assign negative priorities if you have certain headers that
-  /// always need to be first.
-  ///
-  /// To configure this in the .clang-format file, use:
-  /// \code{.yaml}
-  ///   IncludeCategories:
-  ///     - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-  ///       Priority:        2
-  ///     - Regex:           '^(<|"(gtest|isl|json)/)'
-  ///       Priority:        3
-  ///     - Regex:           '.*'
-  ///       Priority:        1
-  /// \endcode
-  std::vector<IncludeCategory> IncludeCategories;
-
-  /// \brief Specify a regular expression of suffixes that are allowed in the
-  /// file-to-main-include mapping.
-  ///
-  /// When guessing whether a #include is the "main" include (to assign
-  /// category 0, see above), use this regex of allowed suffixes to the header
-  /// stem. A partial match is done, so that:
-  /// - "" means "arbitrary suffix"
-  /// - "$" means "no suffix"
-  ///
-  /// For example, if configured to "(_test)?$", then a header a.h would be seen
-  /// as the "main" include in both a.cc and a_test.cc.
-  std::string IncludeIsMainRegex;
-
-  /// \brief Indent case labels one level from the switch statement.
-  ///
-  /// When ``false``, use the same indentation level as for the switch statement.
-  /// Switch statement body is always indented one level more than case labels.
-  bool IndentCaseLabels;
-
-  /// \brief The number of columns to use for indentation.
-  /// \code
-  ///    IndentWidth: 3
-  ///    void f() {
-  ///       someFunction();
-  ///       if (true, false) {
-  ///          f();
-  ///       }
-  ///    }
-  /// \endcode
-  unsigned IndentWidth;
-
-  /// \brief Indent if a function definition or declaration is wrapped after the
-  /// type.
-  bool IndentWrappedFunctionNames;
-
-  /// \brief Quotation styles for JavaScript strings. Does not affect template
-  /// strings.
-  enum JavaScriptQuoteStyle {
-    /// Leave string quotes as they are.
-    /// \code{.js}
-    ///    string1 = "foo";
-    ///    string2 = 'bar';
-    /// \endcode
-    JSQS_Leave,
-    /// Always use single quotes.
-    /// \code{.js}
-    ///    string1 = 'foo';
-    ///    string2 = 'bar';
-    /// \endcode
-    JSQS_Single,
-    /// Always use double quotes.
-    /// \code{.js}
-    ///    string1 = "foo";
-    ///    string2 = "bar";
-    /// \endcode
-    JSQS_Double
-  };
-
-  /// \brief The JavaScriptQuoteStyle to use for JavaScript strings.
-  JavaScriptQuoteStyle JavaScriptQuotes;
-
-  /// \brief Whether to wrap JavaScript import/export statements.
-  /// \code{.js}
-  ///    true:
-  ///    import {
-  ///        VeryLongImportsAreAnnoying,
-  ///        VeryLongImportsAreAnnoying,
-  ///        VeryLongImportsAreAnnoying,
-  ///    } from 'some/module.js'
-  ///
-  ///    false:
-  ///    import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
-  /// \endcode
-  bool JavaScriptWrapImports;
-
-  /// \brief If true, empty lines at the start of blocks are kept.
-  bool KeepEmptyLinesAtTheStartOfBlocks;
-
-  /// \brief Supported languages.
-  ///
-  /// When stored in a configuration file, specifies the language, that the
-  /// configuration targets. When passed to the ``reformat()`` function, enables
-  /// syntax features specific to the language.
-  enum LanguageKind {
-    /// Do not use.
-    LK_None,
-    /// Should be used for C, C++.
-    LK_Cpp,
-    /// Should be used for Java.
-    LK_Java,
-    /// Should be used for JavaScript.
-    LK_JavaScript,
-    /// Should be used for Objective-C, Objective-C++.
-    LK_ObjC,
-    /// Should be used for Protocol Buffers
-    /// (https://developers.google.com/protocol-buffers/).
-    LK_Proto,
-    /// Should be used for TableGen code.
-    LK_TableGen
-  };
-  bool IsCpp() const { return Language == LK_Cpp || Language == LK_ObjC; }
-
-  /// \brief Language, this format style is targeted at.
-  LanguageKind Language;
-
-  /// \brief A regular expression matching macros that start a block.
-  /// \code
-  ///    # With:
-  ///    MacroBlockBegin: "^NS_MAP_BEGIN|\
-  ///    NS_TABLE_HEAD$"
-  ///    MacroBlockEnd: "^\
-  ///    NS_MAP_END|\
-  ///    NS_TABLE_.*_END$"
-  ///
-  ///    NS_MAP_BEGIN
-  ///      foo();
-  ///    NS_MAP_END
-  ///
-  ///    NS_TABLE_HEAD
-  ///      bar();
-  ///    NS_TABLE_FOO_END
-  ///
-  ///    # Without:
-  ///    NS_MAP_BEGIN
-  ///    foo();
-  ///    NS_MAP_END
-  ///
-  ///    NS_TABLE_HEAD
-  ///    bar();
-  ///    NS_TABLE_FOO_END
-  /// \endcode
-  std::string MacroBlockBegin;
-
-  /// \brief A regular expression matching macros that end a block.
-  std::string MacroBlockEnd;
-
-  /// \brief The maximum number of consecutive empty lines to keep.
-  /// \code
-  ///    MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
-  ///    int f() {                              int f() {
-  ///      int = 1;                                 int i = 1;
-  ///                                               i = foo();
-  ///      i = foo();                               return i;
-  ///                                           }
-  ///      return i;
-  ///    }
-  /// \endcode
-  unsigned MaxEmptyLinesToKeep;
-
-  /// \brief Different ways to indent namespace contents.
-  enum NamespaceIndentationKind {
-    /// Don't indent in namespaces.
-    /// \code
-    ///    namespace out {
-    ///    int i;
-    ///    namespace in {
-    ///    int i;
-    ///    }
-    ///    }
-    /// \endcode
-    NI_None,
-    /// Indent only in inner namespaces (nested in other namespaces).
-    /// \code
-    ///    namespace out {
-    ///    int i;
-    ///    namespace in {
-    ///      int i;
-    ///    }
-    ///    }
-    /// \endcode
-    NI_Inner,
-    /// Indent in all namespaces.
-    /// \code
-    ///    namespace out {
-    ///      int i;
-    ///      namespace in {
-    ///        int i;
-    ///      }
-    ///    }
-    /// \endcode
-    NI_All
-  };
-
-  /// \brief The indentation used for namespaces.
-  NamespaceIndentationKind NamespaceIndentation;
-
-  /// \brief The number of characters to use for indentation of ObjC blocks.
-  unsigned ObjCBlockIndentWidth;
-
-  /// \brief Add a space after ``@property`` in Objective-C, i.e. use
-  /// ``@property (readonly)`` instead of ``@property(readonly)``.
-  bool ObjCSpaceAfterProperty;
-
-  /// \brief Add a space in front of an Objective-C protocol list, i.e. use
-  /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
-  bool ObjCSpaceBeforeProtocolList;
-
-  /// \brief The penalty for breaking a function call after ``call(``.
-  unsigned PenaltyBreakBeforeFirstCallParameter;
-
-  /// \brief The penalty for each line break introduced inside a comment.
-  unsigned PenaltyBreakComment;
-
-  /// \brief The penalty for breaking before the first ``<<``.
-  unsigned PenaltyBreakFirstLessLess;
-
-  /// \brief The penalty for each line break introduced inside a string literal.
-  unsigned PenaltyBreakString;
-
-  /// \brief The penalty for each character outside of the column limit.
-  unsigned PenaltyExcessCharacter;
-
-  /// \brief Penalty for putting the return type of a function onto its own
-  /// line.
-  unsigned PenaltyReturnTypeOnItsOwnLine;
-
-  /// \brief The ``&`` and ``*`` alignment style.
-  enum PointerAlignmentStyle {
-    /// Align pointer to the left.
-    /// \code
-    ///   int* a;
-    /// \endcode
-    PAS_Left,
-    /// Align pointer to the right.
-    /// \code
-    ///   int *a;
-    /// \endcode
-    PAS_Right,
-    /// Align pointer in the middle.
-    /// \code
-    ///   int * a;
-    /// \endcode
-    PAS_Middle
-  };
-
-  /// \brief Pointer and reference alignment style.
-  PointerAlignmentStyle PointerAlignment;
-
-  /// \brief If ``true``, clang-format will attempt to re-flow comments.
-  /// \code
-  ///    false:
-  ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
-  ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
-  ///
-  ///    true:
-  ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
-  ///    // information
-  ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
-  ///     * information */
-  /// \endcode
-  bool ReflowComments;
-
-  /// \brief If ``true``, clang-format will sort ``#includes``.
-  /// \code
-  ///    false:                                 true:
-  ///    #include "b.h"                 vs.     #include "a.h"
-  ///    #include "a.h"                         #include "b.h"
-  /// \endcode
-  bool SortIncludes;
-
-  /// \brief If ``true``, a space is inserted after C style casts.
-  /// \code
-  ///    true:                                  false:
-  ///    (int)i;                        vs.     (int) i;
-  /// \endcode
-  bool SpaceAfterCStyleCast;
-
-  /// \brief If \c true, a space will be inserted after the 'template' keyword.
-  /// \code
-  ///    true:                                  false:
-  ///    template <int> void foo();     vs.     template<int> void foo();
-  /// \endcode
-  bool SpaceAfterTemplateKeyword;
-
-  /// \brief If ``false``, spaces will be removed before assignment operators.
-  /// \code
-  ///    true:                                  false:
-  ///    int a = 5;                     vs.     int a=5;
-  ///    a += 42                                a+=42;
-  /// \endcode
-  bool SpaceBeforeAssignmentOperators;
-
-  /// \brief Different ways to put a space before opening parentheses.
-  enum SpaceBeforeParensOptions {
-    /// Never put a space before opening parentheses.
-    /// \code
-    ///    void f() {
-    ///      if(true) {
-    ///        f();
-    ///      }
-    ///    }
-    /// \endcode
-    SBPO_Never,
-    /// Put a space before opening parentheses only after control statement
-    /// keywords (``for/if/while...``).
-    /// \code
-    ///    void f() {
-    ///      if (true) {
-    ///        f();
-    ///      }
-    ///    }
-    /// \endcode
-    SBPO_ControlStatements,
-    /// Always put a space before opening parentheses, except when it's
-    /// prohibited by the syntax rules (in function-like macro definitions) or
-    /// when determined by other style rules (after unary operators, opening
-    /// parentheses, etc.)
-    /// \code
-    ///    void f () {
-    ///      if (true) {
-    ///        f ();
-    ///      }
-    ///    }
-    /// \endcode
-    SBPO_Always
-  };
-
-  /// \brief Defines in which cases to put a space before opening parentheses.
-  SpaceBeforeParensOptions SpaceBeforeParens;
-
-  /// \brief If ``true``, spaces may be inserted into ``()``.
-  /// \code
-  ///    true:                                false:
-  ///    void f( ) {                    vs.   void f() {
-  ///      int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
-  ///      if (true) {                          if (true) {
-  ///        f( );                                f();
-  ///      }                                    }
-  ///    }                                    }
-  /// \endcode
-  bool SpaceInEmptyParentheses;
-
-  /// \brief The number of spaces before trailing line comments
-  /// (``//`` - comments).
-  ///
-  /// This does not affect trailing block comments (``/*`` - comments) as
-  /// those commonly have different usage patterns and a number of special
-  /// cases.
-  /// \code
-  ///    SpacesBeforeTrailingComments: 3
-  ///    void f() {
-  ///      if (true) {   // foo1
-  ///        f();        // bar
-  ///      }             // foo
-  ///    }
-  /// \endcode
-  unsigned SpacesBeforeTrailingComments;
-
-  /// \brief If ``true``, spaces will be inserted after ``<`` and before ``>``
-  /// in template argument lists.
-  /// \code
-  ///    true:                                  false:
-  ///    static_cast< int >(arg);       vs.     static_cast<int>(arg);
-  ///    std::function< void(int) > fct;        std::function<void(int)> fct;
-  /// \endcode
-  bool SpacesInAngles;
-
-  /// \brief If ``true``, spaces are inserted inside container literals (e.g.
-  /// ObjC and Javascript array and dict literals).
-  /// \code{.js}
-  ///    true:                                  false:
-  ///    var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
-  ///    f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
-  /// \endcode
-  bool SpacesInContainerLiterals;
-
-  /// \brief If ``true``, spaces may be inserted into C style casts.
-  /// \code
-  ///    true:                                  false:
-  ///    x = ( int32 )y                 vs.     x = (int32)y
-  /// \endcode
-  bool SpacesInCStyleCastParentheses;
-
-  /// \brief If ``true``, spaces will be inserted after ``(`` and before ``)``.
-  /// \code
-  ///    true:                                  false:
-  ///    t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
-  /// \endcode
-  bool SpacesInParentheses;
-
-  /// \brief If ``true``, spaces will be inserted after ``[`` and before ``]``.
-  /// Lambdas or unspecified size array declarations will not be affected.
-  /// \code
-  ///    true:                                  false:
-  ///    int a[ 5 ];                    vs.     int a[5];
-  ///    std::unique_ptr<int[]> foo() {} // Won't be affected
-  /// \endcode
-  bool SpacesInSquareBrackets;
-
-  /// \brief Supported language standards.
-  enum LanguageStandard {
-    /// Use C++03-compatible syntax.
-    LS_Cpp03,
-    /// Use features of C++11 (e.g. ``A<A<int>>`` instead of ``A<A<int> >``).
-    LS_Cpp11,
-    /// Automatic detection based on the input.
-    LS_Auto
-  };
-
-  /// \brief Format compatible with this standard, e.g. use ``A<A<int> >``
-  /// instead of ``A<A<int>>`` for ``LS_Cpp03``.
-  LanguageStandard Standard;
-
-  /// \brief The number of columns used for tab stops.
-  unsigned TabWidth;
-
-  /// \brief Different ways to use tab in formatting.
-  enum UseTabStyle {
-    /// Never use tab.
-    UT_Never,
-    /// Use tabs only for indentation.
-    UT_ForIndentation,
-    /// Use tabs only for line continuation and indentation.
-    UT_ForContinuationAndIndentation,
-    /// Use tabs whenever we need to fill whitespace that spans at least from
-    /// one tab stop to the next one.
-    UT_Always
-  };
-
-  /// \brief The way to use tab characters in the resulting file.
-  UseTabStyle UseTab;
-
-  bool operator==(const FormatStyle &R) const {
-    return AccessModifierOffset == R.AccessModifierOffset &&
-           AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
-           AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
-           AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
-           AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft &&
-           AlignOperands == R.AlignOperands &&
-           AlignTrailingComments == R.AlignTrailingComments &&
-           AllowAllParametersOfDeclarationOnNextLine ==
-               R.AllowAllParametersOfDeclarationOnNextLine &&
-           AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
-           AllowShortCaseLabelsOnASingleLine ==
-               R.AllowShortCaseLabelsOnASingleLine &&
-           AllowShortFunctionsOnASingleLine ==
-               R.AllowShortFunctionsOnASingleLine &&
-           AllowShortIfStatementsOnASingleLine ==
-               R.AllowShortIfStatementsOnASingleLine &&
-           AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
-           AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
-           AlwaysBreakBeforeMultilineStrings ==
-               R.AlwaysBreakBeforeMultilineStrings &&
-           AlwaysBreakTemplateDeclarations ==
-               R.AlwaysBreakTemplateDeclarations &&
-           BinPackArguments == R.BinPackArguments &&
-           BinPackParameters == R.BinPackParameters &&
-           BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
-           BreakBeforeBraces == R.BreakBeforeBraces &&
-           BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
-           BreakConstructorInitializersBeforeComma ==
-               R.BreakConstructorInitializersBeforeComma &&
-           BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
-           BreakStringLiterals == R.BreakStringLiterals &&
-           ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
-           BreakBeforeInheritanceComma == R.BreakBeforeInheritanceComma &&
-           ConstructorInitializerAllOnOneLineOrOnePerLine ==
-               R.ConstructorInitializerAllOnOneLineOrOnePerLine &&
-           ConstructorInitializerIndentWidth ==
-               R.ConstructorInitializerIndentWidth &&
-           ContinuationIndentWidth == R.ContinuationIndentWidth &&
-           Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
-           DerivePointerAlignment == R.DerivePointerAlignment &&
-           DisableFormat == R.DisableFormat &&
-           ExperimentalAutoDetectBinPacking ==
-               R.ExperimentalAutoDetectBinPacking &&
-           FixNamespaceComments == R.FixNamespaceComments &&
-           ForEachMacros == R.ForEachMacros &&
-           IncludeCategories == R.IncludeCategories &&
-           IndentCaseLabels == R.IndentCaseLabels &&
-           IndentWidth == R.IndentWidth && Language == R.Language &&
-           IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
-           JavaScriptQuotes == R.JavaScriptQuotes &&
-           JavaScriptWrapImports == R.JavaScriptWrapImports &&
-           KeepEmptyLinesAtTheStartOfBlocks ==
-               R.KeepEmptyLinesAtTheStartOfBlocks &&
-           MacroBlockBegin == R.MacroBlockBegin &&
-           MacroBlockEnd == R.MacroBlockEnd &&
-           MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
-           NamespaceIndentation == R.NamespaceIndentation &&
-           ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
-           ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
-           ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
-           PenaltyBreakBeforeFirstCallParameter ==
-               R.PenaltyBreakBeforeFirstCallParameter &&
-           PenaltyBreakComment == R.PenaltyBreakComment &&
-           PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
-           PenaltyBreakString == R.PenaltyBreakString &&
-           PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
-           PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
-           PointerAlignment == R.PointerAlignment &&
-           SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
-           SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
-           SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
-           SpaceBeforeParens == R.SpaceBeforeParens &&
-           SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
-           SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
-           SpacesInAngles == R.SpacesInAngles &&
-           SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
-           SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
-           SpacesInParentheses == R.SpacesInParentheses &&
-           SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
-           Standard == R.Standard && TabWidth == R.TabWidth &&
-           UseTab == R.UseTab;
-  }
-};
-
-/// \brief Returns a format style complying with the LLVM coding standards:
-/// http://llvm.org/docs/CodingStandards.html.
-FormatStyle getLLVMStyle();
-
-/// \brief Returns a format style complying with one of Google's style guides:
-/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
-/// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
-/// https://developers.google.com/protocol-buffers/docs/style.
-FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
-
-/// \brief Returns a format style complying with Chromium's style guide:
-/// http://www.chromium.org/developers/coding-style.
-FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
-
-/// \brief Returns a format style complying with Mozilla's style guide:
-/// https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style.
-FormatStyle getMozillaStyle();
-
-/// \brief Returns a format style complying with Webkit's style guide:
-/// http://www.webkit.org/coding/coding-style.html
-FormatStyle getWebKitStyle();
-
-/// \brief Returns a format style complying with GNU Coding Standards:
-/// http://www.gnu.org/prep/standards/standards.html
-FormatStyle getGNUStyle();
-
-/// \brief Returns style indicating formatting should be not applied at all.
-FormatStyle getNoStyle();
-
-/// \brief Gets a predefined style for the specified language by name.
-///
-/// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are
-/// compared case-insensitively.
-///
-/// Returns ``true`` if the Style has been set.
-bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
-                        FormatStyle *Style);
-
-/// \brief Parse configuration from YAML-formatted text.
-///
-/// Style->Language is used to get the base style, if the ``BasedOnStyle``
-/// option is present.
-///
-/// When ``BasedOnStyle`` is not present, options not present in the YAML
-/// document, are retained in \p Style.
-std::error_code parseConfiguration(StringRef Text, FormatStyle *Style);
-
-/// \brief Gets configuration in a YAML string.
-std::string configurationAsText(const FormatStyle &Style);
-
-/// \brief Returns the replacements necessary to sort all ``#include`` blocks
-/// that are affected by ``Ranges``.
-tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
-                                   ArrayRef<tooling::Range> Ranges,
-                                   StringRef FileName,
-                                   unsigned *Cursor = nullptr);
-
-/// \brief Returns the replacements corresponding to applying and formatting
-/// \p Replaces on success; otheriwse, return an llvm::Error carrying
-/// llvm::StringError.
-llvm::Expected<tooling::Replacements>
-formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                   const FormatStyle &Style);
-
-/// \brief Returns the replacements corresponding to applying \p Replaces and
-/// cleaning up the code after that on success; otherwise, return an llvm::Error
-/// carrying llvm::StringError.
-/// This also supports inserting/deleting C++ #include directives:
-/// - If a replacement has offset UINT_MAX, length 0, and a replacement text
-///   that is an #include directive, this will insert the #include into the
-///   correct block in the \p Code. When searching for points to insert new
-///   header, this ignores #include's after the #include block(s) in the
-///   beginning of a file to avoid inserting headers into code sections where
-///   new #include's should not be added by default. These code sections
-///   include:
-///     - raw string literals (containing #include).
-///     - #if blocks.
-///     - Special #include's among declarations (e.g. functions).
-/// - If a replacement has offset UINT_MAX, length 1, and a replacement text
-///   that is the name of the header to be removed, the header will be removed
-///   from \p Code if it exists.
-llvm::Expected<tooling::Replacements>
-cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                          const FormatStyle &Style);
-
-/// \brief Reformats the given \p Ranges in \p Code.
-///
-/// Each range is extended on either end to its next bigger logic unit, i.e.
-/// everything that might influence its formatting or might be influenced by its
-/// formatting.
-///
-/// Returns the ``Replacements`` necessary to make all \p Ranges comply with
-/// \p Style.
-///
-/// If ``IncompleteFormat`` is non-null, its value will be set to true if any
-/// of the affected ranges were not formatted due to a non-recoverable syntax
-/// error.
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
-                               ArrayRef<tooling::Range> Ranges,
-                               StringRef FileName = "<stdin>",
-                               bool *IncompleteFormat = nullptr);
-
-/// \brief Clean up any erroneous/redundant code in the given \p Ranges in \p
-/// Code.
-///
-/// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
-tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
-                              ArrayRef<tooling::Range> Ranges,
-                              StringRef FileName = "<stdin>");
-
-/// \brief Fix namespace end comments in the given \p Ranges in \p Code.
-///
-/// Returns the ``Replacements`` that fix the namespace comments in all
-/// \p Ranges in \p Code.
-tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
-                                              StringRef Code,
-                                              ArrayRef<tooling::Range> Ranges,
-                                              StringRef FileName = "<stdin>");
-
-/// \brief Returns the ``LangOpts`` that the formatter expects you to set.
-///
-/// \param Style determines specific settings for lexing mode.
-LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
-
-/// \brief Description to be used for help text for a ``llvm::cl`` option for
-/// specifying format style. The description is closely related to the operation
-/// of ``getStyle()``.
-extern const char *StyleOptionHelpDescription;
-
-/// \brief Construct a FormatStyle based on ``StyleName``.
-///
-/// ``StyleName`` can take several forms:
-/// * "{<key>: <value>, ...}" - Set specic style parameters.
-/// * "<style name>" - One of the style names supported by
-/// getPredefinedStyle().
-/// * "file" - Load style configuration from a file called ``.clang-format``
-/// located in one of the parent directories of ``FileName`` or the current
-/// directory if ``FileName`` is empty.
-///
-/// \param[in] StyleName Style name to interpret according to the description
-/// above.
-/// \param[in] FileName Path to start search for .clang-format if ``StyleName``
-/// == "file".
-/// \param[in] FallbackStyle The name of a predefined style used to fallback to
-/// in case \p StyleName is "file" and no file can be found.
-/// \param[in] Code The actual code to be formatted. Used to determine the
-/// language if the filename isn't sufficient.
-/// \param[in] FS The underlying file system, in which the file resides. By
-/// default, the file system is the real file system.
-///
-/// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is
-/// "file" and no file is found, returns ``FallbackStyle``. If no style could be
-/// determined, returns an Error.
-llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
-                                     StringRef FallbackStyle,
-                                     StringRef Code = "",
-                                     vfs::FileSystem *FS = nullptr);
-
-// \brief Returns a string representation of ``Language``.
-inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
-  switch (Language) {
-  case FormatStyle::LK_Cpp:
-    return "C++";
-  case FormatStyle::LK_ObjC:
-    return "Objective-C";
-  case FormatStyle::LK_Java:
-    return "Java";
-  case FormatStyle::LK_JavaScript:
-    return "JavaScript";
-  case FormatStyle::LK_Proto:
-    return "Proto";
-  default:
-    return "Unknown";
-  }
-}
-
-} // end namespace format
-} // end namespace clang
-
-namespace std {
-template <>
-struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
-}
-
-#endif // LLVM_CLANG_FORMAT_FORMAT_H
+//===--- Format.h - Format C++ code -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Various functions to configurably format source code.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_FORMAT_FORMAT_H
+#define LLVM_CLANG_FORMAT_FORMAT_H
+
+#include "clang/Basic/LangOptions.h"
+#include "clang/Tooling/Core/Replacement.h"
+#include "llvm/ADT/ArrayRef.h"
+#include <system_error>
+
+namespace clang {
+
+class Lexer;
+class SourceManager;
+class DiagnosticConsumer;
+
+namespace vfs {
+class FileSystem;
+}
+
+namespace format {
+
+enum class ParseError { Success = 0, Error, Unsuitable };
+class ParseErrorCategory final : public std::error_category {
+public:
+  const char *name() const noexcept override;
+  std::string message(int EV) const override;
+};
+const std::error_category &getParseCategory();
+std::error_code make_error_code(ParseError e);
+
+/// \brief The ``FormatStyle`` is used to configure the formatting to follow
+/// specific guidelines.
+struct FormatStyle {
+  /// \brief The extra indent or outdent of access modifiers, e.g. ``public:``.
+  int AccessModifierOffset;
+
+  /// \brief Different styles for aligning after open brackets.
+  enum BracketAlignmentStyle {
+    /// \brief Align parameters on the open bracket, e.g.:
+    /// \code
+    ///   someLongFunction(argument1,
+    ///                    argument2);
+    /// \endcode
+    BAS_Align,
+    /// \brief Don't align, instead use ``ContinuationIndentWidth``, e.g.:
+    /// \code
+    ///   someLongFunction(argument1,
+    ///       argument2);
+    /// \endcode
+    BAS_DontAlign,
+    /// \brief Always break after an open bracket, if the parameters don't fit
+    /// on a single line, e.g.:
+    /// \code
+    ///   someLongFunction(
+    ///       argument1, argument2);
+    /// \endcode
+    BAS_AlwaysBreak,
+  };
+
+  /// \brief If ``true``, horizontally aligns arguments after an open bracket.
+  ///
+  /// This applies to round brackets (parentheses), angle brackets and square
+  /// brackets.
+  BracketAlignmentStyle AlignAfterOpenBracket;
+
+  /// \brief If ``true``, aligns consecutive assignments.
+  ///
+  /// This will align the assignment operators of consecutive lines. This
+  /// will result in formattings like
+  /// \code
+  ///   int aaaa = 12;
+  ///   int b    = 23;
+  ///   int ccc  = 23;
+  /// \endcode
+  bool AlignConsecutiveAssignments;
+
+  /// \brief If ``true``, aligns consecutive declarations.
+  ///
+  /// This will align the declaration names of consecutive lines. This
+  /// will result in formattings like
+  /// \code
+  ///   int         aaaa = 12;
+  ///   float       b = 23;
+  ///   std::string ccc = 23;
+  /// \endcode
+  bool AlignConsecutiveDeclarations;
+
+  /// \brief If ``true``, aligns escaped newlines as far left as possible.
+  /// Otherwise puts them into the right-most column.
+  /// \code
+  ///   true:
+  ///   #define A   \
+  ///     int aaaa; \
+  ///     int b;    \
+  ///     int dddddddddd;
+  ///
+  ///   false:
+  ///   #define A                                                                      \
+  ///     int aaaa;                                                                    \
+  ///     int b;                                                                       \
+  ///     int dddddddddd;
+  /// \endcode
+  bool AlignEscapedNewlinesLeft;
+
+  /// \brief If ``true``, horizontally align operands of binary and ternary
+  /// expressions.
+  ///
+  /// Specifically, this aligns operands of a single expression that needs to be
+  /// split over multiple lines, e.g.:
+  /// \code
+  ///   int aaa = bbbbbbbbbbbbbbb +
+  ///             ccccccccccccccc;
+  /// \endcode
+  bool AlignOperands;
+
+  /// \brief If ``true``, aligns trailing comments.
+  /// \code
+  ///   true:                                   false:
+  ///   int a;     // My comment a      vs.     int a; // My comment a
+  ///   int b = 2; // comment  b                int b = 2; // comment about b
+  /// \endcode
+  bool AlignTrailingComments;
+
+  /// \brief Allow putting all parameters of a function declaration onto
+  /// the next line even if ``BinPackParameters`` is ``false``.
+  /// \code
+  ///   true:                                   false:
+  ///   myFunction(foo,                 vs.     myFunction(foo, bar, plop);
+  ///              bar,
+  ///              plop);
+  /// \endcode
+  bool AllowAllParametersOfDeclarationOnNextLine;
+
+  /// \brief Allows contracting simple braced statements to a single line.
+  ///
+  /// E.g., this allows ``if (a) { return; }`` to be put on a single line.
+  bool AllowShortBlocksOnASingleLine;
+
+  /// \brief If ``true``, short case labels will be contracted to a single line.
+  /// \code
+  ///   true:                                   false:
+  ///   switch (a) {                    vs.     switch (a) {
+  ///   case 1: x = 1; break;                   case 1:
+  ///   case 2: return;                           x = 1;
+  ///   }                                         break;
+  ///                                           case 2:
+  ///                                             return;
+  ///                                           }
+  /// \endcode
+  bool AllowShortCaseLabelsOnASingleLine;
+
+  /// \brief Different styles for merging short functions containing at most one
+  /// statement.
+  enum ShortFunctionStyle {
+    /// \brief Never merge functions into a single line.
+    SFS_None,
+    /// \brief Only merge empty functions.
+    /// \code
+    ///   void f() { bar(); }
+    ///   void f2() {
+    ///     bar2();
+    ///   }
+    /// \endcode
+    SFS_Empty,
+    /// \brief Only merge functions defined inside a class. Implies "empty".
+    /// \code
+    ///   class {
+    ///     void f() { foo(); }
+    ///   };
+    /// \endcode
+    SFS_Inline,
+    /// \brief Merge all functions fitting on a single line.
+    /// \code
+    ///   class {
+    ///     void f() { foo(); }
+    ///   };
+    ///   void f() { bar(); }
+    /// \endcode
+    SFS_All,
+  };
+
+  /// \brief Dependent on the value, ``int f() { return 0; }`` can be put on a
+  /// single line.
+  ShortFunctionStyle AllowShortFunctionsOnASingleLine;
+
+  /// \brief If ``true``, ``if (a) return;`` can be put on a single line.
+  bool AllowShortIfStatementsOnASingleLine;
+
+  /// \brief If ``true``, ``while (true) continue;`` can be put on a single
+  /// line.
+  bool AllowShortLoopsOnASingleLine;
+
+  /// \brief Different ways to break after the function definition return type.
+  /// This option is **deprecated** and is retained for backwards compatibility.
+  enum DefinitionReturnTypeBreakingStyle {
+    /// Break after return type automatically.
+    /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
+    DRTBS_None,
+    /// Always break after the return type.
+    DRTBS_All,
+    /// Always break after the return types of top-level functions.
+    DRTBS_TopLevel,
+  };
+
+  /// \brief Different ways to break after the function definition or
+  /// declaration return type.
+  enum ReturnTypeBreakingStyle {
+    /// Break after return type automatically.
+    /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
+    /// \code
+    ///   class A {
+    ///     int f() { return 0; };
+    ///   };
+    ///   int f();
+    ///   int f() { return 1; }
+    /// \endcode
+    RTBS_None,
+    /// Always break after the return type.
+    /// \code
+    ///   class A {
+    ///     int
+    ///     f() {
+    ///       return 0;
+    ///     };
+    ///   };
+    ///   int
+    ///   f();
+    ///   int
+    ///   f() {
+    ///     return 1;
+    ///   }
+    /// \endcode
+    RTBS_All,
+    /// Always break after the return types of top-level functions.
+    /// \code
+    ///   class A {
+    ///     int f() { return 0; };
+    ///   };
+    ///   int
+    ///   f();
+    ///   int
+    ///   f() {
+    ///     return 1;
+    ///   }
+    /// \endcode
+    RTBS_TopLevel,
+    /// Always break after the return type of function definitions.
+    /// \code
+    ///   class A {
+    ///     int
+    ///     f() {
+    ///       return 0;
+    ///     };
+    ///   };
+    ///   int f();
+    ///   int
+    ///   f() {
+    ///     return 1;
+    ///   }
+    /// \endcode
+    RTBS_AllDefinitions,
+    /// Always break after the return type of top-level definitions.
+    /// \code
+    ///   class A {
+    ///     int f() { return 0; };
+    ///   };
+    ///   int f();
+    ///   int
+    ///   f() {
+    ///     return 1;
+    ///   }
+    /// \endcode
+    RTBS_TopLevelDefinitions,
+  };
+
+  /// \brief The function definition return type breaking style to use.  This
+  /// option is **deprecated** and is retained for backwards compatibility.
+  DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
+
+  /// \brief The function declaration return type breaking style to use.
+  ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;
+
+  /// \brief If ``true``, always break before multiline string literals.
+  ///
+  /// This flag is mean to make cases where there are multiple multiline strings
+  /// in a file look more consistent. Thus, it will only take effect if wrapping
+  /// the string at that point leads to it being indented
+  /// ``ContinuationIndentWidth`` spaces from the start of the line.
+  /// \code
+  ///    true:                                  false:
+  ///    aaaa =                         vs.     aaaa = "bbbb"
+  ///        "bbbb"                                    "cccc";
+  ///        "cccc";
+  /// \endcode
+  bool AlwaysBreakBeforeMultilineStrings;
+
+  /// \brief If ``true``, always break after the ``template<...>`` of a template
+  /// declaration.
+  /// \code
+  ///    true:                                  false:
+  ///    template <typename T>          vs.     template <typename T> class C {};
+  ///    class C {};
+  /// \endcode
+  bool AlwaysBreakTemplateDeclarations;
+
+  /// \brief If ``false``, a function call's arguments will either be all on the
+  /// same line or will have one line each.
+  /// \code
+  ///   true:
+  ///   void f() {
+  ///     f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
+  ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
+  ///   }
+  ///
+  ///   false:
+  ///   void f() {
+  ///     f(aaaaaaaaaaaaaaaaaaaa,
+  ///       aaaaaaaaaaaaaaaaaaaa,
+  ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
+  ///   }
+  /// \endcode
+  bool BinPackArguments;
+
+  /// \brief If ``false``, a function declaration's or function definition's
+  /// parameters will either all be on the same line or will have one line each.
+  /// \code
+  ///   true:
+  ///   void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
+  ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
+  ///
+  ///   false:
+  ///   void f(int aaaaaaaaaaaaaaaaaaaa,
+  ///          int aaaaaaaaaaaaaaaaaaaa,
+  ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
+  /// \endcode
+  bool BinPackParameters;
+
+  /// \brief The style of breaking before or after binary operators.
+  enum BinaryOperatorStyle {
+    /// Break after operators.
+    /// \code
+    ///    LooooooooooongType loooooooooooooooooooooongVariable =
+    ///        someLooooooooooooooooongFunction();
+    ///
+    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
+    ///                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
+    ///                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
+    ///                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
+    ///                     ccccccccccccccccccccccccccccccccccccccccc;
+    /// \endcode
+    BOS_None,
+    /// Break before operators that aren't assignments.
+    /// \code
+    ///    LooooooooooongType loooooooooooooooooooooongVariable =
+    ///        someLooooooooooooooooongFunction();
+    ///
+    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                         + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                        > ccccccccccccccccccccccccccccccccccccccccc;
+    /// \endcode
+    BOS_NonAssignment,
+    /// Break before operators.
+    /// \code
+    ///    LooooooooooongType loooooooooooooooooooooongVariable
+    ///        = someLooooooooooooooooongFunction();
+    ///
+    ///    bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                         + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    ///                        > ccccccccccccccccccccccccccccccccccccccccc;
+    /// \endcode
+    BOS_All,
+  };
+
+  /// \brief The way to wrap binary operators.
+  BinaryOperatorStyle BreakBeforeBinaryOperators;
+
+  /// \brief Different ways to attach braces to their surrounding context.
+  enum BraceBreakingStyle {
+    /// Always attach braces to surrounding context.
+    /// \code
+    ///   try {
+    ///     foo();
+    ///   } catch () {
+    ///   }
+    ///   void foo() { bar(); }
+    ///   class foo {};
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    ///   enum X : int { A, B };
+    /// \endcode
+    BS_Attach,
+    /// Like ``Attach``, but break before braces on function, namespace and
+    /// class definitions.
+    /// \code
+    ///   try {
+    ///     foo();
+    ///   } catch () {
+    ///   }
+    ///   void foo() { bar(); }
+    ///   class foo
+    ///   {
+    ///   };
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    ///   enum X : int { A, B };
+    /// \endcode
+    BS_Linux,
+    /// Like ``Attach``, but break before braces on enum, function, and record
+    /// definitions.
+    /// \code
+    ///   try {
+    ///     foo();
+    ///   } catch () {
+    ///   }
+    ///   void foo() { bar(); }
+    ///   class foo
+    ///   {
+    ///   };
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    ///   enum X : int { A, B };
+    /// \endcode
+    BS_Mozilla,
+    /// Like ``Attach``, but break before function definitions, ``catch``, and
+    /// ``else``.
+    /// \code
+    ///   try {
+    ///     foo();
+    ///   } catch () {
+    ///   }
+    ///   void foo() { bar(); }
+    ///   class foo
+    ///   {
+    ///   };
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    ///   enum X : int
+    ///   {
+    ///     A,
+    ///     B
+    ///   };
+    /// \endcode
+    BS_Stroustrup,
+    /// Always break before braces.
+    /// \code
+    ///   try {
+    ///     foo();
+    ///   }
+    ///   catch () {
+    ///   }
+    ///   void foo() { bar(); }
+    ///   class foo {
+    ///   };
+    ///   if (foo()) {
+    ///   }
+    ///   else {
+    ///   }
+    ///   enum X : int { A, B };
+    /// \endcode
+    BS_Allman,
+    /// Always break before braces and add an extra level of indentation to
+    /// braces of control statements, not to those of class, function
+    /// or other definitions.
+    /// \code
+    ///   try
+    ///     {
+    ///       foo();
+    ///     }
+    ///   catch ()
+    ///     {
+    ///     }
+    ///   void foo() { bar(); }
+    ///   class foo
+    ///   {
+    ///   };
+    ///   if (foo())
+    ///     {
+    ///     }
+    ///   else
+    ///     {
+    ///     }
+    ///   enum X : int
+    ///   {
+    ///     A,
+    ///     B
+    ///   };
+    /// \endcode
+    BS_GNU,
+    /// Like ``Attach``, but break before functions.
+    /// \code
+    ///   try {
+    ///     foo();
+    ///   } catch () {
+    ///   }
+    ///   void foo() { bar(); }
+    ///   class foo {
+    ///   };
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    ///   enum X : int { A, B };
+    /// \endcode
+    BS_WebKit,
+    /// Configure each individual brace in `BraceWrapping`.
+    BS_Custom
+  };
+
+  /// \brief The brace breaking style to use.
+  BraceBreakingStyle BreakBeforeBraces;
+
+  /// \brief Precise control over the wrapping of braces.
+  /// \code
+  ///   # Should be declared this way:
+  ///   BreakBeforeBraces: Custom
+  ///   BraceWrapping:
+  ///       AfterClass: true
+  /// \endcode
+  struct BraceWrappingFlags {
+    /// \brief Wrap class definitions.
+    /// \code
+    ///   true:
+    ///   class foo {};
+    ///
+    ///   false:
+    ///   class foo
+    ///   {};
+    /// \endcode
+    bool AfterClass;
+    /// \brief Wrap control statements (``if``/``for``/``while``/``switch``/..).
+    /// \code
+    ///   true:
+    ///   if (foo())
+    ///   {
+    ///   } else
+    ///   {}
+    ///   for (int i = 0; i < 10; ++i)
+    ///   {}
+    ///
+    ///   false:
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    ///   for (int i = 0; i < 10; ++i) {
+    ///   }
+    /// \endcode
+    bool AfterControlStatement;
+    /// \brief Wrap enum definitions.
+    /// \code
+    ///   true:
+    ///   enum X : int
+    ///   {
+    ///     B
+    ///   };
+    ///
+    ///   false:
+    ///   enum X : int { B };
+    /// \endcode
+    bool AfterEnum;
+    /// \brief Wrap function definitions.
+    /// \code
+    ///   true:
+    ///   void foo()
+    ///   {
+    ///     bar();
+    ///     bar2();
+    ///   }
+    ///
+    ///   false:
+    ///   void foo() {
+    ///     bar();
+    ///     bar2();
+    ///   }
+    /// \endcode
+    bool AfterFunction;
+    /// \brief Wrap namespace definitions.
+    /// \code
+    ///   true:
+    ///   namespace
+    ///   {
+    ///   int foo();
+    ///   int bar();
+    ///   }
+    ///
+    ///   false:
+    ///   namespace {
+    ///   int foo();
+    ///   int bar();
+    ///   }
+    /// \endcode
+    bool AfterNamespace;
+    /// \brief Wrap ObjC definitions (``@autoreleasepool``, interfaces, ..).
+    bool AfterObjCDeclaration;
+    /// \brief Wrap struct definitions.
+    /// \code
+    ///   true:
+    ///   struct foo
+    ///   {
+    ///     int x;
+    ///   }
+    ///
+    ///   false:
+    ///   struct foo {
+    ///     int x;
+    ///   }
+    /// \endcode
+    bool AfterStruct;
+    /// \brief Wrap union definitions.
+    /// \code
+    ///   true:
+    ///   union foo
+    ///   {
+    ///     int x;
+    ///   }
+    ///
+    ///   false:
+    ///   union foo {
+    ///     int x;
+    ///   }
+    /// \endcode
+    bool AfterUnion;
+    /// \brief Wrap before ``catch``.
+    /// \code
+    ///   true:
+    ///   try {
+    ///     foo();
+    ///   }
+    ///   catch () {
+    ///   }
+    ///
+    ///   false:
+    ///   try {
+    ///     foo();
+    ///   } catch () {
+    ///   }
+    /// \endcode
+    bool BeforeCatch;
+    /// \brief Wrap before ``else``.
+    /// \code
+    ///   true:
+    ///   if (foo()) {
+    ///   }
+    ///   else {
+    ///   }
+    ///
+    ///   false:
+    ///   if (foo()) {
+    ///   } else {
+    ///   }
+    /// \endcode
+    bool BeforeElse;
+    /// \brief Indent the wrapped braces themselves.
+    bool IndentBraces;
+  };
+
+  /// \brief 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.
+  BraceWrappingFlags BraceWrapping;
+
+  /// \brief If ``true``, ternary operators will be placed after line breaks.
+  /// \code
+  ///    true:
+  ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
+  ///        ? firstValue
+  ///        : SecondValueVeryVeryVeryVeryLong;
+  ///
+  ///    true:
+  ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
+  ///        firstValue :
+  ///        SecondValueVeryVeryVeryVeryLong;
+  /// \endcode
+  bool BreakBeforeTernaryOperators;
+
+  /// \brief Always break constructor initializers before commas and align
+  /// the commas with the colon.
+  /// \code
+  ///    true:                                  false:
+  ///    SomeClass::Constructor()       vs.     SomeClass::Constructor() : a(a),
+  ///        : a(a)                                                   b(b),
+  ///        , b(b)                                                   c(c) {}
+  ///        , c(c) {}
+  /// \endcode
+  bool BreakConstructorInitializersBeforeComma;
+
+  /// \brief Break after each annotation on a field in Java files.
+  bool BreakAfterJavaFieldAnnotations;
+
+  /// \brief Allow breaking string literals when formatting.
+  bool BreakStringLiterals;
+
+  /// \brief The column limit.
+  ///
+  /// A column limit of ``0`` means that there is no column limit. In this case,
+  /// clang-format will respect the input's line breaking decisions within
+  /// statements unless they contradict other rules.
+  unsigned ColumnLimit;
+
+  /// \brief A regular expression that describes comments with special meaning,
+  /// which should not be split into lines or otherwise changed.
+  /// \code
+  ///    CommentPragmas: '^ FOOBAR pragma:'
+  ///    // Will leave the following line unaffected
+  ///    #include <vector> // FOOBAR pragma: keep
+  /// \endcode
+  std::string CommentPragmas;
+
+  /// \brief If ``true``, in the class inheritance expression clang-format will
+  /// break before ``:`` and ``,`` if there is multiple inheritance.
+  /// \code
+  ///    true:                                  false:
+  ///    class MyClass                  vs.     class MyClass : public X, public Y {
+  ///        : public X                         };
+  ///        , public Y {
+  ///    };
+  /// \endcode
+  bool BreakBeforeInheritanceComma;
+
+  /// \brief If the constructor initializers don't fit on a line, put each
+  /// initializer on its own line.
+  /// \code
+  ///   true:
+  ///   SomeClass::Constructor()
+  ///       : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
+  ///     return 0;
+  ///   }
+  ///
+  ///   false:
+  ///   SomeClass::Constructor()
+  ///       : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
+  ///         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
+  ///     return 0;
+  ///   }
+  /// \endcode
+  bool ConstructorInitializerAllOnOneLineOrOnePerLine;
+
+  /// \brief The number of characters to use for indentation of constructor
+  /// initializer lists.
+  unsigned ConstructorInitializerIndentWidth;
+
+  /// \brief Indent width for line continuations.
+  unsigned ContinuationIndentWidth;
+
+  /// \brief If ``true``, format braced lists as best suited for C++11 braced
+  /// lists.
+  ///
+  /// Important differences:
+  /// - No spaces inside the braced list.
+  /// - No line break before the closing brace.
+  /// - Indentation with the continuation indent, not with the block indent.
+  ///
+  /// Fundamentally, C++11 braced lists are formatted exactly like function
+  /// calls would be formatted in their place. If the braced list follows a name
+  /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
+  /// the parentheses of a function call with that name. If there is no name,
+  /// a zero-length name is assumed.
+  bool Cpp11BracedListStyle;
+
+  /// \brief If ``true``, analyze the formatted file for the most common
+  /// alignment of ``&`` and ``*``. ``PointerAlignment`` is then used only as
+  /// fallback.
+  bool DerivePointerAlignment;
+
+  /// \brief Disables formatting completely.
+  bool DisableFormat;
+
+  /// \brief If ``true``, clang-format detects whether function calls and
+  /// definitions are formatted with one parameter per line.
+  ///
+  /// Each call can be bin-packed, one-per-line or inconclusive. If it is
+  /// inconclusive, e.g. completely on one line, but a decision needs to be
+  /// made, clang-format analyzes whether there are other bin-packed cases in
+  /// the input file and act accordingly.
+  ///
+  /// NOTE: This is an experimental flag, that might go away or be renamed. Do
+  /// not use this in config files, etc. Use at your own risk.
+  bool ExperimentalAutoDetectBinPacking;
+
+  /// \brief If ``true``, clang-format adds missing namespace end comments and
+  /// fixes invalid existing ones.
+  /// \code
+  ///    true:                                  false:
+  ///    namespace a {                  vs.     namespace a {
+  ///    foo();                                 foo();
+  ///    } // namespace a;                      }
+  /// \endcode
+  bool FixNamespaceComments;
+
+  /// \brief A vector of macros that should be interpreted as foreach loops
+  /// instead of as function calls.
+  ///
+  /// These are expected to be macros of the form:
+  /// \code
+  ///   FOREACH(<variable-declaration>, ...)
+  ///     <loop-body>
+  /// \endcode
+  ///
+  /// In the .clang-format configuration file, this can be configured like:
+  /// \code{.yaml}
+  ///   ForEachMacros: ['RANGES_FOR', 'FOREACH']
+  /// \endcode
+  ///
+  /// For example: BOOST_FOREACH.
+  std::vector<std::string> ForEachMacros;
+
+  /// \brief See documentation of ``IncludeCategories``.
+  struct IncludeCategory {
+    /// \brief The regular expression that this category matches.
+    std::string Regex;
+    /// \brief The priority to assign to this category.
+    int Priority;
+    bool operator==(const IncludeCategory &Other) const {
+      return Regex == Other.Regex && Priority == Other.Priority;
+    }
+  };
+
+  /// \brief Regular expressions denoting the different ``#include`` categories
+  /// used for ordering ``#includes``.
+  ///
+  /// These regular expressions are matched against the filename of an include
+  /// (including the <> or "") in order. The value belonging to the first
+  /// matching regular expression is assigned and ``#includes`` are sorted first
+  /// according to increasing category number and then alphabetically within
+  /// each category.
+  ///
+  /// If none of the regular expressions match, INT_MAX is assigned as
+  /// category. The main header for a source file automatically gets category 0.
+  /// so that it is generally kept at the beginning of the ``#includes``
+  /// (http://llvm.org/docs/CodingStandards.html#include-style). However, you
+  /// can also assign negative priorities if you have certain headers that
+  /// always need to be first.
+  ///
+  /// To configure this in the .clang-format file, use:
+  /// \code{.yaml}
+  ///   IncludeCategories:
+  ///     - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+  ///       Priority:        2
+  ///     - Regex:           '^(<|"(gtest|isl|json)/)'
+  ///       Priority:        3
+  ///     - Regex:           '.*'
+  ///       Priority:        1
+  /// \endcode
+  std::vector<IncludeCategory> IncludeCategories;
+
+  /// \brief Specify a regular expression of suffixes that are allowed in the
+  /// file-to-main-include mapping.
+  ///
+  /// When guessing whether a #include is the "main" include (to assign
+  /// category 0, see above), use this regex of allowed suffixes to the header
+  /// stem. A partial match is done, so that:
+  /// - "" means "arbitrary suffix"
+  /// - "$" means "no suffix"
+  ///
+  /// For example, if configured to "(_test)?$", then a header a.h would be seen
+  /// as the "main" include in both a.cc and a_test.cc.
+  std::string IncludeIsMainRegex;
+
+  /// \brief Indent case labels one level from the switch statement.
+  ///
+  /// When ``false``, use the same indentation level as for the switch statement.
+  /// Switch statement body is always indented one level more than case labels.
+  bool IndentCaseLabels;
+
+  /// \brief The number of columns to use for indentation.
+  /// \code
+  ///    IndentWidth: 3
+  ///    void f() {
+  ///       someFunction();
+  ///       if (true, false) {
+  ///          f();
+  ///       }
+  ///    }
+  /// \endcode
+  unsigned IndentWidth;
+
+  /// \brief Indent if a function definition or declaration is wrapped after the
+  /// type.
+  bool IndentWrappedFunctionNames;
+
+  /// \brief Quotation styles for JavaScript strings. Does not affect template
+  /// strings.
+  enum JavaScriptQuoteStyle {
+    /// Leave string quotes as they are.
+    /// \code{.js}
+    ///    string1 = "foo";
+    ///    string2 = 'bar';
+    /// \endcode
+    JSQS_Leave,
+    /// Always use single quotes.
+    /// \code{.js}
+    ///    string1 = 'foo';
+    ///    string2 = 'bar';
+    /// \endcode
+    JSQS_Single,
+    /// Always use double quotes.
+    /// \code{.js}
+    ///    string1 = "foo";
+    ///    string2 = "bar";
+    /// \endcode
+    JSQS_Double
+  };
+
+  /// \brief The JavaScriptQuoteStyle to use for JavaScript strings.
+  JavaScriptQuoteStyle JavaScriptQuotes;
+
+  /// \brief Whether to wrap JavaScript import/export statements.
+  /// \code{.js}
+  ///    true:
+  ///    import {
+  ///        VeryLongImportsAreAnnoying,
+  ///        VeryLongImportsAreAnnoying,
+  ///        VeryLongImportsAreAnnoying,
+  ///    } from 'some/module.js'
+  ///
+  ///    false:
+  ///    import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
+  /// \endcode
+  bool JavaScriptWrapImports;
+
+  /// \brief If true, empty lines at the start of blocks are kept.
+  bool KeepEmptyLinesAtTheStartOfBlocks;
+
+  /// \brief Supported languages.
+  ///
+  /// When stored in a configuration file, specifies the language, that the
+  /// configuration targets. When passed to the ``reformat()`` function, enables
+  /// syntax features specific to the language.
+  enum LanguageKind {
+    /// Do not use.
+    LK_None,
+    /// Should be used for C, C++.
+    LK_Cpp,
+    /// Should be used for Java.
+    LK_Java,
+    /// Should be used for JavaScript.
+    LK_JavaScript,
+    /// Should be used for Objective-C, Objective-C++.
+    LK_ObjC,
+    /// Should be used for Protocol Buffers
+    /// (https://developers.google.com/protocol-buffers/).
+    LK_Proto,
+    /// Should be used for TableGen code.
+    LK_TableGen
+  };
+  bool IsCpp() const { return Language == LK_Cpp || Language == LK_ObjC; }
+
+  /// \brief Language, this format style is targeted at.
+  LanguageKind Language;
+
+  /// \brief A regular expression matching macros that start a block.
+  /// \code
+  ///    # With:
+  ///    MacroBlockBegin: "^NS_MAP_BEGIN|\
+  ///    NS_TABLE_HEAD$"
+  ///    MacroBlockEnd: "^\
+  ///    NS_MAP_END|\
+  ///    NS_TABLE_.*_END$"
+  ///
+  ///    NS_MAP_BEGIN
+  ///      foo();
+  ///    NS_MAP_END
+  ///
+  ///    NS_TABLE_HEAD
+  ///      bar();
+  ///    NS_TABLE_FOO_END
+  ///
+  ///    # Without:
+  ///    NS_MAP_BEGIN
+  ///    foo();
+  ///    NS_MAP_END
+  ///
+  ///    NS_TABLE_HEAD
+  ///    bar();
+  ///    NS_TABLE_FOO_END
+  /// \endcode
+  std::string MacroBlockBegin;
+
+  /// \brief A regular expression matching macros that end a block.
+  std::string MacroBlockEnd;
+
+  /// \brief The maximum number of consecutive empty lines to keep.
+  /// \code
+  ///    MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
+  ///    int f() {                              int f() {
+  ///      int = 1;                                 int i = 1;
+  ///                                               i = foo();
+  ///      i = foo();                               return i;
+  ///                                           }
+  ///      return i;
+  ///    }
+  /// \endcode
+  unsigned MaxEmptyLinesToKeep;
+
+  /// \brief Different ways to indent namespace contents.
+  enum NamespaceIndentationKind {
+    /// Don't indent in namespaces.
+    /// \code
+    ///    namespace out {
+    ///    int i;
+    ///    namespace in {
+    ///    int i;
+    ///    }
+    ///    }
+    /// \endcode
+    NI_None,
+    /// Indent only in inner namespaces (nested in other namespaces).
+    /// \code
+    ///    namespace out {
+    ///    int i;
+    ///    namespace in {
+    ///      int i;
+    ///    }
+    ///    }
+    /// \endcode
+    NI_Inner,
+    /// Indent in all namespaces.
+    /// \code
+    ///    namespace out {
+    ///      int i;
+    ///      namespace in {
+    ///        int i;
+    ///      }
+    ///    }
+    /// \endcode
+    NI_All
+  };
+
+  /// \brief The indentation used for namespaces.
+  NamespaceIndentationKind NamespaceIndentation;
+
+  /// \brief The number of characters to use for indentation of ObjC blocks.
+  unsigned ObjCBlockIndentWidth;
+
+  /// \brief Add a space after ``@property`` in Objective-C, i.e. use
+  /// ``@property (readonly)`` instead of ``@property(readonly)``.
+  bool ObjCSpaceAfterProperty;
+
+  /// \brief Add a space in front of an Objective-C protocol list, i.e. use
+  /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
+  bool ObjCSpaceBeforeProtocolList;
+
+  /// \brief The penalty for breaking a function call after ``call(``.
+  unsigned PenaltyBreakBeforeFirstCallParameter;
+
+  /// \brief The penalty for each line break introduced inside a comment.
+  unsigned PenaltyBreakComment;
+
+  /// \brief The penalty for breaking before the first ``<<``.
+  unsigned PenaltyBreakFirstLessLess;
+
+  /// \brief The penalty for each line break introduced inside a string literal.
+  unsigned PenaltyBreakString;
+
+  /// \brief The penalty for each character outside of the column limit.
+  unsigned PenaltyExcessCharacter;
+
+  /// \brief Penalty for putting the return type of a function onto its own
+  /// line.
+  unsigned PenaltyReturnTypeOnItsOwnLine;
+
+  /// \brief The ``&`` and ``*`` alignment style.
+  enum PointerAlignmentStyle {
+    /// Align pointer to the left.
+    /// \code
+    ///   int* a;
+    /// \endcode
+    PAS_Left,
+    /// Align pointer to the right.
+    /// \code
+    ///   int *a;
+    /// \endcode
+    PAS_Right,
+    /// Align pointer in the middle.
+    /// \code
+    ///   int * a;
+    /// \endcode
+    PAS_Middle
+  };
+
+  /// \brief Pointer and reference alignment style.
+  PointerAlignmentStyle PointerAlignment;
+
+  /// \brief Different ways when to indent preprocessor directives.
+  enum PPDirectiveIndentationKind {
+    /// Don't indent preprocessor directives.
+    PPDI_None,
+    /// Indent preprocessor directives except for include guards.
+    PPDI_Inner,
+    /// Indent all preprocessor directives.
+    PPDI_All
+  };
+
+  /// \brief The indentation used for preprocessor directives.
+  PPDirectiveIndentationKind PPDirectiveIndentation;
+
+  /// \brief Different ways when to indent preprocessor directives.
+  /// This option is taken into account if PPDirectiveIndentation is different
+  /// from PPDI_None.
+  enum PPDirectiveIndentationStyleKind {
+    /// Indent by inserting spaces between hash and directive name.
+    PPDIS_AfterHash,
+    /// Indent by inserting spaces before hash.
+    PPDIS_BeforeHash
+  };
+
+  /// \brief The indentation used for preprocessor directives.
+  PPDirectiveIndentationStyleKind PPDirectiveIndentationStyle;
+
+  /// \brief If ``true``, clang-format will attempt to re-flow comments.
+  /// \code
+  ///    false:
+  ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
+  ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
+  ///
+  ///    true:
+  ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
+  ///    // information
+  ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
+  ///     * information */
+  /// \endcode
+  bool ReflowComments;
+
+  /// \brief If ``true``, clang-format will sort ``#includes``.
+  /// \code
+  ///    false:                                 true:
+  ///    #include "b.h"                 vs.     #include "a.h"
+  ///    #include "a.h"                         #include "b.h"
+  /// \endcode
+  bool SortIncludes;
+
+  /// \brief If ``true``, a space is inserted after C style casts.
+  /// \code
+  ///    true:                                  false:
+  ///    (int)i;                        vs.     (int) i;
+  /// \endcode
+  bool SpaceAfterCStyleCast;
+
+  /// \brief If \c true, a space will be inserted after the 'template' keyword.
+  /// \code
+  ///    true:                                  false:
+  ///    template <int> void foo();     vs.     template<int> void foo();
+  /// \endcode
+  bool SpaceAfterTemplateKeyword;
+
+  /// \brief If ``false``, spaces will be removed before assignment operators.
+  /// \code
+  ///    true:                                  false:
+  ///    int a = 5;                     vs.     int a=5;
+  ///    a += 42                                a+=42;
+  /// \endcode
+  bool SpaceBeforeAssignmentOperators;
+
+  /// \brief Different ways to put a space before opening parentheses.
+  enum SpaceBeforeParensOptions {
+    /// Never put a space before opening parentheses.
+    /// \code
+    ///    void f() {
+    ///      if(true) {
+    ///        f();
+    ///      }
+    ///    }
+    /// \endcode
+    SBPO_Never,
+    /// Put a space before opening parentheses only after control statement
+    /// keywords (``for/if/while...``).
+    /// \code
+    ///    void f() {
+    ///      if (true) {
+    ///        f();
+    ///      }
+    ///    }
+    /// \endcode
+    SBPO_ControlStatements,
+    /// Always put a space before opening parentheses, except when it's
+    /// prohibited by the syntax rules (in function-like macro definitions) or
+    /// when determined by other style rules (after unary operators, opening
+    /// parentheses, etc.)
+    /// \code
+    ///    void f () {
+    ///      if (true) {
+    ///        f ();
+    ///      }
+    ///    }
+    /// \endcode
+    SBPO_Always
+  };
+
+  /// \brief Defines in which cases to put a space before opening parentheses.
+  SpaceBeforeParensOptions SpaceBeforeParens;
+
+  /// \brief If ``true``, spaces may be inserted into ``()``.
+  /// \code
+  ///    true:                                false:
+  ///    void f( ) {                    vs.   void f() {
+  ///      int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
+  ///      if (true) {                          if (true) {
+  ///        f( );                                f();
+  ///      }                                    }
+  ///    }                                    }
+  /// \endcode
+  bool SpaceInEmptyParentheses;
+
+  /// \brief The number of spaces before trailing line comments
+  /// (``//`` - comments).
+  ///
+  /// This does not affect trailing block comments (``/*`` - comments) as
+  /// those commonly have different usage patterns and a number of special
+  /// cases.
+  /// \code
+  ///    SpacesBeforeTrailingComments: 3
+  ///    void f() {
+  ///      if (true) {   // foo1
+  ///        f();        // bar
+  ///      }             // foo
+  ///    }
+  /// \endcode
+  unsigned SpacesBeforeTrailingComments;
+
+  /// \brief If ``true``, spaces will be inserted after ``<`` and before ``>``
+  /// in template argument lists.
+  /// \code
+  ///    true:                                  false:
+  ///    static_cast< int >(arg);       vs.     static_cast<int>(arg);
+  ///    std::function< void(int) > fct;        std::function<void(int)> fct;
+  /// \endcode
+  bool SpacesInAngles;
+
+  /// \brief If ``true``, spaces are inserted inside container literals (e.g.
+  /// ObjC and Javascript array and dict literals).
+  /// \code{.js}
+  ///    true:                                  false:
+  ///    var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
+  ///    f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
+  /// \endcode
+  bool SpacesInContainerLiterals;
+
+  /// \brief If ``true``, spaces may be inserted into C style casts.
+  /// \code
+  ///    true:                                  false:
+  ///    x = ( int32 )y                 vs.     x = (int32)y
+  /// \endcode
+  bool SpacesInCStyleCastParentheses;
+
+  /// \brief If ``true``, spaces will be inserted after ``(`` and before ``)``.
+  /// \code
+  ///    true:                                  false:
+  ///    t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
+  /// \endcode
+  bool SpacesInParentheses;
+
+  /// \brief If ``true``, spaces will be inserted after ``[`` and before ``]``.
+  /// Lambdas or unspecified size array declarations will not be affected.
+  /// \code
+  ///    true:                                  false:
+  ///    int a[ 5 ];                    vs.     int a[5];
+  ///    std::unique_ptr<int[]> foo() {} // Won't be affected
+  /// \endcode
+  bool SpacesInSquareBrackets;
+
+  /// \brief Supported language standards.
+  enum LanguageStandard {
+    /// Use C++03-compatible syntax.
+    LS_Cpp03,
+    /// Use features of C++11 (e.g. ``A<A<int>>`` instead of ``A<A<int> >``).
+    LS_Cpp11,
+    /// Automatic detection based on the input.
+    LS_Auto
+  };
+
+  /// \brief Format compatible with this standard, e.g. use ``A<A<int> >``
+  /// instead of ``A<A<int>>`` for ``LS_Cpp03``.
+  LanguageStandard Standard;
+
+  /// \brief The number of columns used for tab stops.
+  unsigned TabWidth;
+
+  /// \brief Different ways to use tab in formatting.
+  enum UseTabStyle {
+    /// Never use tab.
+    UT_Never,
+    /// Use tabs only for indentation.
+    UT_ForIndentation,
+    /// Use tabs only for line continuation and indentation.
+    UT_ForContinuationAndIndentation,
+    /// Use tabs whenever we need to fill whitespace that spans at least from
+    /// one tab stop to the next one.
+    UT_Always
+  };
+
+  /// \brief The way to use tab characters in the resulting file.
+  UseTabStyle UseTab;
+
+  bool operator==(const FormatStyle &R) const {
+    return AccessModifierOffset == R.AccessModifierOffset &&
+           AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
+           AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
+           AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
+           AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft &&
+           AlignOperands == R.AlignOperands &&
+           AlignTrailingComments == R.AlignTrailingComments &&
+           AllowAllParametersOfDeclarationOnNextLine ==
+               R.AllowAllParametersOfDeclarationOnNextLine &&
+           AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
+           AllowShortCaseLabelsOnASingleLine ==
+               R.AllowShortCaseLabelsOnASingleLine &&
+           AllowShortFunctionsOnASingleLine ==
+               R.AllowShortFunctionsOnASingleLine &&
+           AllowShortIfStatementsOnASingleLine ==
+               R.AllowShortIfStatementsOnASingleLine &&
+           AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
+           AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
+           AlwaysBreakBeforeMultilineStrings ==
+               R.AlwaysBreakBeforeMultilineStrings &&
+           AlwaysBreakTemplateDeclarations ==
+               R.AlwaysBreakTemplateDeclarations &&
+           BinPackArguments == R.BinPackArguments &&
+           BinPackParameters == R.BinPackParameters &&
+           BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
+           BreakBeforeBraces == R.BreakBeforeBraces &&
+           BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
+           BreakConstructorInitializersBeforeComma ==
+               R.BreakConstructorInitializersBeforeComma &&
+           BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
+           BreakStringLiterals == R.BreakStringLiterals &&
+           ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
+           BreakBeforeInheritanceComma == R.BreakBeforeInheritanceComma &&
+           ConstructorInitializerAllOnOneLineOrOnePerLine ==
+               R.ConstructorInitializerAllOnOneLineOrOnePerLine &&
+           ConstructorInitializerIndentWidth ==
+               R.ConstructorInitializerIndentWidth &&
+           ContinuationIndentWidth == R.ContinuationIndentWidth &&
+           Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
+           DerivePointerAlignment == R.DerivePointerAlignment &&
+           DisableFormat == R.DisableFormat &&
+           ExperimentalAutoDetectBinPacking ==
+               R.ExperimentalAutoDetectBinPacking &&
+           FixNamespaceComments == R.FixNamespaceComments &&
+           ForEachMacros == R.ForEachMacros &&
+           IncludeCategories == R.IncludeCategories &&
+           IndentCaseLabels == R.IndentCaseLabels &&
+           IndentWidth == R.IndentWidth && Language == R.Language &&
+           IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
+           JavaScriptQuotes == R.JavaScriptQuotes &&
+           JavaScriptWrapImports == R.JavaScriptWrapImports &&
+           KeepEmptyLinesAtTheStartOfBlocks ==
+               R.KeepEmptyLinesAtTheStartOfBlocks &&
+           MacroBlockBegin == R.MacroBlockBegin &&
+           MacroBlockEnd == R.MacroBlockEnd &&
+           MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
+           NamespaceIndentation == R.NamespaceIndentation &&
+           ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
+           ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
+           ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
+           PenaltyBreakBeforeFirstCallParameter ==
+               R.PenaltyBreakBeforeFirstCallParameter &&
+           PenaltyBreakComment == R.PenaltyBreakComment &&
+           PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
+           PenaltyBreakString == R.PenaltyBreakString &&
+           PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
+           PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
+           PointerAlignment == R.PointerAlignment &&
+           PPDirectiveIndentation == R.PPDirectiveIndentation &&
+           PPDirectiveIndentationStyle == R.PPDirectiveIndentationStyle &&
+           SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
+           SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
+           SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
+           SpaceBeforeParens == R.SpaceBeforeParens &&
+           SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
+           SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
+           SpacesInAngles == R.SpacesInAngles &&
+           SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
+           SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
+           SpacesInParentheses == R.SpacesInParentheses &&
+           SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
+           Standard == R.Standard && TabWidth == R.TabWidth &&
+           UseTab == R.UseTab;
+  }
+};
+
+/// \brief Returns a format style complying with the LLVM coding standards:
+/// http://llvm.org/docs/CodingStandards.html.
+FormatStyle getLLVMStyle();
+
+/// \brief Returns a format style complying with one of Google's style guides:
+/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
+/// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
+/// https://developers.google.com/protocol-buffers/docs/style.
+FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
+
+/// \brief Returns a format style complying with Chromium's style guide:
+/// http://www.chromium.org/developers/coding-style.
+FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
+
+/// \brief Returns a format style complying with Mozilla's style guide:
+/// https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style.
+FormatStyle getMozillaStyle();
+
+/// \brief Returns a format style complying with Webkit's style guide:
+/// http://www.webkit.org/coding/coding-style.html
+FormatStyle getWebKitStyle();
+
+/// \brief Returns a format style complying with GNU Coding Standards:
+/// http://www.gnu.org/prep/standards/standards.html
+FormatStyle getGNUStyle();
+
+/// \brief Returns style indicating formatting should be not applied at all.
+FormatStyle getNoStyle();
+
+/// \brief Gets a predefined style for the specified language by name.
+///
+/// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are
+/// compared case-insensitively.
+///
+/// Returns ``true`` if the Style has been set.
+bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
+                        FormatStyle *Style);
+
+/// \brief Parse configuration from YAML-formatted text.
+///
+/// Style->Language is used to get the base style, if the ``BasedOnStyle``
+/// option is present.
+///
+/// When ``BasedOnStyle`` is not present, options not present in the YAML
+/// document, are retained in \p Style.
+std::error_code parseConfiguration(StringRef Text, FormatStyle *Style);
+
+/// \brief Gets configuration in a YAML string.
+std::string configurationAsText(const FormatStyle &Style);
+
+/// \brief Returns the replacements necessary to sort all ``#include`` blocks
+/// that are affected by ``Ranges``.
+tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
+                                   ArrayRef<tooling::Range> Ranges,
+                                   StringRef FileName,
+                                   unsigned *Cursor = nullptr);
+
+/// \brief Returns the replacements necessary to format all preprocessor
+/// directives that are affected by ``Ranges``.
+tooling::Replacements formatPPDirectives(const FormatStyle &Style,
+                                         StringRef Code,
+                                         ArrayRef<tooling::Range> Ranges,
+                                         StringRef FileName,
+                                         unsigned *Cursor = nullptr);
+
+/// \brief Returns the replacements corresponding to applying and formatting
+/// \p Replaces on success; otheriwse, return an llvm::Error carrying
+/// llvm::StringError.
+llvm::Expected<tooling::Replacements>
+formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
+                   const FormatStyle &Style);
+
+/// \brief Returns the replacements corresponding to applying \p Replaces and
+/// cleaning up the code after that on success; otherwise, return an llvm::Error
+/// carrying llvm::StringError.
+/// This also supports inserting/deleting C++ #include directives:
+/// - If a replacement has offset UINT_MAX, length 0, and a replacement text
+///   that is an #include directive, this will insert the #include into the
+///   correct block in the \p Code. When searching for points to insert new
+///   header, this ignores #include's after the #include block(s) in the
+///   beginning of a file to avoid inserting headers into code sections where
+///   new #include's should not be added by default. These code sections
+///   include:
+///     - raw string literals (containing #include).
+///     - #if blocks.
+///     - Special #include's among declarations (e.g. functions).
+/// - If a replacement has offset UINT_MAX, length 1, and a replacement text
+///   that is the name of the header to be removed, the header will be removed
+///   from \p Code if it exists.
+llvm::Expected<tooling::Replacements>
+cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
+                          const FormatStyle &Style);
+
+/// \brief Reformats the given \p Ranges in \p Code.
+///
+/// Each range is extended on either end to its next bigger logic unit, i.e.
+/// everything that might influence its formatting or might be influenced by its
+/// formatting.
+///
+/// Returns the ``Replacements`` necessary to make all \p Ranges comply with
+/// \p Style.
+///
+/// If ``IncompleteFormat`` is non-null, its value will be set to true if any
+/// of the affected ranges were not formatted due to a non-recoverable syntax
+/// error.
+tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+                               ArrayRef<tooling::Range> Ranges,
+                               StringRef FileName = "<stdin>",
+                               bool *IncompleteFormat = nullptr);
+
+/// \brief Clean up any erroneous/redundant code in the given \p Ranges in \p
+/// Code.
+///
+/// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
+tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
+                              ArrayRef<tooling::Range> Ranges,
+                              StringRef FileName = "<stdin>");
+
+/// \brief Fix namespace end comments in the given \p Ranges in \p Code.
+///
+/// Returns the ``Replacements`` that fix the namespace comments in all
+/// \p Ranges in \p Code.
+tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
+                                              StringRef Code,
+                                              ArrayRef<tooling::Range> Ranges,
+                                              StringRef FileName = "<stdin>");
+
+/// \brief Returns the ``LangOpts`` that the formatter expects you to set.
+///
+/// \param Style determines specific settings for lexing mode.
+LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
+
+/// \brief Description to be used for help text for a ``llvm::cl`` option for
+/// specifying format style. The description is closely related to the operation
+/// of ``getStyle()``.
+extern const char *StyleOptionHelpDescription;
+
+/// \brief Construct a FormatStyle based on ``StyleName``.
+///
+/// ``StyleName`` can take several forms:
+/// * "{<key>: <value>, ...}" - Set specic style parameters.
+/// * "<style name>" - One of the style names supported by
+/// getPredefinedStyle().
+/// * "file" - Load style configuration from a file called ``.clang-format``
+/// located in one of the parent directories of ``FileName`` or the current
+/// directory if ``FileName`` is empty.
+///
+/// \param[in] StyleName Style name to interpret according to the description
+/// above.
+/// \param[in] FileName Path to start search for .clang-format if ``StyleName``
+/// == "file".
+/// \param[in] FallbackStyle The name of a predefined style used to fallback to
+/// in case \p StyleName is "file" and no file can be found.
+/// \param[in] Code The actual code to be formatted. Used to determine the
+/// language if the filename isn't sufficient.
+/// \param[in] FS The underlying file system, in which the file resides. By
+/// default, the file system is the real file system.
+///
+/// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is
+/// "file" and no file is found, returns ``FallbackStyle``. If no style could be
+/// determined, returns an Error.
+llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
+                                     StringRef FallbackStyle,
+                                     StringRef Code = "",
+                                     vfs::FileSystem *FS = nullptr);
+
+// \brief Returns a string representation of ``Language``.
+inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
+  switch (Language) {
+  case FormatStyle::LK_Cpp:
+    return "C++";
+  case FormatStyle::LK_ObjC:
+    return "Objective-C";
+  case FormatStyle::LK_Java:
+    return "Java";
+  case FormatStyle::LK_JavaScript:
+    return "JavaScript";
+  case FormatStyle::LK_Proto:
+    return "Proto";
+  default:
+    return "Unknown";
+  }
+}
+
+} // end namespace format
+} // end namespace clang
+
+namespace std {
+template <>
+struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
+}
+
+#endif // LLVM_CLANG_FORMAT_FORMAT_H

lib/Format/Format.cpp

-//===--- Format.cpp - Format C++ code -------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file implements functions declared in Format.h. This will be
-/// split into separate files as we go.
-///
-//===----------------------------------------------------------------------===//
-
-#include "clang/Format/Format.h"
-#include "AffectedRangeManager.h"
-#include "ContinuationIndenter.h"
-#include "FormatTokenLexer.h"
-#include "NamespaceEndCommentsFixer.h"
-#include "SortJavaScriptImports.h"
-#include "TokenAnalyzer.h"
-#include "TokenAnnotator.h"
-#include "UnwrappedLineFormatter.h"
-#include "UnwrappedLineParser.h"
-#include "WhitespaceManager.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Basic/VirtualFileSystem.h"
-#include "clang/Lex/Lexer.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Regex.h"
-#include "llvm/Support/YAMLTraits.h"
-#include <algorithm>
-#include <memory>
-#include <string>
-
-#define DEBUG_TYPE "format-formatter"
-
-using clang::format::FormatStyle;
-
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
-LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory)
-
-namespace llvm {
-namespace yaml {
-template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
-  static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
-    IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
-    IO.enumCase(Value, "Java", FormatStyle::LK_Java);
-    IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
-    IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
-    IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
-    IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
-  static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
-    IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
-    IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
-    IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
-    IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
-    IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
-  static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
-    IO.enumCase(Value, "Never", FormatStyle::UT_Never);
-    IO.enumCase(Value, "false", FormatStyle::UT_Never);
-    IO.enumCase(Value, "Always", FormatStyle::UT_Always);
-    IO.enumCase(Value, "true", FormatStyle::UT_Always);
-    IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
-    IO.enumCase(Value, "ForContinuationAndIndentation",
-                FormatStyle::UT_ForContinuationAndIndentation);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> {
-  static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) {
-    IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave);
-    IO.enumCase(Value, "Single", FormatStyle::JSQS_Single);
-    IO.enumCase(Value, "Double", FormatStyle::JSQS_Double);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
-  static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
-    IO.enumCase(Value, "None", FormatStyle::SFS_None);
-    IO.enumCase(Value, "false", FormatStyle::SFS_None);
-    IO.enumCase(Value, "All", FormatStyle::SFS_All);
-    IO.enumCase(Value, "true", FormatStyle::SFS_All);
-    IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
-    IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
-  static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
-    IO.enumCase(Value, "All", FormatStyle::BOS_All);
-    IO.enumCase(Value, "true", FormatStyle::BOS_All);
-    IO.enumCase(Value, "None", FormatStyle::BOS_None);
-    IO.enumCase(Value, "false", FormatStyle::BOS_None);
-    IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
-  static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
-    IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
-    IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
-    IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
-    IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
-    IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
-    IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
-    IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
-    IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
-  }
-};
-
-template <>
-struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
-  static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
-    IO.enumCase(Value, "None", FormatStyle::RTBS_None);
-    IO.enumCase(Value, "All", FormatStyle::RTBS_All);
-    IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
-    IO.enumCase(Value, "TopLevelDefinitions",
-                FormatStyle::RTBS_TopLevelDefinitions);
-    IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
-  }
-};
-
-template <>
-struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
-  static void
-  enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
-    IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
-    IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
-    IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
-
-    // For backward compatibility.
-    IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
-    IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
-  }
-};
-
-template <>
-struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
-  static void enumeration(IO &IO,
-                          FormatStyle::NamespaceIndentationKind &Value) {
-    IO.enumCase(Value, "None", FormatStyle::NI_None);
-    IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
-    IO.enumCase(Value, "All", FormatStyle::NI_All);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
-  static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
-    IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
-    IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
-    IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
-
-    // For backward compatibility.
-    IO.enumCase(Value, "true", FormatStyle::BAS_Align);
-    IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
-  static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
-    IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
-    IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
-    IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
-
-    // For backward compatibility.
-    IO.enumCase(Value, "true", FormatStyle::PAS_Left);
-    IO.enumCase(Value, "false", FormatStyle::PAS_Right);
-  }
-};
-
-template <>
-struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
-  static void enumeration(IO &IO,
-                          FormatStyle::SpaceBeforeParensOptions &Value) {
-    IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
-    IO.enumCase(Value, "ControlStatements",
-                FormatStyle::SBPO_ControlStatements);
-    IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
-
-    // For backward compatibility.
-    IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
-    IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
-  }
-};
-
-template <> struct MappingTraits<FormatStyle> {
-  static void mapping(IO &IO, FormatStyle &Style) {
-    // When reading, read the language first, we need it for getPredefinedStyle.
-    IO.mapOptional("Language", Style.Language);
-
-    if (IO.outputting()) {
-      StringRef StylesArray[] = {"LLVM",    "Google", "Chromium",
-                                 "Mozilla", "WebKit", "GNU"};
-      ArrayRef<StringRef> Styles(StylesArray);
-      for (size_t i = 0, e = Styles.size(); i < e; ++i) {
-        StringRef StyleName(Styles[i]);
-        FormatStyle PredefinedStyle;
-        if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
-            Style == PredefinedStyle) {
-          IO.mapOptional("# BasedOnStyle", StyleName);
-          break;
-        }
-      }
-    } else {
-      StringRef BasedOnStyle;
-      IO.mapOptional("BasedOnStyle", BasedOnStyle);
-      if (!BasedOnStyle.empty()) {
-        FormatStyle::LanguageKind OldLanguage = Style.Language;
-        FormatStyle::LanguageKind Language =
-            ((FormatStyle *)IO.getContext())->Language;
-        if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
-          IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
-          return;
-        }
-        Style.Language = OldLanguage;
-      }
-    }
-
-    // For backward compatibility.
-    if (!IO.outputting()) {
-      IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
-      IO.mapOptional("IndentFunctionDeclarationAfterType",
-                     Style.IndentWrappedFunctionNames);
-      IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
-      IO.mapOptional("SpaceAfterControlStatementKeyword",
-                     Style.SpaceBeforeParens);
-    }
-
-    IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
-    IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
-    IO.mapOptional("AlignConsecutiveAssignments",
-                   Style.AlignConsecutiveAssignments);
-    IO.mapOptional("AlignConsecutiveDeclarations",
-                   Style.AlignConsecutiveDeclarations);
-    IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
-    IO.mapOptional("AlignOperands", Style.AlignOperands);
-    IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
-    IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
-                   Style.AllowAllParametersOfDeclarationOnNextLine);
-    IO.mapOptional("AllowShortBlocksOnASingleLine",
-                   Style.AllowShortBlocksOnASingleLine);
-    IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
-                   Style.AllowShortCaseLabelsOnASingleLine);
-    IO.mapOptional("AllowShortFunctionsOnASingleLine",
-                   Style.AllowShortFunctionsOnASingleLine);
-    IO.mapOptional("AllowShortIfStatementsOnASingleLine",
-                   Style.AllowShortIfStatementsOnASingleLine);
-    IO.mapOptional("AllowShortLoopsOnASingleLine",
-                   Style.AllowShortLoopsOnASingleLine);
-    IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
-                   Style.AlwaysBreakAfterDefinitionReturnType);
-    IO.mapOptional("AlwaysBreakAfterReturnType",
-                   Style.AlwaysBreakAfterReturnType);
-    // If AlwaysBreakAfterDefinitionReturnType was specified but
-    // AlwaysBreakAfterReturnType was not, initialize the latter from the
-    // former for backwards compatibility.
-    if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
-        Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
-      if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
-        Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
-      else if (Style.AlwaysBreakAfterDefinitionReturnType ==
-               FormatStyle::DRTBS_TopLevel)
-        Style.AlwaysBreakAfterReturnType =
-            FormatStyle::RTBS_TopLevelDefinitions;
-    }
-
-    IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
-                   Style.AlwaysBreakBeforeMultilineStrings);
-    IO.mapOptional("AlwaysBreakTemplateDeclarations",
-                   Style.AlwaysBreakTemplateDeclarations);
-    IO.mapOptional("BinPackArguments", Style.BinPackArguments);
-    IO.mapOptional("BinPackParameters", Style.BinPackParameters);
-    IO.mapOptional("BraceWrapping", Style.BraceWrapping);
-    IO.mapOptional("BreakBeforeBinaryOperators",
-                   Style.BreakBeforeBinaryOperators);
-    IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
-    IO.mapOptional("BreakBeforeTernaryOperators",
-                   Style.BreakBeforeTernaryOperators);
-    IO.mapOptional("BreakConstructorInitializersBeforeComma",
-                   Style.BreakConstructorInitializersBeforeComma);
-    IO.mapOptional("BreakAfterJavaFieldAnnotations",
-                   Style.BreakAfterJavaFieldAnnotations);
-    IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
-    IO.mapOptional("ColumnLimit", Style.ColumnLimit);
-    IO.mapOptional("CommentPragmas", Style.CommentPragmas);
-    IO.mapOptional("BreakBeforeInheritanceComma",
-                   Style.BreakBeforeInheritanceComma);
-    IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
-                   Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
-    IO.mapOptional("ConstructorInitializerIndentWidth",
-                   Style.ConstructorInitializerIndentWidth);
-    IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
-    IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
-    IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
-    IO.mapOptional("DisableFormat", Style.DisableFormat);
-    IO.mapOptional("ExperimentalAutoDetectBinPacking",
-                   Style.ExperimentalAutoDetectBinPacking);
-    IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
-    IO.mapOptional("ForEachMacros", Style.ForEachMacros);
-    IO.mapOptional("IncludeCategories", Style.IncludeCategories);
-    IO.mapOptional("IncludeIsMainRegex", Style.IncludeIsMainRegex);
-    IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
-    IO.mapOptional("IndentWidth", Style.IndentWidth);
-    IO.mapOptional("IndentWrappedFunctionNames",
-                   Style.IndentWrappedFunctionNames);
-    IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
-    IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
-    IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
-                   Style.KeepEmptyLinesAtTheStartOfBlocks);
-    IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
-    IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
-    IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
-    IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
-    IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
-    IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
-    IO.mapOptional("ObjCSpaceBeforeProtocolList",
-                   Style.ObjCSpaceBeforeProtocolList);
-    IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
-                   Style.PenaltyBreakBeforeFirstCallParameter);
-    IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
-    IO.mapOptional("PenaltyBreakFirstLessLess",
-                   Style.PenaltyBreakFirstLessLess);
-    IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
-    IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
-    IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
-                   Style.PenaltyReturnTypeOnItsOwnLine);
-    IO.mapOptional("PointerAlignment", Style.PointerAlignment);
-    IO.mapOptional("ReflowComments", Style.ReflowComments);
-    IO.mapOptional("SortIncludes", Style.SortIncludes);
-    IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
-    IO.mapOptional("SpaceAfterTemplateKeyword", Style.SpaceAfterTemplateKeyword);
-    IO.mapOptional("SpaceBeforeAssignmentOperators",
-                   Style.SpaceBeforeAssignmentOperators);
-    IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
-    IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
-    IO.mapOptional("SpacesBeforeTrailingComments",
-                   Style.SpacesBeforeTrailingComments);
-    IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
-    IO.mapOptional("SpacesInContainerLiterals",
-                   Style.SpacesInContainerLiterals);
-    IO.mapOptional("SpacesInCStyleCastParentheses",
-                   Style.SpacesInCStyleCastParentheses);
-    IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
-    IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
-    IO.mapOptional("Standard", Style.Standard);
-    IO.mapOptional("TabWidth", Style.TabWidth);
-    IO.mapOptional("UseTab", Style.UseTab);
-  }
-};
-
-template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
-  static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
-    IO.mapOptional("AfterClass", Wrapping.AfterClass);
-    IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
-    IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
-    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("IndentBraces", Wrapping.IndentBraces);
-  }
-};
-
-template <> struct MappingTraits<FormatStyle::IncludeCategory> {
-  static void mapping(IO &IO, FormatStyle::IncludeCategory &Category) {
-    IO.mapOptional("Regex", Category.Regex);
-    IO.mapOptional("Priority", Category.Priority);
-  }
-};
-
-// Allows to read vector<FormatStyle> while keeping default values.
-// IO.getContext() should contain a pointer to the FormatStyle structure, that
-// will be used to get default values for missing keys.
-// If the first element has no Language specified, it will be treated as the
-// default one for the following elements.
-template <> struct DocumentListTraits<std::vector<FormatStyle>> {
-  static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
-    return Seq.size();
-  }
-  static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
-                              size_t Index) {
-    if (Index >= Seq.size()) {
-      assert(Index == Seq.size());
-      FormatStyle Template;
-      if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
-        Template = Seq[0];
-      } else {
-        Template = *((const FormatStyle *)IO.getContext());
-        Template.Language = FormatStyle::LK_None;
-      }
-      Seq.resize(Index + 1, Template);
-    }
-    return Seq[Index];
-  }
-};
-} // namespace yaml
-} // namespace llvm
-
-namespace clang {
-namespace format {
-
-const std::error_category &getParseCategory() {
-  static ParseErrorCategory C;
-  return C;
-}
-std::error_code make_error_code(ParseError e) {
-  return std::error_code(static_cast<int>(e), getParseCategory());
-}
-
-inline llvm::Error make_string_error(const llvm::Twine &Message) {
-  return llvm::make_error<llvm::StringError>(Message,
-                                             llvm::inconvertibleErrorCode());
-}
-
-const char *ParseErrorCategory::name() const noexcept {
-  return "clang-format.parse_error";
-}
-
-std::string ParseErrorCategory::message(int EV) const {
-  switch (static_cast<ParseError>(EV)) {
-  case ParseError::Success:
-    return "Success";
-  case ParseError::Error:
-    return "Invalid argument";
-  case ParseError::Unsuitable:
-    return "Unsuitable";
-  }
-  llvm_unreachable("unexpected parse error");
-}
-
-static FormatStyle expandPresets(const FormatStyle &Style) {
-  if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
-    return Style;
-  FormatStyle Expanded = Style;
-  Expanded.BraceWrapping = {false, false, false, false, false, false,
-                            false, false, false, false, false};
-  switch (Style.BreakBeforeBraces) {
-  case FormatStyle::BS_Linux:
-    Expanded.BraceWrapping.AfterClass = true;
-    Expanded.BraceWrapping.AfterFunction = true;
-    Expanded.BraceWrapping.AfterNamespace = true;
-    break;
-  case FormatStyle::BS_Mozilla:
-    Expanded.BraceWrapping.AfterClass = true;
-    Expanded.BraceWrapping.AfterEnum = true;
-    Expanded.BraceWrapping.AfterFunction = true;
-    Expanded.BraceWrapping.AfterStruct = true;
-    Expanded.BraceWrapping.AfterUnion = true;
-    break;
-  case FormatStyle::BS_Stroustrup:
-    Expanded.BraceWrapping.AfterFunction = true;
-    Expanded.BraceWrapping.BeforeCatch = true;
-    Expanded.BraceWrapping.BeforeElse = true;
-    break;
-  case FormatStyle::BS_Allman:
-    Expanded.BraceWrapping.AfterClass = true;
-    Expanded.BraceWrapping.AfterControlStatement = true;
-    Expanded.BraceWrapping.AfterEnum = true;
-    Expanded.BraceWrapping.AfterFunction = true;
-    Expanded.BraceWrapping.AfterNamespace = true;
-    Expanded.BraceWrapping.AfterObjCDeclaration = true;
-    Expanded.BraceWrapping.AfterStruct = true;
-    Expanded.BraceWrapping.BeforeCatch = true;
-    Expanded.BraceWrapping.BeforeElse = true;
-    break;
-  case FormatStyle::BS_GNU:
-    Expanded.BraceWrapping = {true, true, true, true, true, true,
-                              true, true, true, true, true};
-    break;
-  case FormatStyle::BS_WebKit:
-    Expanded.BraceWrapping.AfterFunction = true;
-    break;
-  default:
-    break;
-  }
-  return Expanded;
-}
-
-FormatStyle getLLVMStyle() {
-  FormatStyle LLVMStyle;
-  LLVMStyle.Language = FormatStyle::LK_Cpp;
-  LLVMStyle.AccessModifierOffset = -2;
-  LLVMStyle.AlignEscapedNewlinesLeft = false;
-  LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
-  LLVMStyle.AlignOperands = true;
-  LLVMStyle.AlignTrailingComments = true;
-  LLVMStyle.AlignConsecutiveAssignments = false;
-  LLVMStyle.AlignConsecutiveDeclarations = false;
-  LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
-  LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
-  LLVMStyle.AllowShortBlocksOnASingleLine = false;
-  LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
-  LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
-  LLVMStyle.AllowShortLoopsOnASingleLine = false;
-  LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
-  LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
-  LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
-  LLVMStyle.AlwaysBreakTemplateDeclarations = false;
-  LLVMStyle.BinPackParameters = true;
-  LLVMStyle.BinPackArguments = true;
-  LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
-  LLVMStyle.BreakBeforeTernaryOperators = true;
-  LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
-  LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
-                             false, false, false, false, false};
-  LLVMStyle.BreakAfterJavaFieldAnnotations = false;
-  LLVMStyle.BreakConstructorInitializersBeforeComma = false;
-  LLVMStyle.BreakBeforeInheritanceComma = false;
-  LLVMStyle.BreakStringLiterals = true;
-  LLVMStyle.ColumnLimit = 80;
-  LLVMStyle.CommentPragmas = "^ IWYU pragma:";
-  LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
-  LLVMStyle.ConstructorInitializerIndentWidth = 4;
-  LLVMStyle.ContinuationIndentWidth = 4;
-  LLVMStyle.Cpp11BracedListStyle = true;
-  LLVMStyle.DerivePointerAlignment = false;
-  LLVMStyle.ExperimentalAutoDetectBinPacking = false;
-  LLVMStyle.FixNamespaceComments = true;
-  LLVMStyle.ForEachMacros.push_back("foreach");
-  LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
-  LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
-  LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2},
-                                 {"^(<|\"(gtest|isl|json)/)", 3},
-                                 {".*", 1}};
-  LLVMStyle.IncludeIsMainRegex = "$";
-  LLVMStyle.IndentCaseLabels = false;
-  LLVMStyle.IndentWrappedFunctionNames = false;
-  LLVMStyle.IndentWidth = 2;
-  LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
-  LLVMStyle.JavaScriptWrapImports = true;
-  LLVMStyle.TabWidth = 8;
-  LLVMStyle.MaxEmptyLinesToKeep = 1;
-  LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
-  LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
-  LLVMStyle.ObjCBlockIndentWidth = 2;
-  LLVMStyle.ObjCSpaceAfterProperty = false;
-  LLVMStyle.ObjCSpaceBeforeProtocolList = true;
-  LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
-  LLVMStyle.SpacesBeforeTrailingComments = 1;
-  LLVMStyle.Standard = FormatStyle::LS_Cpp11;
-  LLVMStyle.UseTab = FormatStyle::UT_Never;
-  LLVMStyle.ReflowComments = true;
-  LLVMStyle.SpacesInParentheses = false;
-  LLVMStyle.SpacesInSquareBrackets = false;
-  LLVMStyle.SpaceInEmptyParentheses = false;
-  LLVMStyle.SpacesInContainerLiterals = true;
-  LLVMStyle.SpacesInCStyleCastParentheses = false;
-  LLVMStyle.SpaceAfterCStyleCast = false;
-  LLVMStyle.SpaceAfterTemplateKeyword = true;
-  LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
-  LLVMStyle.SpaceBeforeAssignmentOperators = true;
-  LLVMStyle.SpacesInAngles = false;
-
-  LLVMStyle.PenaltyBreakComment = 300;
-  LLVMStyle.PenaltyBreakFirstLessLess = 120;
-  LLVMStyle.PenaltyBreakString = 1000;
-  LLVMStyle.PenaltyExcessCharacter = 1000000;
-  LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
-  LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
-
-  LLVMStyle.DisableFormat = false;
-  LLVMStyle.SortIncludes = true;
-
-  return LLVMStyle;
-}
-
-FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
-  FormatStyle GoogleStyle = getLLVMStyle();
-  GoogleStyle.Language = Language;
-
-  GoogleStyle.AccessModifierOffset = -1;
-  GoogleStyle.AlignEscapedNewlinesLeft = true;
-  GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
-  GoogleStyle.AllowShortLoopsOnASingleLine = true;
-  GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
-  GoogleStyle.AlwaysBreakTemplateDeclarations = true;
-  GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
-  GoogleStyle.DerivePointerAlignment = true;
-  GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
-  GoogleStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
-  GoogleStyle.IndentCaseLabels = true;
-  GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
-  GoogleStyle.ObjCSpaceAfterProperty = false;
-  GoogleStyle.ObjCSpaceBeforeProtocolList = false;
-  GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
-  GoogleStyle.SpacesBeforeTrailingComments = 2;
-  GoogleStyle.Standard = FormatStyle::LS_Auto;
-
-  GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
-  GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
-
-  if (Language == FormatStyle::LK_Java) {
-    GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-    GoogleStyle.AlignOperands = false;
-    GoogleStyle.AlignTrailingComments = false;
-    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
-    GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
-    GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
-    GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
-    GoogleStyle.ColumnLimit = 100;
-    GoogleStyle.SpaceAfterCStyleCast = true;
-    GoogleStyle.SpacesBeforeTrailingComments = 1;
-  } else if (Language == FormatStyle::LK_JavaScript) {
-    GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-    GoogleStyle.AlignOperands = false;
-    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
-    GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
-    GoogleStyle.BreakBeforeTernaryOperators = false;
-    // taze:, @tag followed by { for a lot of JSDoc tags, and @see, which is
-    // commonly followed by overlong URLs.
-    GoogleStyle.CommentPragmas = "(taze:|(@[A-Za-z_0-9-]+[ \\t]*{)|@see)";
-    GoogleStyle.MaxEmptyLinesToKeep = 3;
-    GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
-    GoogleStyle.SpacesInContainerLiterals = false;
-    GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
-    GoogleStyle.JavaScriptWrapImports = false;
-  } else if (Language == FormatStyle::LK_Proto) {
-    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
-    GoogleStyle.SpacesInContainerLiterals = false;
-  } else if (Language == FormatStyle::LK_ObjC) {
-    GoogleStyle.ColumnLimit = 100;
-  }
-
-  return GoogleStyle;
-}
-
-FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
-  FormatStyle ChromiumStyle = getGoogleStyle(Language);
-  if (Language == FormatStyle::LK_Java) {
-    ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
-    ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
-    ChromiumStyle.ContinuationIndentWidth = 8;
-    ChromiumStyle.IndentWidth = 4;
-  } else if (Language == FormatStyle::LK_JavaScript) {
-    ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
-    ChromiumStyle.AllowShortLoopsOnASingleLine = false;
-  } else {
-    ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
-    ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
-    ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
-    ChromiumStyle.AllowShortLoopsOnASingleLine = false;
-    ChromiumStyle.BinPackParameters = false;
-    ChromiumStyle.DerivePointerAlignment = false;
-    if (Language == FormatStyle::LK_ObjC)
-      ChromiumStyle.ColumnLimit = 80;
-  }
-  return ChromiumStyle;
-}
-
-FormatStyle getMozillaStyle() {
-  FormatStyle MozillaStyle = getLLVMStyle();
-  MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
-  MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
-  MozillaStyle.AlwaysBreakAfterReturnType =
-      FormatStyle::RTBS_TopLevel;
-  MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
-      FormatStyle::DRTBS_TopLevel;
-  MozillaStyle.AlwaysBreakTemplateDeclarations = true;
-  MozillaStyle.BinPackParameters = false;
-  MozillaStyle.BinPackArguments = false;
-  MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
-  MozillaStyle.BreakConstructorInitializersBeforeComma = true;
-  MozillaStyle.BreakBeforeInheritanceComma = true;
-  MozillaStyle.ConstructorInitializerIndentWidth = 2;
-  MozillaStyle.ContinuationIndentWidth = 2;
-  MozillaStyle.Cpp11BracedListStyle = false;
-  MozillaStyle.FixNamespaceComments = false;
-  MozillaStyle.IndentCaseLabels = true;
-  MozillaStyle.ObjCSpaceAfterProperty = true;
-  MozillaStyle.ObjCSpaceBeforeProtocolList = false;
-  MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
-  MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
-  MozillaStyle.SpaceAfterTemplateKeyword = false;
-  return MozillaStyle;
-}
-
-FormatStyle getWebKitStyle() {
-  FormatStyle Style = getLLVMStyle();
-  Style.AccessModifierOffset = -4;
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  Style.AlignOperands = false;
-  Style.AlignTrailingComments = false;
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
-  Style.BreakConstructorInitializersBeforeComma = true;
-  Style.Cpp11BracedListStyle = false;
-  Style.ColumnLimit = 0;
-  Style.FixNamespaceComments = false;
-  Style.IndentWidth = 4;
-  Style.NamespaceIndentation = FormatStyle::NI_Inner;
-  Style.ObjCBlockIndentWidth = 4;
-  Style.ObjCSpaceAfterProperty = true;
-  Style.PointerAlignment = FormatStyle::PAS_Left;
-  return Style;
-}
-
-FormatStyle getGNUStyle() {
-  FormatStyle Style = getLLVMStyle();
-  Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  Style.BreakBeforeBraces = FormatStyle::BS_GNU;
-  Style.BreakBeforeTernaryOperators = true;
-  Style.Cpp11BracedListStyle = false;
-  Style.ColumnLimit = 79;
-  Style.FixNamespaceComments = false;
-  Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
-  Style.Standard = FormatStyle::LS_Cpp03;
-  return Style;
-}
-
-FormatStyle getNoStyle() {
-  FormatStyle NoStyle = getLLVMStyle();
-  NoStyle.DisableFormat = true;
-  NoStyle.SortIncludes = false;
-  return NoStyle;
-}
-
-bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
-                        FormatStyle *Style) {
-  if (Name.equals_lower("llvm")) {
-    *Style = getLLVMStyle();
-  } else if (Name.equals_lower("chromium")) {
-    *Style = getChromiumStyle(Language);
-  } else if (Name.equals_lower("mozilla")) {
-    *Style = getMozillaStyle();
-  } else if (Name.equals_lower("google")) {
-    *Style = getGoogleStyle(Language);
-  } else if (Name.equals_lower("webkit")) {
-    *Style = getWebKitStyle();
-  } else if (Name.equals_lower("gnu")) {
-    *Style = getGNUStyle();
-  } else if (Name.equals_lower("none")) {
-    *Style = getNoStyle();
-  } else {
-    return false;
-  }
-
-  Style->Language = Language;
-  return true;
-}
-
-std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
-  assert(Style);
-  FormatStyle::LanguageKind Language = Style->Language;
-  assert(Language != FormatStyle::LK_None);
-  if (Text.trim().empty())
-    return make_error_code(ParseError::Error);
-
-  std::vector<FormatStyle> Styles;
-  llvm::yaml::Input Input(Text);
-  // DocumentListTraits<vector<FormatStyle>> uses the context to get default
-  // values for the fields, keys for which are missing from the configuration.
-  // Mapping also uses the context to get the language to find the correct
-  // base style.
-  Input.setContext(Style);
-  Input >> Styles;
-  if (Input.error())
-    return Input.error();
-
-  for (unsigned i = 0; i < Styles.size(); ++i) {
-    // Ensures that only the first configuration can skip the Language option.
-    if (Styles[i].Language == FormatStyle::LK_None && i != 0)
-      return make_error_code(ParseError::Error);
-    // Ensure that each language is configured at most once.
-    for (unsigned j = 0; j < i; ++j) {
-      if (Styles[i].Language == Styles[j].Language) {
-        DEBUG(llvm::dbgs()
-              << "Duplicate languages in the config file on positions " << j
-              << " and " << i << "\n");
-        return make_error_code(ParseError::Error);
-      }
-    }
-  }
-  // Look for a suitable configuration starting from the end, so we can
-  // find the configuration for the specific language first, and the default
-  // configuration (which can only be at slot 0) after it.
-  for (int i = Styles.size() - 1; i >= 0; --i) {
-    if (Styles[i].Language == Language ||
-        Styles[i].Language == FormatStyle::LK_None) {
-      *Style = Styles[i];
-      Style->Language = Language;
-      return make_error_code(ParseError::Success);
-    }
-  }
-  return make_error_code(ParseError::Unsuitable);
-}
-
-std::string configurationAsText(const FormatStyle &Style) {
-  std::string Text;
-  llvm::raw_string_ostream Stream(Text);
-  llvm::yaml::Output Output(Stream);
-  // We use the same mapping method for input and output, so we need a non-const
-  // reference here.
-  FormatStyle NonConstStyle = expandPresets(Style);
-  Output << NonConstStyle;
-  return Stream.str();
-}
-
-namespace {
-
-class JavaScriptRequoter : public TokenAnalyzer {
-public:
-  JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
-      : TokenAnalyzer(Env, Style) {}
-
-  tooling::Replacements
-  analyze(TokenAnnotator &Annotator,
-          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
-          FormatTokenLexer &Tokens) override {
-    AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
-                                          AnnotatedLines.end());
-    tooling::Replacements Result;
-    requoteJSStringLiteral(AnnotatedLines, Result);
-    return Result;
-  }
-
-private:
-  // Replaces double/single-quoted string literal as appropriate, re-escaping
-  // the contents in the process.
-  void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
-                              tooling::Replacements &Result) {
-    for (AnnotatedLine *Line : Lines) {
-      requoteJSStringLiteral(Line->Children, Result);
-      if (!Line->Affected)
-        continue;
-      for (FormatToken *FormatTok = Line->First; FormatTok;
-           FormatTok = FormatTok->Next) {
-        StringRef Input = FormatTok->TokenText;
-        if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
-            // NB: testing for not starting with a double quote to avoid
-            // breaking `template strings`.
-            (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
-             !Input.startswith("\"")) ||
-            (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
-             !Input.startswith("\'")))
-          continue;
-
-        // Change start and end quote.
-        bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
-        SourceLocation Start = FormatTok->Tok.getLocation();
-        auto Replace = [&](SourceLocation Start, unsigned Length,
-                           StringRef ReplacementText) {
-          auto Err = Result.add(tooling::Replacement(
-              Env.getSourceManager(), Start, Length, ReplacementText));
-          // FIXME: handle error. For now, print error message and skip the
-          // replacement for release version.
-          if (Err) {
-            llvm::errs() << llvm::toString(std::move(Err)) << "\n";
-            assert(false);
-          }
-        };
-        Replace(Start, 1, IsSingle ? "'" : "\"");
-        Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
-                IsSingle ? "'" : "\"");
-
-        // Escape internal quotes.
-        bool Escaped = false;
-        for (size_t i = 1; i < Input.size() - 1; i++) {
-          switch (Input[i]) {
-          case '\\':
-            if (!Escaped && i + 1 < Input.size() &&
-                ((IsSingle && Input[i + 1] == '"') ||
-                 (!IsSingle && Input[i + 1] == '\''))) {
-              // Remove this \, it's escaping a " or ' that no longer needs
-              // escaping
-              Replace(Start.getLocWithOffset(i), 1, "");
-              continue;
-            }
-            Escaped = !Escaped;
-            break;
-          case '\"':
-          case '\'':
-            if (!Escaped && IsSingle == (Input[i] == '\'')) {
-              // Escape the quote.
-              Replace(Start.getLocWithOffset(i), 0, "\\");
-            }
-            Escaped = false;
-            break;
-          default:
-            Escaped = false;
-            break;
-          }
-        }
-      }
-    }
-  }
-};
-
-class Formatter : public TokenAnalyzer {
-public:
-  Formatter(const Environment &Env, const FormatStyle &Style,
-            bool *IncompleteFormat)
-      : TokenAnalyzer(Env, Style), IncompleteFormat(IncompleteFormat) {}
-
-  tooling::Replacements
-  analyze(TokenAnnotator &Annotator,
-          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
-          FormatTokenLexer &Tokens) override {
-    tooling::Replacements Result;
-    deriveLocalStyle(AnnotatedLines);
-    AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
-                                          AnnotatedLines.end());
-    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
-      Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
-    }
-    Annotator.setCommentLineLevels(AnnotatedLines);
-
-    WhitespaceManager Whitespaces(
-        Env.getSourceManager(), Style,
-        inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
-    ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
-                                  Env.getSourceManager(), Whitespaces, Encoding,
-                                  BinPackInconclusiveFunctions);
-    UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
-                           IncompleteFormat)
-        .format(AnnotatedLines);
-    for (const auto &R : Whitespaces.generateReplacements())
-      if (Result.add(R))
-        return Result;
-    return Result;
-  }
-
-private:
-
-  static bool inputUsesCRLF(StringRef Text) {
-    return Text.count('\r') * 2 > Text.count('\n');
-  }
-
-  bool
-  hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
-    for (const AnnotatedLine *Line : Lines) {
-      if (hasCpp03IncompatibleFormat(Line->Children))
-        return true;
-      for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
-        if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
-          if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
-            return true;
-          if (Tok->is(TT_TemplateCloser) &&
-              Tok->Previous->is(TT_TemplateCloser))
-            return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
-    int AlignmentDiff = 0;
-    for (const AnnotatedLine *Line : Lines) {
-      AlignmentDiff += countVariableAlignments(Line->Children);
-      for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
-        if (!Tok->is(TT_PointerOrReference))
-          continue;
-        bool SpaceBefore =
-            Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
-        bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
-                          Tok->Next->WhitespaceRange.getEnd();
-        if (SpaceBefore && !SpaceAfter)
-          ++AlignmentDiff;
-        if (!SpaceBefore && SpaceAfter)
-          --AlignmentDiff;
-      }
-    }
-    return AlignmentDiff;
-  }
-
-  void
-  deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
-    bool HasBinPackedFunction = false;
-    bool HasOnePerLineFunction = false;
-    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
-      if (!AnnotatedLines[i]->First->Next)
-        continue;
-      FormatToken *Tok = AnnotatedLines[i]->First->Next;
-      while (Tok->Next) {
-        if (Tok->PackingKind == PPK_BinPacked)
-          HasBinPackedFunction = true;
-        if (Tok->PackingKind == PPK_OnePerLine)
-          HasOnePerLineFunction = true;
-
-        Tok = Tok->Next;
-      }
-    }
-    if (Style.DerivePointerAlignment)
-      Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
-                                   ? FormatStyle::PAS_Left
-                                   : FormatStyle::PAS_Right;
-    if (Style.Standard == FormatStyle::LS_Auto)
-      Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
-                           ? FormatStyle::LS_Cpp11
-                           : FormatStyle::LS_Cpp03;
-    BinPackInconclusiveFunctions =
-        HasBinPackedFunction || !HasOnePerLineFunction;
-  }
-
-  bool BinPackInconclusiveFunctions;
-  bool *IncompleteFormat;
-};
-
-// This class clean up the erroneous/redundant code around the given ranges in
-// file.
-class Cleaner : public TokenAnalyzer {
-public:
-  Cleaner(const Environment &Env, const FormatStyle &Style)
-      : TokenAnalyzer(Env, Style),
-        DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
-
-  // FIXME: eliminate unused parameters.
-  tooling::Replacements
-  analyze(TokenAnnotator &Annotator,
-          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
-          FormatTokenLexer &Tokens) override {
-    // FIXME: in the current implementation the granularity of affected range
-    // is an annotated line. However, this is not sufficient. Furthermore,
-    // redundant code introduced by replacements does not necessarily
-    // intercept with ranges of replacements that result in the redundancy.
-    // To determine if some redundant code is actually introduced by
-    // replacements(e.g. deletions), we need to come up with a more
-    // sophisticated way of computing affected ranges.
-    AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
-                                          AnnotatedLines.end());
-
-    checkEmptyNamespace(AnnotatedLines);
-
-    for (auto &Line : AnnotatedLines) {
-      if (Line->Affected) {
-        cleanupRight(Line->First, tok::comma, tok::comma);
-        cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
-        cleanupRight(Line->First, tok::l_paren, tok::comma);
-        cleanupLeft(Line->First, tok::comma, tok::r_paren);
-        cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
-        cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
-        cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
-      }
-    }
-
-    return generateFixes();
-  }
-
-private:
-  bool containsOnlyComments(const AnnotatedLine &Line) {
-    for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
-      if (Tok->isNot(tok::comment))
-        return false;
-    }
-    return true;
-  }
-
-  // Iterate through all lines and remove any empty (nested) namespaces.
-  void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
-    std::set<unsigned> DeletedLines;
-    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
-      auto &Line = *AnnotatedLines[i];
-      if (Line.startsWith(tok::kw_namespace) ||
-          Line.startsWith(tok::kw_inline, tok::kw_namespace)) {
-        checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
-      }
-    }
-
-    for (auto Line : DeletedLines) {
-      FormatToken *Tok = AnnotatedLines[Line]->First;
-      while (Tok) {
-        deleteToken(Tok);
-        Tok = Tok->Next;
-      }
-    }
-  }
-
-  // The function checks if the namespace, which starts from \p CurrentLine, and
-  // its nested namespaces are empty and delete them if they are empty. It also
-  // sets \p NewLine to the last line checked.
-  // Returns true if the current namespace is empty.
-  bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
-                           unsigned CurrentLine, unsigned &NewLine,
-                           std::set<unsigned> &DeletedLines) {
-    unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
-    if (Style.BraceWrapping.AfterNamespace) {
-      // If the left brace is in a new line, we should consume it first so that
-      // it does not make the namespace non-empty.
-      // FIXME: error handling if there is no left brace.
-      if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
-        NewLine = CurrentLine;
-        return false;
-      }
-    } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
-      return false;
-    }
-    while (++CurrentLine < End) {
-      if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
-        break;
-
-      if (AnnotatedLines[CurrentLine]->startsWith(tok::kw_namespace) ||
-          AnnotatedLines[CurrentLine]->startsWith(tok::kw_inline,
-                                                  tok::kw_namespace)) {
-        if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
-                                 DeletedLines))
-          return false;
-        CurrentLine = NewLine;
-        continue;
-      }
-
-      if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
-        continue;
-
-      // If there is anything other than comments or nested namespaces in the
-      // current namespace, the namespace cannot be empty.
-      NewLine = CurrentLine;
-      return false;
-    }
-
-    NewLine = CurrentLine;
-    if (CurrentLine >= End)
-      return false;
-
-    // Check if the empty namespace is actually affected by changed ranges.
-    if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
-            AnnotatedLines[InitLine]->First->Tok.getLocation(),
-            AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
-      return false;
-
-    for (unsigned i = InitLine; i <= CurrentLine; ++i) {
-      DeletedLines.insert(i);
-    }
-
-    return true;
-  }
-
-  // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
-  // of the token in the pair if the left token has \p LK token kind and the
-  // right token has \p RK token kind. If \p DeleteLeft is true, the left token
-  // is deleted on match; otherwise, the right token is deleted.
-  template <typename LeftKind, typename RightKind>
-  void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
-                   bool DeleteLeft) {
-    auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
-      for (auto *Res = Tok.Next; Res; Res = Res->Next)
-        if (!Res->is(tok::comment) &&
-            DeletedTokens.find(Res) == DeletedTokens.end())
-          return Res;
-      return nullptr;
-    };
-    for (auto *Left = Start; Left;) {
-      auto *Right = NextNotDeleted(*Left);
-      if (!Right)
-        break;
-      if (Left->is(LK) && Right->is(RK)) {
-        deleteToken(DeleteLeft ? Left : Right);
-        for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
-          deleteToken(Tok);
-        // If the right token is deleted, we should keep the left token
-        // unchanged and pair it with the new right token.
-        if (!DeleteLeft)
-          continue;
-      }
-      Left = Right;
-    }
-  }
-
-  template <typename LeftKind, typename RightKind>
-  void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
-    cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
-  }
-
-  template <typename LeftKind, typename RightKind>
-  void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
-    cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
-  }
-
-  // Delete the given token.
-  inline void deleteToken(FormatToken *Tok) {
-    if (Tok)
-      DeletedTokens.insert(Tok);
-  }
-
-  tooling::Replacements generateFixes() {
-    tooling::Replacements Fixes;
-    std::vector<FormatToken *> Tokens;
-    std::copy(DeletedTokens.begin(), DeletedTokens.end(),
-              std::back_inserter(Tokens));
-
-    // Merge multiple continuous token deletions into one big deletion so that
-    // the number of replacements can be reduced. This makes computing affected
-    // ranges more efficient when we run reformat on the changed code.
-    unsigned Idx = 0;
-    while (Idx < Tokens.size()) {
-      unsigned St = Idx, End = Idx;
-      while ((End + 1) < Tokens.size() &&
-             Tokens[End]->Next == Tokens[End + 1]) {
-        End++;
-      }
-      auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
-                                              Tokens[End]->Tok.getEndLoc());
-      auto Err =
-          Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
-      // FIXME: better error handling. for now just print error message and skip
-      // for the release version.
-      if (Err) {
-        llvm::errs() << llvm::toString(std::move(Err)) << "\n";
-        assert(false && "Fixes must not conflict!");
-      }
-      Idx = End + 1;
-    }
-
-    return Fixes;
-  }
-
-  // Class for less-than inequality comparason for the set `RedundantTokens`.
-  // We store tokens in the order they appear in the translation unit so that
-  // we do not need to sort them in `generateFixes()`.
-  struct FormatTokenLess {
-    FormatTokenLess(const SourceManager &SM) : SM(SM) {}
-
-    bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
-      return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
-                                          RHS->Tok.getLocation());
-    }
-    const SourceManager &SM;
-  };
-
-  // Tokens to be deleted.
-  std::set<FormatToken *, FormatTokenLess> DeletedTokens;
-};
-
-struct IncludeDirective {
-  StringRef Filename;
-  StringRef Text;
-  unsigned Offset;
-  int Category;
-};
-
-} // end anonymous namespace
-
-// Determines whether 'Ranges' intersects with ('Start', 'End').
-static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
-                         unsigned End) {
-  for (auto Range : Ranges) {
-    if (Range.getOffset() < End &&
-        Range.getOffset() + Range.getLength() > Start)
-      return true;
-  }
-  return false;
-}
-
-// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
-// before sorting/deduplicating. Index is the index of the include under the
-// cursor in the original set of includes. If this include has duplicates, it is
-// the index of the first of the duplicates as the others are going to be
-// removed. OffsetToEOL describes the cursor's position relative to the end of
-// its current line.
-// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
-static std::pair<unsigned, unsigned>
-FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
-                const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
-  unsigned CursorIndex = UINT_MAX;
-  unsigned OffsetToEOL = 0;
-  for (int i = 0, e = Includes.size(); i != e; ++i) {
-    unsigned Start = Includes[Indices[i]].Offset;
-    unsigned End = Start + Includes[Indices[i]].Text.size();
-    if (!(Cursor >= Start && Cursor < End))
-      continue;
-    CursorIndex = Indices[i];
-    OffsetToEOL = End - Cursor;
-    // Put the cursor on the only remaining #include among the duplicate
-    // #includes.
-    while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
-      CursorIndex = i;
-    break;
-  }
-  return std::make_pair(CursorIndex, OffsetToEOL);
-}
-
-// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
-// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
-// source order.
-// #include directives with the same text will be deduplicated, and only the
-// first #include in the duplicate #includes remains. If the `Cursor` is
-// provided and put on a deleted #include, it will be moved to the remaining
-// #include in the duplicate #includes.
-static void sortCppIncludes(const FormatStyle &Style,
-                            const SmallVectorImpl<IncludeDirective> &Includes,
-                            ArrayRef<tooling::Range> Ranges, StringRef FileName,
-                            tooling::Replacements &Replaces, unsigned *Cursor) {
-  unsigned IncludesBeginOffset = Includes.front().Offset;
-  unsigned IncludesEndOffset =
-      Includes.back().Offset + Includes.back().Text.size();
-  unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
-  if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
-    return;
-  SmallVector<unsigned, 16> Indices;
-  for (unsigned i = 0, e = Includes.size(); i != e; ++i)
-    Indices.push_back(i);
-  std::stable_sort(
-      Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
-        return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
-               std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
-      });
-  // The index of the include on which the cursor will be put after
-  // sorting/deduplicating.
-  unsigned CursorIndex;
-  // The offset from cursor to the end of line.
-  unsigned CursorToEOLOffset;
-  if (Cursor)
-    std::tie(CursorIndex, CursorToEOLOffset) =
-        FindCursorIndex(Includes, Indices, *Cursor);
-
-  // Deduplicate #includes.
-  Indices.erase(std::unique(Indices.begin(), Indices.end(),
-                            [&](unsigned LHSI, unsigned RHSI) {
-                              return Includes[LHSI].Text == Includes[RHSI].Text;
-                            }),
-                Indices.end());
-
-  // If the #includes are out of order, we generate a single replacement fixing
-  // the entire block. Otherwise, no replacement is generated.
-  if (Indices.size() == Includes.size() &&
-      std::is_sorted(Indices.begin(), Indices.end()))
-    return;
-
-  std::string result;
-  for (unsigned Index : Indices) {
-    if (!result.empty())
-      result += "\n";
-    result += Includes[Index].Text;
-    if (Cursor && CursorIndex == Index)
-      *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
-  }
-
-  auto Err = Replaces.add(tooling::Replacement(
-      FileName, Includes.front().Offset, IncludesBlockSize, result));
-  // FIXME: better error handling. For now, just skip the replacement for the
-  // release version.
-  if (Err) {
-    llvm::errs() << llvm::toString(std::move(Err)) << "\n";
-    assert(false);
-  }
-}
-
-namespace {
-
-// This class manages priorities of #include categories and calculates
-// priorities for headers.
-class IncludeCategoryManager {
-public:
-  IncludeCategoryManager(const FormatStyle &Style, StringRef FileName)
-      : Style(Style), FileName(FileName) {
-    FileStem = llvm::sys::path::stem(FileName);
-    for (const auto &Category : Style.IncludeCategories)
-      CategoryRegexs.emplace_back(Category.Regex);
-    IsMainFile = FileName.endswith(".c") || FileName.endswith(".cc") ||
-                 FileName.endswith(".cpp") || FileName.endswith(".c++") ||
-                 FileName.endswith(".cxx") || FileName.endswith(".m") ||
-                 FileName.endswith(".mm");
-  }
-
-  // Returns the priority of the category which \p IncludeName belongs to.
-  // If \p CheckMainHeader is true and \p IncludeName is a main header, returns
-  // 0. Otherwise, returns the priority of the matching category or INT_MAX.
-  int getIncludePriority(StringRef IncludeName, bool CheckMainHeader) {
-    int Ret = INT_MAX;
-    for (unsigned i = 0, e = CategoryRegexs.size(); i != e; ++i)
-      if (CategoryRegexs[i].match(IncludeName)) {
-        Ret = Style.IncludeCategories[i].Priority;
-        break;
-      }
-    if (CheckMainHeader && IsMainFile && Ret > 0 && isMainHeader(IncludeName))
-      Ret = 0;
-    return Ret;
-  }
-
-private:
-  bool isMainHeader(StringRef IncludeName) const {
-    if (!IncludeName.startswith("\""))
-      return false;
-    StringRef HeaderStem =
-        llvm::sys::path::stem(IncludeName.drop_front(1).drop_back(1));
-    if (FileStem.startswith(HeaderStem)) {
-      llvm::Regex MainIncludeRegex(
-          (HeaderStem + Style.IncludeIsMainRegex).str());
-      if (MainIncludeRegex.match(FileStem))
-        return true;
-    }
-    return false;
-  }
-
-  const FormatStyle &Style;
-  bool IsMainFile;
-  StringRef FileName;
-  StringRef FileStem;
-  SmallVector<llvm::Regex, 4> CategoryRegexs;
-};
-
-const char IncludeRegexPattern[] =
-    R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
-
-} // anonymous namespace
-
-tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
-                                      ArrayRef<tooling::Range> Ranges,
-                                      StringRef FileName,
-                                      tooling::Replacements &Replaces,
-                                      unsigned *Cursor) {
-  unsigned Prev = 0;
-  unsigned SearchFrom = 0;
-  llvm::Regex IncludeRegex(IncludeRegexPattern);
-  SmallVector<StringRef, 4> Matches;
-  SmallVector<IncludeDirective, 16> IncludesInBlock;
-
-  // In compiled files, consider the first #include to be the main #include of
-  // the file if it is not a system #include. This ensures that the header
-  // doesn't have hidden dependencies
-  // (http://llvm.org/docs/CodingStandards.html#include-style).
-  //
-  // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
-  // cases where the first #include is unlikely to be the main header.
-  IncludeCategoryManager Categories(Style, FileName);
-  bool FirstIncludeBlock = true;
-  bool MainIncludeFound = false;
-  bool FormattingOff = false;
-
-  for (;;) {
-    auto Pos = Code.find('\n', SearchFrom);
-    StringRef Line =
-        Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
-
-    StringRef Trimmed = Line.trim();
-    if (Trimmed == "// clang-format off")
-      FormattingOff = true;
-    else if (Trimmed == "// clang-format on")
-      FormattingOff = false;
-
-    if (!FormattingOff && !Line.endswith("\\")) {
-      if (IncludeRegex.match(Line, &Matches)) {
-        StringRef IncludeName = Matches[2];
-        int Category = Categories.getIncludePriority(
-            IncludeName,
-            /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
-        if (Category == 0)
-          MainIncludeFound = true;
-        IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
-      } else if (!IncludesInBlock.empty()) {
-        sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
-                        Cursor);
-        IncludesInBlock.clear();
-        FirstIncludeBlock = false;
-      }
-      Prev = Pos + 1;
-    }
-    if (Pos == StringRef::npos || Pos + 1 == Code.size())
-      break;
-    SearchFrom = Pos + 1;
-  }
-  if (!IncludesInBlock.empty())
-    sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
-  return Replaces;
-}
-
-bool isMpegTS(StringRef Code) {
-  // MPEG transport streams use the ".ts" file extension. clang-format should
-  // not attempt to format those. MPEG TS' frame format starts with 0x47 every
-  // 189 bytes - detect that and return.
-  return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
-}
-
-tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
-                                   ArrayRef<tooling::Range> Ranges,
-                                   StringRef FileName, unsigned *Cursor) {
-  tooling::Replacements Replaces;
-  if (!Style.SortIncludes)
-    return Replaces;
-  if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
-      isMpegTS(Code))
-    return Replaces;
-  if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
-    return sortJavaScriptImports(Style, Code, Ranges, FileName);
-  sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
-  return Replaces;
-}
-
-template <typename T>
-static llvm::Expected<tooling::Replacements>
-processReplacements(T ProcessFunc, StringRef Code,
-                    const tooling::Replacements &Replaces,
-                    const FormatStyle &Style) {
-  if (Replaces.empty())
-    return tooling::Replacements();
-
-  auto NewCode = applyAllReplacements(Code, Replaces);
-  if (!NewCode)
-    return NewCode.takeError();
-  std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
-  StringRef FileName = Replaces.begin()->getFilePath();
-
-  tooling::Replacements FormatReplaces =
-      ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
-
-  return Replaces.merge(FormatReplaces);
-}
-
-llvm::Expected<tooling::Replacements>
-formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                   const FormatStyle &Style) {
-  // We need to use lambda function here since there are two versions of
-  // `sortIncludes`.
-  auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
-                         std::vector<tooling::Range> Ranges,
-                         StringRef FileName) -> tooling::Replacements {
-    return sortIncludes(Style, Code, Ranges, FileName);
-  };
-  auto SortedReplaces =
-      processReplacements(SortIncludes, Code, Replaces, Style);
-  if (!SortedReplaces)
-    return SortedReplaces.takeError();
-
-  // We need to use lambda function here since there are two versions of
-  // `reformat`.
-  auto Reformat = [](const FormatStyle &Style, StringRef Code,
-                     std::vector<tooling::Range> Ranges,
-                     StringRef FileName) -> tooling::Replacements {
-    return reformat(Style, Code, Ranges, FileName);
-  };
-  return processReplacements(Reformat, Code, *SortedReplaces, Style);
-}
-
-namespace {
-
-inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
-  return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
-         llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
-}
-
-inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
-  return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
-}
-
-// Returns the offset after skipping a sequence of tokens, matched by \p
-// GetOffsetAfterSequence, from the start of the code.
-// \p GetOffsetAfterSequence should be a function that matches a sequence of
-// tokens and returns an offset after the sequence.
-unsigned getOffsetAfterTokenSequence(
-    StringRef FileName, StringRef Code, const FormatStyle &Style,
-    llvm::function_ref<unsigned(const SourceManager &, Lexer &, Token &)>
-        GetOffsetAfterSequence) {
-  std::unique_ptr<Environment> Env =
-      Environment::CreateVirtualEnvironment(Code, FileName, /*Ranges=*/{});
-  const SourceManager &SourceMgr = Env->getSourceManager();
-  Lexer Lex(Env->getFileID(), SourceMgr.getBuffer(Env->getFileID()), SourceMgr,
-            getFormattingLangOpts(Style));
-  Token Tok;
-  // Get the first token.
-  Lex.LexFromRawLexer(Tok);
-  return GetOffsetAfterSequence(SourceMgr, Lex, Tok);
-}
-
-// Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is,
-// \p Tok will be the token after this directive; otherwise, it can be any token
-// after the given \p Tok (including \p Tok).
-bool checkAndConsumeDirectiveWithName(Lexer &Lex, StringRef Name, Token &Tok) {
-  bool Matched = Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
-                 Tok.is(tok::raw_identifier) &&
-                 Tok.getRawIdentifier() == Name && !Lex.LexFromRawLexer(Tok) &&
-                 Tok.is(tok::raw_identifier);
-  if (Matched)
-    Lex.LexFromRawLexer(Tok);
-  return Matched;
-}
-
-void skipComments(Lexer &Lex, Token &Tok) {
-  while (Tok.is(tok::comment))
-    if (Lex.LexFromRawLexer(Tok))
-      return;
-}
-
-// Returns the offset after header guard directives and any comments
-// before/after header guards. If no header guard presents in the code, this
-// will returns the offset after skipping all comments from the start of the
-// code.
-unsigned getOffsetAfterHeaderGuardsAndComments(StringRef FileName,
-                                               StringRef Code,
-                                               const FormatStyle &Style) {
-  return getOffsetAfterTokenSequence(
-      FileName, Code, Style,
-      [](const SourceManager &SM, Lexer &Lex, Token Tok) {
-        skipComments(Lex, Tok);
-        unsigned InitialOffset = SM.getFileOffset(Tok.getLocation());
-        if (checkAndConsumeDirectiveWithName(Lex, "ifndef", Tok)) {
-          skipComments(Lex, Tok);
-          if (checkAndConsumeDirectiveWithName(Lex, "define", Tok))
-            return SM.getFileOffset(Tok.getLocation());
-        }
-        return InitialOffset;
-      });
-}
-
-// Check if a sequence of tokens is like
-//    "#include ("header.h" | <header.h>)".
-// If it is, \p Tok will be the token after this directive; otherwise, it can be
-// any token after the given \p Tok (including \p Tok).
-bool checkAndConsumeInclusiveDirective(Lexer &Lex, Token &Tok) {
-  auto Matched = [&]() {
-    Lex.LexFromRawLexer(Tok);
-    return true;
-  };
-  if (Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
-      Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "include") {
-    if (Lex.LexFromRawLexer(Tok))
-      return false;
-    if (Tok.is(tok::string_literal))
-      return Matched();
-    if (Tok.is(tok::less)) {
-      while (!Lex.LexFromRawLexer(Tok) && Tok.isNot(tok::greater)) {
-      }
-      if (Tok.is(tok::greater))
-        return Matched();
-    }
-  }
-  return false;
-}
-
-// Returns the offset of the last #include directive after which a new
-// #include can be inserted. This ignores #include's after the #include block(s)
-// in the beginning of a file to avoid inserting headers into code sections
-// where new #include's should not be added by default.
-// These code sections include:
-//      - raw string literals (containing #include).
-//      - #if blocks.
-//      - Special #include's among declarations (e.g. functions).
-//
-// If no #include after which a new #include can be inserted, this returns the
-// offset after skipping all comments from the start of the code.
-// Inserting after an #include is not allowed if it comes after code that is not
-// #include (e.g. pre-processing directive that is not #include, declarations).
-unsigned getMaxHeaderInsertionOffset(StringRef FileName, StringRef Code,
-                                     const FormatStyle &Style) {
-  return getOffsetAfterTokenSequence(
-      FileName, Code, Style,
-      [](const SourceManager &SM, Lexer &Lex, Token Tok) {
-        skipComments(Lex, Tok);
-        unsigned MaxOffset = SM.getFileOffset(Tok.getLocation());
-        while (checkAndConsumeInclusiveDirective(Lex, Tok))
-          MaxOffset = SM.getFileOffset(Tok.getLocation());
-        return MaxOffset;
-      });
-}
-
-bool isDeletedHeader(llvm::StringRef HeaderName,
-                     const std::set<llvm::StringRef> &HeadersToDelete) {
-  return HeadersToDelete.count(HeaderName) ||
-         HeadersToDelete.count(HeaderName.trim("\"<>"));
-}
-
-// FIXME: insert empty lines between newly created blocks.
-tooling::Replacements
-fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
-                        const FormatStyle &Style) {
-  if (!Style.IsCpp())
-    return Replaces;
-
-  tooling::Replacements HeaderInsertions;
-  std::set<llvm::StringRef> HeadersToDelete;
-  tooling::Replacements Result;
-  for (const auto &R : Replaces) {
-    if (isHeaderInsertion(R)) {
-      // Replacements from \p Replaces must be conflict-free already, so we can
-      // simply consume the error.
-      llvm::consumeError(HeaderInsertions.add(R));
-    } else if (isHeaderDeletion(R)) {
-      HeadersToDelete.insert(R.getReplacementText());
-    } else if (R.getOffset() == UINT_MAX) {
-      llvm::errs() << "Insertions other than header #include insertion are "
-                      "not supported! "
-                   << R.getReplacementText() << "\n";
-    } else {
-      llvm::consumeError(Result.add(R));
-    }
-  }
-  if (HeaderInsertions.empty() && HeadersToDelete.empty())
-    return Replaces;
-
-  llvm::Regex IncludeRegex(IncludeRegexPattern);
-  llvm::Regex DefineRegex(R"(^[\t\ ]*#[\t\ ]*define[\t\ ]*[^\\]*$)");
-  SmallVector<StringRef, 4> Matches;
-
-  StringRef FileName = Replaces.begin()->getFilePath();
-  IncludeCategoryManager Categories(Style, FileName);
-
-  // Record the offset of the end of the last include in each category.
-  std::map<int, int> CategoryEndOffsets;
-  // All possible priorities.
-  // Add 0 for main header and INT_MAX for headers that are not in any category.
-  std::set<int> Priorities = {0, INT_MAX};
-  for (const auto &Category : Style.IncludeCategories)
-    Priorities.insert(Category.Priority);
-  int FirstIncludeOffset = -1;
-  // All new headers should be inserted after this offset.
-  unsigned MinInsertOffset =
-      getOffsetAfterHeaderGuardsAndComments(FileName, Code, Style);
-  StringRef TrimmedCode = Code.drop_front(MinInsertOffset);
-  // Max insertion offset in the original code.
-  unsigned MaxInsertOffset =
-      MinInsertOffset +
-      getMaxHeaderInsertionOffset(FileName, TrimmedCode, Style);
-  SmallVector<StringRef, 32> Lines;
-  TrimmedCode.split(Lines, '\n');
-  unsigned Offset = MinInsertOffset;
-  unsigned NextLineOffset;
-  std::set<StringRef> ExistingIncludes;
-  for (auto Line : Lines) {
-    NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
-    if (IncludeRegex.match(Line, &Matches)) {
-      // The header name with quotes or angle brackets.
-      StringRef IncludeName = Matches[2];
-      ExistingIncludes.insert(IncludeName);
-      // Only record the offset of current #include if we can insert after it.
-      if (Offset <= MaxInsertOffset) {
-        int Category = Categories.getIncludePriority(
-            IncludeName, /*CheckMainHeader=*/FirstIncludeOffset < 0);
-        CategoryEndOffsets[Category] = NextLineOffset;
-        if (FirstIncludeOffset < 0)
-          FirstIncludeOffset = Offset;
-      }
-      if (isDeletedHeader(IncludeName, HeadersToDelete)) {
-        // If this is the last line without trailing newline, we need to make
-        // sure we don't delete across the file boundary.
-        unsigned Length = std::min(Line.size() + 1, Code.size() - Offset);
-        llvm::Error Err =
-            Result.add(tooling::Replacement(FileName, Offset, Length, ""));
-        if (Err) {
-          // Ignore the deletion on conflict.
-          llvm::errs() << "Failed to add header deletion replacement for "
-                       << IncludeName << ": " << llvm::toString(std::move(Err))
-                       << "\n";
-        }
-      }
-    }
-    Offset = NextLineOffset;
-  }
-
-  // Populate CategoryEndOfssets:
-  // - Ensure that CategoryEndOffset[Highest] is always populated.
-  // - If CategoryEndOffset[Priority] isn't set, use the next higher value that
-  //   is set, up to CategoryEndOffset[Highest].
-  auto Highest = Priorities.begin();
-  if (CategoryEndOffsets.find(*Highest) == CategoryEndOffsets.end()) {
-    if (FirstIncludeOffset >= 0)
-      CategoryEndOffsets[*Highest] = FirstIncludeOffset;
-    else
-      CategoryEndOffsets[*Highest] = MinInsertOffset;
-  }
-  // By this point, CategoryEndOffset[Highest] is always set appropriately:
-  //  - to an appropriate location before/after existing #includes, or
-  //  - to right after the header guard, or
-  //  - to the beginning of the file.
-  for (auto I = ++Priorities.begin(), E = Priorities.end(); I != E; ++I)
-    if (CategoryEndOffsets.find(*I) == CategoryEndOffsets.end())
-      CategoryEndOffsets[*I] = CategoryEndOffsets[*std::prev(I)];
-
-  bool NeedNewLineAtEnd = !Code.empty() && Code.back() != '\n';
-  for (const auto &R : HeaderInsertions) {
-    auto IncludeDirective = R.getReplacementText();
-    bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
-    assert(Matched && "Header insertion replacement must have replacement text "
-                      "'#include ...'");
-    (void)Matched;
-    auto IncludeName = Matches[2];
-    if (ExistingIncludes.find(IncludeName) != ExistingIncludes.end()) {
-      DEBUG(llvm::dbgs() << "Skip adding existing include : " << IncludeName
-                         << "\n");
-      continue;
-    }
-    int Category =
-        Categories.getIncludePriority(IncludeName, /*CheckMainHeader=*/true);
-    Offset = CategoryEndOffsets[Category];
-    std::string NewInclude = !IncludeDirective.endswith("\n")
-                                 ? (IncludeDirective + "\n").str()
-                                 : IncludeDirective.str();
-    // When inserting headers at end of the code, also append '\n' to the code
-    // if it does not end with '\n'.
-    if (NeedNewLineAtEnd && Offset == Code.size()) {
-      NewInclude = "\n" + NewInclude;
-      NeedNewLineAtEnd = false;
-    }
-    auto NewReplace = tooling::Replacement(FileName, Offset, 0, NewInclude);
-    auto Err = Result.add(NewReplace);
-    if (Err) {
-      llvm::consumeError(std::move(Err));
-      unsigned NewOffset = Result.getShiftedCodePosition(Offset);
-      NewReplace = tooling::Replacement(FileName, NewOffset, 0, NewInclude);
-      Result = Result.merge(tooling::Replacements(NewReplace));
-    }
-  }
-  return Result;
-}
-
-} // anonymous namespace
-
-llvm::Expected<tooling::Replacements>
-cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                          const FormatStyle &Style) {
-  // We need to use lambda function here since there are two versions of
-  // `cleanup`.
-  auto Cleanup = [](const FormatStyle &Style, StringRef Code,
-                    std::vector<tooling::Range> Ranges,
-                    StringRef FileName) -> tooling::Replacements {
-    return cleanup(Style, Code, Ranges, FileName);
-  };
-  // Make header insertion replacements insert new headers into correct blocks.
-  tooling::Replacements NewReplaces =
-      fixCppIncludeInsertions(Code, Replaces, Style);
-  return processReplacements(Cleanup, Code, NewReplaces, Style);
-}
-
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
-                               ArrayRef<tooling::Range> Ranges,
-                               StringRef FileName, bool *IncompleteFormat) {
-  FormatStyle Expanded = expandPresets(Style);
-  if (Expanded.DisableFormat)
-    return tooling::Replacements();
-  if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
-    return tooling::Replacements();
-  auto Env = Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
-
-  auto reformatAfterApplying = [&] (TokenAnalyzer& Fixer) {
-    tooling::Replacements Fixes = Fixer.process();
-    if (!Fixes.empty()) {
-      auto NewCode = applyAllReplacements(Code, Fixes);
-      if (NewCode) {
-        auto NewEnv = Environment::CreateVirtualEnvironment(
-            *NewCode, FileName,
-            tooling::calculateRangesAfterReplacements(Fixes, Ranges));
-        Formatter Format(*NewEnv, Expanded, IncompleteFormat);
-        return Fixes.merge(Format.process());
-      }
-    }
-    Formatter Format(*Env, Expanded, IncompleteFormat);
-    return Format.process();
-  };
-
-  if (Style.Language == FormatStyle::LK_Cpp &&
-      Style.FixNamespaceComments) {
-    NamespaceEndCommentsFixer CommentsFixer(*Env, Expanded);
-    return reformatAfterApplying(CommentsFixer);
-  }
-
-  if (Style.Language == FormatStyle::LK_JavaScript &&
-      Style.JavaScriptQuotes != FormatStyle::JSQS_Leave) {
-    JavaScriptRequoter Requoter(*Env, Expanded);
-    return reformatAfterApplying(Requoter);
-  }
-
-  Formatter Format(*Env, Expanded, IncompleteFormat);
-  return Format.process();
-}
-
-tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
-                              ArrayRef<tooling::Range> Ranges,
-                              StringRef FileName) {
-  std::unique_ptr<Environment> Env =
-      Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
-  Cleaner Clean(*Env, Style);
-  return Clean.process();
-}
-
-tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
-                                              StringRef Code,
-                                              ArrayRef<tooling::Range> Ranges,
-                                              StringRef FileName) {
-  std::unique_ptr<Environment> Env =
-      Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
-  NamespaceEndCommentsFixer Fix(*Env, Style);
-  return Fix.process();
-}
-
-LangOptions getFormattingLangOpts(const FormatStyle &Style) {
-  LangOptions LangOpts;
-  LangOpts.CPlusPlus = 1;
-  LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
-  LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
-  LangOpts.LineComment = 1;
-  bool AlternativeOperators = Style.IsCpp();
-  LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
-  LangOpts.Bool = 1;
-  LangOpts.ObjC1 = 1;
-  LangOpts.ObjC2 = 1;
-  LangOpts.MicrosoftExt = 1;    // To get kw___try, kw___finally.
-  LangOpts.DeclSpecKeyword = 1; // To get __declspec.
-  return LangOpts;
-}
-
-const char *StyleOptionHelpDescription =
-    "Coding style, currently supports:\n"
-    "  LLVM, Google, Chromium, Mozilla, WebKit.\n"
-    "Use -style=file to load style configuration from\n"
-    ".clang-format file located in one of the parent\n"
-    "directories of the source file (or current\n"
-    "directory for stdin).\n"
-    "Use -style=\"{key: value, ...}\" to set specific\n"
-    "parameters, e.g.:\n"
-    "  -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
-
-static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
-  if (FileName.endswith(".java"))
-    return FormatStyle::LK_Java;
-  if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
-    return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
-  if (FileName.endswith(".m") || FileName.endswith(".mm"))
-    return FormatStyle::LK_ObjC;
-  if (FileName.endswith_lower(".proto") ||
-      FileName.endswith_lower(".protodevel"))
-    return FormatStyle::LK_Proto;
-  if (FileName.endswith_lower(".td"))
-    return FormatStyle::LK_TableGen;
-  return FormatStyle::LK_Cpp;
-}
-
-llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
-                                     StringRef FallbackStyleName,
-                                     StringRef Code, vfs::FileSystem *FS) {
-  if (!FS) {
-    FS = vfs::getRealFileSystem().get();
-  }
-  FormatStyle Style = getLLVMStyle();
-  Style.Language = getLanguageByFileName(FileName);
-
-  // This is a very crude detection of whether a header contains ObjC code that
-  // should be improved over time and probably be done on tokens, not one the
-  // bare content of the file.
-  if (Style.Language == FormatStyle::LK_Cpp && FileName.endswith(".h") &&
-      (Code.contains("\n- (") || Code.contains("\n+ (")))
-    Style.Language = FormatStyle::LK_ObjC;
-
-  FormatStyle FallbackStyle = getNoStyle();
-  if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
-    return make_string_error("Invalid fallback style \"" + FallbackStyleName);
-
-  if (StyleName.startswith("{")) {
-    // Parse YAML/JSON style from the command line.
-    if (std::error_code ec = parseConfiguration(StyleName, &Style))
-      return make_string_error("Error parsing -style: " + ec.message());
-    return Style;
-  }
-
-  if (!StyleName.equals_lower("file")) {
-    if (!getPredefinedStyle(StyleName, Style.Language, &Style))
-      return make_string_error("Invalid value for -style");
-    return Style;
-  }
-
-  // Look for .clang-format/_clang-format file in the file's parent directories.
-  SmallString<128> UnsuitableConfigFiles;
-  SmallString<128> Path(FileName);
-  if (std::error_code EC = FS->makeAbsolute(Path))
-    return make_string_error(EC.message());
-
-  for (StringRef Directory = Path; !Directory.empty();
-       Directory = llvm::sys::path::parent_path(Directory)) {
-
-    auto Status = FS->status(Directory);
-    if (!Status ||
-        Status->getType() != llvm::sys::fs::file_type::directory_file) {
-      continue;
-    }
-
-    SmallString<128> ConfigFile(Directory);
-
-    llvm::sys::path::append(ConfigFile, ".clang-format");
-    DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
-
-    Status = FS->status(ConfigFile.str());
-    bool FoundConfigFile =
-        Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
-    if (!FoundConfigFile) {
-      // Try _clang-format too, since dotfiles are not commonly used on Windows.
-      ConfigFile = Directory;
-      llvm::sys::path::append(ConfigFile, "_clang-format");
-      DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
-      Status = FS->status(ConfigFile.str());
-      FoundConfigFile = Status && (Status->getType() ==
-                                   llvm::sys::fs::file_type::regular_file);
-    }
-
-    if (FoundConfigFile) {
-      llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
-          FS->getBufferForFile(ConfigFile.str());
-      if (std::error_code EC = Text.getError())
-        return make_string_error(EC.message());
-      if (std::error_code ec =
-              parseConfiguration(Text.get()->getBuffer(), &Style)) {
-        if (ec == ParseError::Unsuitable) {
-          if (!UnsuitableConfigFiles.empty())
-            UnsuitableConfigFiles.append(", ");
-          UnsuitableConfigFiles.append(ConfigFile);
-          continue;
-        }
-        return make_string_error("Error reading " + ConfigFile + ": " +
-                                 ec.message());
-      }
-      DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
-      return Style;
-    }
-  }
-  if (!UnsuitableConfigFiles.empty())
-    return make_string_error("Configuration file(s) do(es) not support " +
-                             getLanguageName(Style.Language) + ": " +
-                             UnsuitableConfigFiles);
-  return FallbackStyle;
-}
-
-} // namespace format
-} // namespace clang
+//===--- Format.cpp - Format C++ code -------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file implements functions declared in Format.h. This will be
+/// split into separate files as we go.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang/Format/Format.h"
+#include "AffectedRangeManager.h"
+#include "ContinuationIndenter.h"
+#include "FormatTokenLexer.h"
+#include "NamespaceEndCommentsFixer.h"
+#include "SortJavaScriptImports.h"
+#include "TokenAnalyzer.h"
+#include "TokenAnnotator.h"
+#include "UnwrappedLineFormatter.h"
+#include "UnwrappedLineParser.h"
+#include "WhitespaceManager.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/VirtualFileSystem.h"
+#include "clang/Lex/Lexer.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Regex.h"
+#include "llvm/Support/YAMLTraits.h"
+#include <algorithm>
+#include <memory>
+#include <string>
+
+#define DEBUG_TYPE "format-formatter"
+
+using clang::format::FormatStyle;
+
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory)
+
+namespace llvm {
+namespace yaml {
+template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
+  static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
+    IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
+    IO.enumCase(Value, "Java", FormatStyle::LK_Java);
+    IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
+    IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
+    IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
+    IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
+  static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
+    IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
+    IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
+    IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
+    IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
+    IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
+  static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
+    IO.enumCase(Value, "Never", FormatStyle::UT_Never);
+    IO.enumCase(Value, "false", FormatStyle::UT_Never);
+    IO.enumCase(Value, "Always", FormatStyle::UT_Always);
+    IO.enumCase(Value, "true", FormatStyle::UT_Always);
+    IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
+    IO.enumCase(Value, "ForContinuationAndIndentation",
+                FormatStyle::UT_ForContinuationAndIndentation);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> {
+  static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) {
+    IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave);
+    IO.enumCase(Value, "Single", FormatStyle::JSQS_Single);
+    IO.enumCase(Value, "Double", FormatStyle::JSQS_Double);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
+  static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
+    IO.enumCase(Value, "None", FormatStyle::SFS_None);
+    IO.enumCase(Value, "false", FormatStyle::SFS_None);
+    IO.enumCase(Value, "All", FormatStyle::SFS_All);
+    IO.enumCase(Value, "true", FormatStyle::SFS_All);
+    IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
+    IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
+  static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
+    IO.enumCase(Value, "All", FormatStyle::BOS_All);
+    IO.enumCase(Value, "true", FormatStyle::BOS_All);
+    IO.enumCase(Value, "None", FormatStyle::BOS_None);
+    IO.enumCase(Value, "false", FormatStyle::BOS_None);
+    IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
+  static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
+    IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
+    IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
+    IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
+    IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
+    IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
+    IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
+    IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
+    IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
+  static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
+    IO.enumCase(Value, "None", FormatStyle::RTBS_None);
+    IO.enumCase(Value, "All", FormatStyle::RTBS_All);
+    IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
+    IO.enumCase(Value, "TopLevelDefinitions",
+                FormatStyle::RTBS_TopLevelDefinitions);
+    IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
+  static void
+  enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
+    IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
+    IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
+    IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
+
+    // For backward compatibility.
+    IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
+    IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
+  static void enumeration(IO &IO,
+                          FormatStyle::NamespaceIndentationKind &Value) {
+    IO.enumCase(Value, "None", FormatStyle::NI_None);
+    IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
+    IO.enumCase(Value, "All", FormatStyle::NI_All);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::PPDirectiveIndentationKind> {
+  static void enumeration(IO &IO,
+                          FormatStyle::PPDirectiveIndentationKind &Value) {
+    IO.enumCase(Value, "None", FormatStyle::PPDI_None);
+    IO.enumCase(Value, "Inner", FormatStyle::PPDI_Inner);
+    IO.enumCase(Value, "All", FormatStyle::PPDI_All);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::PPDirectiveIndentationStyleKind> {
+  static void enumeration(IO &IO,
+                          FormatStyle::PPDirectiveIndentationStyleKind &Value) {
+    IO.enumCase(Value, "AfterHash", FormatStyle::PPDIS_AfterHash);
+    IO.enumCase(Value, "BeforeHash", FormatStyle::PPDIS_BeforeHash);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
+  static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
+    IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
+    IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
+    IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
+
+    // For backward compatibility.
+    IO.enumCase(Value, "true", FormatStyle::BAS_Align);
+    IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
+  }
+};
+
+template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
+  static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
+    IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
+    IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
+    IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
+
+    // For backward compatibility.
+    IO.enumCase(Value, "true", FormatStyle::PAS_Left);
+    IO.enumCase(Value, "false", FormatStyle::PAS_Right);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
+  static void enumeration(IO &IO,
+                          FormatStyle::SpaceBeforeParensOptions &Value) {
+    IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
+    IO.enumCase(Value, "ControlStatements",
+                FormatStyle::SBPO_ControlStatements);
+    IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
+
+    // For backward compatibility.
+    IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
+    IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
+  }
+};
+
+template <> struct MappingTraits<FormatStyle> {
+  static void mapping(IO &IO, FormatStyle &Style) {
+    // When reading, read the language first, we need it for getPredefinedStyle.
+    IO.mapOptional("Language", Style.Language);
+
+    if (IO.outputting()) {
+      StringRef StylesArray[] = {"LLVM",    "Google", "Chromium",
+                                 "Mozilla", "WebKit", "GNU"};
+      ArrayRef<StringRef> Styles(StylesArray);
+      for (size_t i = 0, e = Styles.size(); i < e; ++i) {
+        StringRef StyleName(Styles[i]);
+        FormatStyle PredefinedStyle;
+        if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
+            Style == PredefinedStyle) {
+          IO.mapOptional("# BasedOnStyle", StyleName);
+          break;
+        }
+      }
+    } else {
+      StringRef BasedOnStyle;
+      IO.mapOptional("BasedOnStyle", BasedOnStyle);
+      if (!BasedOnStyle.empty()) {
+        FormatStyle::LanguageKind OldLanguage = Style.Language;
+        FormatStyle::LanguageKind Language =
+            ((FormatStyle *)IO.getContext())->Language;
+        if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
+          IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
+          return;
+        }
+        Style.Language = OldLanguage;
+      }
+    }
+
+    // For backward compatibility.
+    if (!IO.outputting()) {
+      IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
+      IO.mapOptional("IndentFunctionDeclarationAfterType",
+                     Style.IndentWrappedFunctionNames);
+      IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
+      IO.mapOptional("SpaceAfterControlStatementKeyword",
+                     Style.SpaceBeforeParens);
+    }
+
+    IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
+    IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
+    IO.mapOptional("AlignConsecutiveAssignments",
+                   Style.AlignConsecutiveAssignments);
+    IO.mapOptional("AlignConsecutiveDeclarations",
+                   Style.AlignConsecutiveDeclarations);
+    IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
+    IO.mapOptional("AlignOperands", Style.AlignOperands);
+    IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
+    IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
+                   Style.AllowAllParametersOfDeclarationOnNextLine);
+    IO.mapOptional("AllowShortBlocksOnASingleLine",
+                   Style.AllowShortBlocksOnASingleLine);
+    IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
+                   Style.AllowShortCaseLabelsOnASingleLine);
+    IO.mapOptional("AllowShortFunctionsOnASingleLine",
+                   Style.AllowShortFunctionsOnASingleLine);
+    IO.mapOptional("AllowShortIfStatementsOnASingleLine",
+                   Style.AllowShortIfStatementsOnASingleLine);
+    IO.mapOptional("AllowShortLoopsOnASingleLine",
+                   Style.AllowShortLoopsOnASingleLine);
+    IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
+                   Style.AlwaysBreakAfterDefinitionReturnType);
+    IO.mapOptional("AlwaysBreakAfterReturnType",
+                   Style.AlwaysBreakAfterReturnType);
+    // If AlwaysBreakAfterDefinitionReturnType was specified but
+    // AlwaysBreakAfterReturnType was not, initialize the latter from the
+    // former for backwards compatibility.
+    if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
+        Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
+      if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
+        Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
+      else if (Style.AlwaysBreakAfterDefinitionReturnType ==
+               FormatStyle::DRTBS_TopLevel)
+        Style.AlwaysBreakAfterReturnType =
+            FormatStyle::RTBS_TopLevelDefinitions;
+    }
+
+    IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
+                   Style.AlwaysBreakBeforeMultilineStrings);
+    IO.mapOptional("AlwaysBreakTemplateDeclarations",
+                   Style.AlwaysBreakTemplateDeclarations);
+    IO.mapOptional("BinPackArguments", Style.BinPackArguments);
+    IO.mapOptional("BinPackParameters", Style.BinPackParameters);
+    IO.mapOptional("BraceWrapping", Style.BraceWrapping);
+    IO.mapOptional("BreakBeforeBinaryOperators",
+                   Style.BreakBeforeBinaryOperators);
+    IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
+    IO.mapOptional("BreakBeforeTernaryOperators",
+                   Style.BreakBeforeTernaryOperators);
+    IO.mapOptional("BreakConstructorInitializersBeforeComma",
+                   Style.BreakConstructorInitializersBeforeComma);
+    IO.mapOptional("BreakAfterJavaFieldAnnotations",
+                   Style.BreakAfterJavaFieldAnnotations);
+    IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
+    IO.mapOptional("ColumnLimit", Style.ColumnLimit);
+    IO.mapOptional("CommentPragmas", Style.CommentPragmas);
+    IO.mapOptional("BreakBeforeInheritanceComma",
+                   Style.BreakBeforeInheritanceComma);
+    IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
+                   Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
+    IO.mapOptional("ConstructorInitializerIndentWidth",
+                   Style.ConstructorInitializerIndentWidth);
+    IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
+    IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
+    IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
+    IO.mapOptional("DisableFormat", Style.DisableFormat);
+    IO.mapOptional("ExperimentalAutoDetectBinPacking",
+                   Style.ExperimentalAutoDetectBinPacking);
+    IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
+    IO.mapOptional("ForEachMacros", Style.ForEachMacros);
+    IO.mapOptional("IncludeCategories", Style.IncludeCategories);
+    IO.mapOptional("IncludeIsMainRegex", Style.IncludeIsMainRegex);
+    IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
+    IO.mapOptional("IndentWidth", Style.IndentWidth);
+    IO.mapOptional("IndentWrappedFunctionNames",
+                   Style.IndentWrappedFunctionNames);
+    IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
+    IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
+    IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
+                   Style.KeepEmptyLinesAtTheStartOfBlocks);
+    IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
+    IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
+    IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
+    IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
+    IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
+    IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
+    IO.mapOptional("ObjCSpaceBeforeProtocolList",
+                   Style.ObjCSpaceBeforeProtocolList);
+    IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
+                   Style.PenaltyBreakBeforeFirstCallParameter);
+    IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
+    IO.mapOptional("PenaltyBreakFirstLessLess",
+                   Style.PenaltyBreakFirstLessLess);
+    IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
+    IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
+    IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
+                   Style.PenaltyReturnTypeOnItsOwnLine);
+    IO.mapOptional("PointerAlignment", Style.PointerAlignment);
+    IO.mapOptional("PPDirectiveIndentation", Style.PPDirectiveIndentation);
+    IO.mapOptional("PPDirectiveIndentationStyle",
+                   Style.PPDirectiveIndentationStyle);
+    IO.mapOptional("ReflowComments", Style.ReflowComments);
+    IO.mapOptional("SortIncludes", Style.SortIncludes);
+    IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
+    IO.mapOptional("SpaceAfterTemplateKeyword",
+                   Style.SpaceAfterTemplateKeyword);
+    IO.mapOptional("SpaceBeforeAssignmentOperators",
+                   Style.SpaceBeforeAssignmentOperators);
+    IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
+    IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
+    IO.mapOptional("SpacesBeforeTrailingComments",
+                   Style.SpacesBeforeTrailingComments);
+    IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
+    IO.mapOptional("SpacesInContainerLiterals",
+                   Style.SpacesInContainerLiterals);
+    IO.mapOptional("SpacesInCStyleCastParentheses",
+                   Style.SpacesInCStyleCastParentheses);
+    IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
+    IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
+    IO.mapOptional("Standard", Style.Standard);
+    IO.mapOptional("TabWidth", Style.TabWidth);
+    IO.mapOptional("UseTab", Style.UseTab);
+  }
+};
+
+template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
+  static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
+    IO.mapOptional("AfterClass", Wrapping.AfterClass);
+    IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
+    IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
+    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("IndentBraces", Wrapping.IndentBraces);
+  }
+};
+
+template <> struct MappingTraits<FormatStyle::IncludeCategory> {
+  static void mapping(IO &IO, FormatStyle::IncludeCategory &Category) {
+    IO.mapOptional("Regex", Category.Regex);
+    IO.mapOptional("Priority", Category.Priority);
+  }
+};
+
+// Allows to read vector<FormatStyle> while keeping default values.
+// IO.getContext() should contain a pointer to the FormatStyle structure, that
+// will be used to get default values for missing keys.
+// If the first element has no Language specified, it will be treated as the
+// default one for the following elements.
+template <> struct DocumentListTraits<std::vector<FormatStyle>> {
+  static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
+    return Seq.size();
+  }
+  static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
+                              size_t Index) {
+    if (Index >= Seq.size()) {
+      assert(Index == Seq.size());
+      FormatStyle Template;
+      if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
+        Template = Seq[0];
+      } else {
+        Template = *((const FormatStyle *)IO.getContext());
+        Template.Language = FormatStyle::LK_None;
+      }
+      Seq.resize(Index + 1, Template);
+    }
+    return Seq[Index];
+  }
+};
+} // namespace yaml
+} // namespace llvm
+
+namespace clang {
+namespace format {
+
+const std::error_category &getParseCategory() {
+  static ParseErrorCategory C;
+  return C;
+}
+std::error_code make_error_code(ParseError e) {
+  return std::error_code(static_cast<int>(e), getParseCategory());
+}
+
+inline llvm::Error make_string_error(const llvm::Twine &Message) {
+  return llvm::make_error<llvm::StringError>(Message,
+                                             llvm::inconvertibleErrorCode());
+}
+
+const char *ParseErrorCategory::name() const noexcept {
+  return "clang-format.parse_error";
+}
+
+std::string ParseErrorCategory::message(int EV) const {
+  switch (static_cast<ParseError>(EV)) {
+  case ParseError::Success:
+    return "Success";
+  case ParseError::Error:
+    return "Invalid argument";
+  case ParseError::Unsuitable:
+    return "Unsuitable";
+  }
+  llvm_unreachable("unexpected parse error");
+}
+
+static FormatStyle expandPresets(const FormatStyle &Style) {
+  if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
+    return Style;
+  FormatStyle Expanded = Style;
+  Expanded.BraceWrapping = {false, false, false, false, false, false,
+                            false, false, false, false, false};
+  switch (Style.BreakBeforeBraces) {
+  case FormatStyle::BS_Linux:
+    Expanded.BraceWrapping.AfterClass = true;
+    Expanded.BraceWrapping.AfterFunction = true;
+    Expanded.BraceWrapping.AfterNamespace = true;
+    break;
+  case FormatStyle::BS_Mozilla:
+    Expanded.BraceWrapping.AfterClass = true;
+    Expanded.BraceWrapping.AfterEnum = true;
+    Expanded.BraceWrapping.AfterFunction = true;
+    Expanded.BraceWrapping.AfterStruct = true;
+    Expanded.BraceWrapping.AfterUnion = true;
+    break;
+  case FormatStyle::BS_Stroustrup:
+    Expanded.BraceWrapping.AfterFunction = true;
+    Expanded.BraceWrapping.BeforeCatch = true;
+    Expanded.BraceWrapping.BeforeElse = true;
+    break;
+  case FormatStyle::BS_Allman:
+    Expanded.BraceWrapping.AfterClass = true;
+    Expanded.BraceWrapping.AfterControlStatement = true;
+    Expanded.BraceWrapping.AfterEnum = true;
+    Expanded.BraceWrapping.AfterFunction = true;
+    Expanded.BraceWrapping.AfterNamespace = true;
+    Expanded.BraceWrapping.AfterObjCDeclaration = true;
+    Expanded.BraceWrapping.AfterStruct = true;
+    Expanded.BraceWrapping.BeforeCatch = true;
+    Expanded.BraceWrapping.BeforeElse = true;
+    break;
+  case FormatStyle::BS_GNU:
+    Expanded.BraceWrapping = {true, true, true, true, true, true,
+                              true, true, true, true, true};
+    break;
+  case FormatStyle::BS_WebKit:
+    Expanded.BraceWrapping.AfterFunction = true;
+    break;
+  default:
+    break;
+  }
+  return Expanded;
+}
+
+FormatStyle getLLVMStyle() {
+  FormatStyle LLVMStyle;
+  LLVMStyle.Language = FormatStyle::LK_Cpp;
+  LLVMStyle.AccessModifierOffset = -2;
+  LLVMStyle.AlignEscapedNewlinesLeft = false;
+  LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
+  LLVMStyle.AlignOperands = true;
+  LLVMStyle.AlignTrailingComments = true;
+  LLVMStyle.AlignConsecutiveAssignments = false;
+  LLVMStyle.AlignConsecutiveDeclarations = false;
+  LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
+  LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
+  LLVMStyle.AllowShortBlocksOnASingleLine = false;
+  LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
+  LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
+  LLVMStyle.AllowShortLoopsOnASingleLine = false;
+  LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
+  LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
+  LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
+  LLVMStyle.AlwaysBreakTemplateDeclarations = false;
+  LLVMStyle.BinPackParameters = true;
+  LLVMStyle.BinPackArguments = true;
+  LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
+  LLVMStyle.BreakBeforeTernaryOperators = true;
+  LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
+  LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
+                             false, false, false, false, false};
+  LLVMStyle.BreakAfterJavaFieldAnnotations = false;
+  LLVMStyle.BreakConstructorInitializersBeforeComma = false;
+  LLVMStyle.BreakBeforeInheritanceComma = false;
+  LLVMStyle.BreakStringLiterals = true;
+  LLVMStyle.ColumnLimit = 80;
+  LLVMStyle.CommentPragmas = "^ IWYU pragma:";
+  LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
+  LLVMStyle.ConstructorInitializerIndentWidth = 4;
+  LLVMStyle.ContinuationIndentWidth = 4;
+  LLVMStyle.Cpp11BracedListStyle = true;
+  LLVMStyle.DerivePointerAlignment = false;
+  LLVMStyle.ExperimentalAutoDetectBinPacking = false;
+  LLVMStyle.FixNamespaceComments = true;
+  LLVMStyle.ForEachMacros.push_back("foreach");
+  LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
+  LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
+  LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2},
+                                 {"^(<|\"(gtest|isl|json)/)", 3},
+                                 {".*", 1}};
+  LLVMStyle.IncludeIsMainRegex = "$";
+  LLVMStyle.IndentCaseLabels = false;
+  LLVMStyle.IndentWrappedFunctionNames = false;
+  LLVMStyle.IndentWidth = 2;
+  LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
+  LLVMStyle.JavaScriptWrapImports = true;
+  LLVMStyle.TabWidth = 8;
+  LLVMStyle.MaxEmptyLinesToKeep = 1;
+  LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
+  LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
+  LLVMStyle.ObjCBlockIndentWidth = 2;
+  LLVMStyle.ObjCSpaceAfterProperty = false;
+  LLVMStyle.ObjCSpaceBeforeProtocolList = true;
+  LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
+  LLVMStyle.PPDirectiveIndentation = FormatStyle::PPDI_None;
+  LLVMStyle.PPDirectiveIndentationStyle = FormatStyle::PPDIS_AfterHash;
+  LLVMStyle.SpacesBeforeTrailingComments = 1;
+  LLVMStyle.Standard = FormatStyle::LS_Cpp11;
+  LLVMStyle.UseTab = FormatStyle::UT_Never;
+  LLVMStyle.ReflowComments = true;
+  LLVMStyle.SpacesInParentheses = false;
+  LLVMStyle.SpacesInSquareBrackets = false;
+  LLVMStyle.SpaceInEmptyParentheses = false;
+  LLVMStyle.SpacesInContainerLiterals = true;
+  LLVMStyle.SpacesInCStyleCastParentheses = false;
+  LLVMStyle.SpaceAfterCStyleCast = false;
+  LLVMStyle.SpaceAfterTemplateKeyword = true;
+  LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
+  LLVMStyle.SpaceBeforeAssignmentOperators = true;
+  LLVMStyle.SpacesInAngles = false;
+
+  LLVMStyle.PenaltyBreakComment = 300;
+  LLVMStyle.PenaltyBreakFirstLessLess = 120;
+  LLVMStyle.PenaltyBreakString = 1000;
+  LLVMStyle.PenaltyExcessCharacter = 1000000;
+  LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
+  LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
+
+  LLVMStyle.DisableFormat = false;
+  LLVMStyle.SortIncludes = true;
+
+  return LLVMStyle;
+}
+
+FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
+  FormatStyle GoogleStyle = getLLVMStyle();
+  GoogleStyle.Language = Language;
+
+  GoogleStyle.AccessModifierOffset = -1;
+  GoogleStyle.AlignEscapedNewlinesLeft = true;
+  GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
+  GoogleStyle.AllowShortLoopsOnASingleLine = true;
+  GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
+  GoogleStyle.AlwaysBreakTemplateDeclarations = true;
+  GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+  GoogleStyle.DerivePointerAlignment = true;
+  GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
+  GoogleStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
+  GoogleStyle.IndentCaseLabels = true;
+  GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
+  GoogleStyle.ObjCSpaceAfterProperty = false;
+  GoogleStyle.ObjCSpaceBeforeProtocolList = false;
+  GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
+  GoogleStyle.SpacesBeforeTrailingComments = 2;
+  GoogleStyle.Standard = FormatStyle::LS_Auto;
+
+  GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
+  GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
+
+  if (Language == FormatStyle::LK_Java) {
+    GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+    GoogleStyle.AlignOperands = false;
+    GoogleStyle.AlignTrailingComments = false;
+    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
+    GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
+    GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
+    GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
+    GoogleStyle.ColumnLimit = 100;
+    GoogleStyle.SpaceAfterCStyleCast = true;
+    GoogleStyle.SpacesBeforeTrailingComments = 1;
+  } else if (Language == FormatStyle::LK_JavaScript) {
+    GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+    GoogleStyle.AlignOperands = false;
+    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
+    GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
+    GoogleStyle.BreakBeforeTernaryOperators = false;
+    // taze:, @tag followed by { for a lot of JSDoc tags, and @see, which is
+    // commonly followed by overlong URLs.
+    GoogleStyle.CommentPragmas = "(taze:|(@[A-Za-z_0-9-]+[ \\t]*{)|@see)";
+    GoogleStyle.MaxEmptyLinesToKeep = 3;
+    GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
+    GoogleStyle.SpacesInContainerLiterals = false;
+    GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
+    GoogleStyle.JavaScriptWrapImports = false;
+  } else if (Language == FormatStyle::LK_Proto) {
+    GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
+    GoogleStyle.SpacesInContainerLiterals = false;
+  } else if (Language == FormatStyle::LK_ObjC) {
+    GoogleStyle.ColumnLimit = 100;
+  }
+
+  return GoogleStyle;
+}
+
+FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
+  FormatStyle ChromiumStyle = getGoogleStyle(Language);
+  if (Language == FormatStyle::LK_Java) {
+    ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
+    ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
+    ChromiumStyle.ContinuationIndentWidth = 8;
+    ChromiumStyle.IndentWidth = 4;
+  } else if (Language == FormatStyle::LK_JavaScript) {
+    ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
+    ChromiumStyle.AllowShortLoopsOnASingleLine = false;
+  } else {
+    ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
+    ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
+    ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
+    ChromiumStyle.AllowShortLoopsOnASingleLine = false;
+    ChromiumStyle.BinPackParameters = false;
+    ChromiumStyle.DerivePointerAlignment = false;
+    if (Language == FormatStyle::LK_ObjC)
+      ChromiumStyle.ColumnLimit = 80;
+  }
+  return ChromiumStyle;
+}
+
+FormatStyle getMozillaStyle() {
+  FormatStyle MozillaStyle = getLLVMStyle();
+  MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
+  MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
+  MozillaStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
+  MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
+      FormatStyle::DRTBS_TopLevel;
+  MozillaStyle.AlwaysBreakTemplateDeclarations = true;
+  MozillaStyle.BinPackParameters = false;
+  MozillaStyle.BinPackArguments = false;
+  MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
+  MozillaStyle.BreakConstructorInitializersBeforeComma = true;
+  MozillaStyle.BreakBeforeInheritanceComma = true;
+  MozillaStyle.ConstructorInitializerIndentWidth = 2;
+  MozillaStyle.ContinuationIndentWidth = 2;
+  MozillaStyle.Cpp11BracedListStyle = false;
+  MozillaStyle.FixNamespaceComments = false;
+  MozillaStyle.IndentCaseLabels = true;
+  MozillaStyle.ObjCSpaceAfterProperty = true;
+  MozillaStyle.ObjCSpaceBeforeProtocolList = false;
+  MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
+  MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
+  MozillaStyle.SpaceAfterTemplateKeyword = false;
+  return MozillaStyle;
+}
+
+FormatStyle getWebKitStyle() {
+  FormatStyle Style = getLLVMStyle();
+  Style.AccessModifierOffset = -4;
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  Style.AlignOperands = false;
+  Style.AlignTrailingComments = false;
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
+  Style.BreakConstructorInitializersBeforeComma = true;
+  Style.Cpp11BracedListStyle = false;
+  Style.ColumnLimit = 0;
+  Style.FixNamespaceComments = false;
+  Style.IndentWidth = 4;
+  Style.NamespaceIndentation = FormatStyle::NI_Inner;
+  Style.ObjCBlockIndentWidth = 4;
+  Style.ObjCSpaceAfterProperty = true;
+  Style.PointerAlignment = FormatStyle::PAS_Left;
+  return Style;
+}
+
+FormatStyle getGNUStyle() {
+  FormatStyle Style = getLLVMStyle();
+  Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  Style.BreakBeforeBraces = FormatStyle::BS_GNU;
+  Style.BreakBeforeTernaryOperators = true;
+  Style.Cpp11BracedListStyle = false;
+  Style.ColumnLimit = 79;
+  Style.FixNamespaceComments = false;
+  Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
+  Style.Standard = FormatStyle::LS_Cpp03;
+  return Style;
+}
+
+FormatStyle getNoStyle() {
+  FormatStyle NoStyle = getLLVMStyle();
+  NoStyle.DisableFormat = true;
+  NoStyle.SortIncludes = false;
+  return NoStyle;
+}
+
+bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
+                        FormatStyle *Style) {
+  if (Name.equals_lower("llvm")) {
+    *Style = getLLVMStyle();
+  } else if (Name.equals_lower("chromium")) {
+    *Style = getChromiumStyle(Language);
+  } else if (Name.equals_lower("mozilla")) {
+    *Style = getMozillaStyle();
+  } else if (Name.equals_lower("google")) {
+    *Style = getGoogleStyle(Language);
+  } else if (Name.equals_lower("webkit")) {
+    *Style = getWebKitStyle();
+  } else if (Name.equals_lower("gnu")) {
+    *Style = getGNUStyle();
+  } else if (Name.equals_lower("none")) {
+    *Style = getNoStyle();
+  } else {
+    return false;
+  }
+
+  Style->Language = Language;
+  return true;
+}
+
+std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
+  assert(Style);
+  FormatStyle::LanguageKind Language = Style->Language;
+  assert(Language != FormatStyle::LK_None);
+  if (Text.trim().empty())
+    return make_error_code(ParseError::Error);
+
+  std::vector<FormatStyle> Styles;
+  llvm::yaml::Input Input(Text);
+  // DocumentListTraits<vector<FormatStyle>> uses the context to get default
+  // values for the fields, keys for which are missing from the configuration.
+  // Mapping also uses the context to get the language to find the correct
+  // base style.
+  Input.setContext(Style);
+  Input >> Styles;
+  if (Input.error())
+    return Input.error();
+
+  for (unsigned i = 0; i < Styles.size(); ++i) {
+    // Ensures that only the first configuration can skip the Language option.
+    if (Styles[i].Language == FormatStyle::LK_None && i != 0)
+      return make_error_code(ParseError::Error);
+    // Ensure that each language is configured at most once.
+    for (unsigned j = 0; j < i; ++j) {
+      if (Styles[i].Language == Styles[j].Language) {
+        DEBUG(llvm::dbgs()
+              << "Duplicate languages in the config file on positions " << j
+              << " and " << i << "\n");
+        return make_error_code(ParseError::Error);
+      }
+    }
+  }
+  // Look for a suitable configuration starting from the end, so we can
+  // find the configuration for the specific language first, and the default
+  // configuration (which can only be at slot 0) after it.
+  for (int i = Styles.size() - 1; i >= 0; --i) {
+    if (Styles[i].Language == Language ||
+        Styles[i].Language == FormatStyle::LK_None) {
+      *Style = Styles[i];
+      Style->Language = Language;
+      return make_error_code(ParseError::Success);
+    }
+  }
+  return make_error_code(ParseError::Unsuitable);
+}
+
+std::string configurationAsText(const FormatStyle &Style) {
+  std::string Text;
+  llvm::raw_string_ostream Stream(Text);
+  llvm::yaml::Output Output(Stream);
+  // We use the same mapping method for input and output, so we need a non-const
+  // reference here.
+  FormatStyle NonConstStyle = expandPresets(Style);
+  Output << NonConstStyle;
+  return Stream.str();
+}
+
+namespace {
+
+class JavaScriptRequoter : public TokenAnalyzer {
+public:
+  JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
+      : TokenAnalyzer(Env, Style) {}
+
+  tooling::Replacements
+  analyze(TokenAnnotator &Annotator,
+          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+          FormatTokenLexer &Tokens) override {
+    AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
+                                          AnnotatedLines.end());
+    tooling::Replacements Result;
+    requoteJSStringLiteral(AnnotatedLines, Result);
+    return Result;
+  }
+
+private:
+  // Replaces double/single-quoted string literal as appropriate, re-escaping
+  // the contents in the process.
+  void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
+                              tooling::Replacements &Result) {
+    for (AnnotatedLine *Line : Lines) {
+      requoteJSStringLiteral(Line->Children, Result);
+      if (!Line->Affected)
+        continue;
+      for (FormatToken *FormatTok = Line->First; FormatTok;
+           FormatTok = FormatTok->Next) {
+        StringRef Input = FormatTok->TokenText;
+        if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
+            // NB: testing for not starting with a double quote to avoid
+            // breaking `template strings`.
+            (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
+             !Input.startswith("\"")) ||
+            (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
+             !Input.startswith("\'")))
+          continue;
+
+        // Change start and end quote.
+        bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
+        SourceLocation Start = FormatTok->Tok.getLocation();
+        auto Replace = [&](SourceLocation Start, unsigned Length,
+                           StringRef ReplacementText) {
+          auto Err = Result.add(tooling::Replacement(
+              Env.getSourceManager(), Start, Length, ReplacementText));
+          // FIXME: handle error. For now, print error message and skip the
+          // replacement for release version.
+          if (Err) {
+            llvm::errs() << llvm::toString(std::move(Err)) << "\n";
+            assert(false);
+          }
+        };
+        Replace(Start, 1, IsSingle ? "'" : "\"");
+        Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
+                IsSingle ? "'" : "\"");
+
+        // Escape internal quotes.
+        bool Escaped = false;
+        for (size_t i = 1; i < Input.size() - 1; i++) {
+          switch (Input[i]) {
+          case '\\':
+            if (!Escaped && i + 1 < Input.size() &&
+                ((IsSingle && Input[i + 1] == '"') ||
+                 (!IsSingle && Input[i + 1] == '\''))) {
+              // Remove this \, it's escaping a " or ' that no longer needs
+              // escaping
+              Replace(Start.getLocWithOffset(i), 1, "");
+              continue;
+            }
+            Escaped = !Escaped;
+            break;
+          case '\"':
+          case '\'':
+            if (!Escaped && IsSingle == (Input[i] == '\'')) {
+              // Escape the quote.
+              Replace(Start.getLocWithOffset(i), 0, "\\");
+            }
+            Escaped = false;
+            break;
+          default:
+            Escaped = false;
+            break;
+          }
+        }
+      }
+    }
+  }
+};
+
+class Formatter : public TokenAnalyzer {
+public:
+  Formatter(const Environment &Env, const FormatStyle &Style,
+            bool *IncompleteFormat)
+      : TokenAnalyzer(Env, Style), IncompleteFormat(IncompleteFormat) {}
+
+  tooling::Replacements
+  analyze(TokenAnnotator &Annotator,
+          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+          FormatTokenLexer &Tokens) override {
+    tooling::Replacements Result;
+    deriveLocalStyle(AnnotatedLines);
+    AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
+                                          AnnotatedLines.end());
+    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
+      Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
+    }
+    Annotator.setCommentLineLevels(AnnotatedLines);
+
+    WhitespaceManager Whitespaces(
+        Env.getSourceManager(), Style,
+        inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
+    ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
+                                  Env.getSourceManager(), Whitespaces, Encoding,
+                                  BinPackInconclusiveFunctions);
+    UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
+                           IncompleteFormat)
+        .format(AnnotatedLines);
+    for (const auto &R : Whitespaces.generateReplacements())
+      if (Result.add(R))
+        return Result;
+    return Result;
+  }
+
+private:
+  static bool inputUsesCRLF(StringRef Text) {
+    return Text.count('\r') * 2 > Text.count('\n');
+  }
+
+  bool
+  hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
+    for (const AnnotatedLine *Line : Lines) {
+      if (hasCpp03IncompatibleFormat(Line->Children))
+        return true;
+      for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
+        if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
+          if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
+            return true;
+          if (Tok->is(TT_TemplateCloser) &&
+              Tok->Previous->is(TT_TemplateCloser))
+            return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
+    int AlignmentDiff = 0;
+    for (const AnnotatedLine *Line : Lines) {
+      AlignmentDiff += countVariableAlignments(Line->Children);
+      for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
+        if (!Tok->is(TT_PointerOrReference))
+          continue;
+        bool SpaceBefore =
+            Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
+        bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
+                          Tok->Next->WhitespaceRange.getEnd();
+        if (SpaceBefore && !SpaceAfter)
+          ++AlignmentDiff;
+        if (!SpaceBefore && SpaceAfter)
+          --AlignmentDiff;
+      }
+    }
+    return AlignmentDiff;
+  }
+
+  void
+  deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+    bool HasBinPackedFunction = false;
+    bool HasOnePerLineFunction = false;
+    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
+      if (!AnnotatedLines[i]->First->Next)
+        continue;
+      FormatToken *Tok = AnnotatedLines[i]->First->Next;
+      while (Tok->Next) {
+        if (Tok->PackingKind == PPK_BinPacked)
+          HasBinPackedFunction = true;
+        if (Tok->PackingKind == PPK_OnePerLine)
+          HasOnePerLineFunction = true;
+
+        Tok = Tok->Next;
+      }
+    }
+    if (Style.DerivePointerAlignment)
+      Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
+                                   ? FormatStyle::PAS_Left
+                                   : FormatStyle::PAS_Right;
+    if (Style.Standard == FormatStyle::LS_Auto)
+      Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
+                           ? FormatStyle::LS_Cpp11
+                           : FormatStyle::LS_Cpp03;
+    BinPackInconclusiveFunctions =
+        HasBinPackedFunction || !HasOnePerLineFunction;
+  }
+
+  bool BinPackInconclusiveFunctions;
+  bool *IncompleteFormat;
+};
+
+// This class clean up the erroneous/redundant code around the given ranges in
+// file.
+class Cleaner : public TokenAnalyzer {
+public:
+  Cleaner(const Environment &Env, const FormatStyle &Style)
+      : TokenAnalyzer(Env, Style),
+        DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
+
+  // FIXME: eliminate unused parameters.
+  tooling::Replacements
+  analyze(TokenAnnotator &Annotator,
+          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+          FormatTokenLexer &Tokens) override {
+    // FIXME: in the current implementation the granularity of affected range
+    // is an annotated line. However, this is not sufficient. Furthermore,
+    // redundant code introduced by replacements does not necessarily
+    // intercept with ranges of replacements that result in the redundancy.
+    // To determine if some redundant code is actually introduced by
+    // replacements(e.g. deletions), we need to come up with a more
+    // sophisticated way of computing affected ranges.
+    AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
+                                          AnnotatedLines.end());
+
+    checkEmptyNamespace(AnnotatedLines);
+
+    for (auto &Line : AnnotatedLines) {
+      if (Line->Affected) {
+        cleanupRight(Line->First, tok::comma, tok::comma);
+        cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
+        cleanupRight(Line->First, tok::l_paren, tok::comma);
+        cleanupLeft(Line->First, tok::comma, tok::r_paren);
+        cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
+        cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
+        cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
+      }
+    }
+
+    return generateFixes();
+  }
+
+private:
+  bool containsOnlyComments(const AnnotatedLine &Line) {
+    for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
+      if (Tok->isNot(tok::comment))
+        return false;
+    }
+    return true;
+  }
+
+  // Iterate through all lines and remove any empty (nested) namespaces.
+  void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+    std::set<unsigned> DeletedLines;
+    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
+      auto &Line = *AnnotatedLines[i];
+      if (Line.startsWith(tok::kw_namespace) ||
+          Line.startsWith(tok::kw_inline, tok::kw_namespace)) {
+        checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
+      }
+    }
+
+    for (auto Line : DeletedLines) {
+      FormatToken *Tok = AnnotatedLines[Line]->First;
+      while (Tok) {
+        deleteToken(Tok);
+        Tok = Tok->Next;
+      }
+    }
+  }
+
+  // The function checks if the namespace, which starts from \p CurrentLine, and
+  // its nested namespaces are empty and delete them if they are empty. It also
+  // sets \p NewLine to the last line checked.
+  // Returns true if the current namespace is empty.
+  bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+                           unsigned CurrentLine, unsigned &NewLine,
+                           std::set<unsigned> &DeletedLines) {
+    unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
+    if (Style.BraceWrapping.AfterNamespace) {
+      // If the left brace is in a new line, we should consume it first so that
+      // it does not make the namespace non-empty.
+      // FIXME: error handling if there is no left brace.
+      if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
+        NewLine = CurrentLine;
+        return false;
+      }
+    } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
+      return false;
+    }
+    while (++CurrentLine < End) {
+      if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
+        break;
+
+      if (AnnotatedLines[CurrentLine]->startsWith(tok::kw_namespace) ||
+          AnnotatedLines[CurrentLine]->startsWith(tok::kw_inline,
+                                                  tok::kw_namespace)) {
+        if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
+                                 DeletedLines))
+          return false;
+        CurrentLine = NewLine;
+        continue;
+      }
+
+      if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
+        continue;
+
+      // If there is anything other than comments or nested namespaces in the
+      // current namespace, the namespace cannot be empty.
+      NewLine = CurrentLine;
+      return false;
+    }
+
+    NewLine = CurrentLine;
+    if (CurrentLine >= End)
+      return false;
+
+    // Check if the empty namespace is actually affected by changed ranges.
+    if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
+            AnnotatedLines[InitLine]->First->Tok.getLocation(),
+            AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
+      return false;
+
+    for (unsigned i = InitLine; i <= CurrentLine; ++i) {
+      DeletedLines.insert(i);
+    }
+
+    return true;
+  }
+
+  // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
+  // of the token in the pair if the left token has \p LK token kind and the
+  // right token has \p RK token kind. If \p DeleteLeft is true, the left token
+  // is deleted on match; otherwise, the right token is deleted.
+  template <typename LeftKind, typename RightKind>
+  void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
+                   bool DeleteLeft) {
+    auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
+      for (auto *Res = Tok.Next; Res; Res = Res->Next)
+        if (!Res->is(tok::comment) &&
+            DeletedTokens.find(Res) == DeletedTokens.end())
+          return Res;
+      return nullptr;
+    };
+    for (auto *Left = Start; Left;) {
+      auto *Right = NextNotDeleted(*Left);
+      if (!Right)
+        break;
+      if (Left->is(LK) && Right->is(RK)) {
+        deleteToken(DeleteLeft ? Left : Right);
+        for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
+          deleteToken(Tok);
+        // If the right token is deleted, we should keep the left token
+        // unchanged and pair it with the new right token.
+        if (!DeleteLeft)
+          continue;
+      }
+      Left = Right;
+    }
+  }
+
+  template <typename LeftKind, typename RightKind>
+  void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
+    cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
+  }
+
+  template <typename LeftKind, typename RightKind>
+  void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
+    cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
+  }
+
+  // Delete the given token.
+  inline void deleteToken(FormatToken *Tok) {
+    if (Tok)
+      DeletedTokens.insert(Tok);
+  }
+
+  tooling::Replacements generateFixes() {
+    tooling::Replacements Fixes;
+    std::vector<FormatToken *> Tokens;
+    std::copy(DeletedTokens.begin(), DeletedTokens.end(),
+              std::back_inserter(Tokens));
+
+    // Merge multiple continuous token deletions into one big deletion so that
+    // the number of replacements can be reduced. This makes computing affected
+    // ranges more efficient when we run reformat on the changed code.
+    unsigned Idx = 0;
+    while (Idx < Tokens.size()) {
+      unsigned St = Idx, End = Idx;
+      while ((End + 1) < Tokens.size() &&
+             Tokens[End]->Next == Tokens[End + 1]) {
+        End++;
+      }
+      auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
+                                              Tokens[End]->Tok.getEndLoc());
+      auto Err =
+          Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
+      // FIXME: better error handling. for now just print error message and skip
+      // for the release version.
+      if (Err) {
+        llvm::errs() << llvm::toString(std::move(Err)) << "\n";
+        assert(false && "Fixes must not conflict!");
+      }
+      Idx = End + 1;
+    }
+
+    return Fixes;
+  }
+
+  // Class for less-than inequality comparason for the set `RedundantTokens`.
+  // We store tokens in the order they appear in the translation unit so that
+  // we do not need to sort them in `generateFixes()`.
+  struct FormatTokenLess {
+    FormatTokenLess(const SourceManager &SM) : SM(SM) {}
+
+    bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
+      return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
+                                          RHS->Tok.getLocation());
+    }
+    const SourceManager &SM;
+  };
+
+  // Tokens to be deleted.
+  std::set<FormatToken *, FormatTokenLess> DeletedTokens;
+};
+
+struct IncludeDirective {
+  StringRef Filename;
+  StringRef Text;
+  unsigned Offset;
+  int Category;
+};
+
+enum PPDirectiveType {
+  PPD_UnknownDirective,
+  PPD_Define,
+  PPD_ElIf,
+  PPD_Else,
+  PPD_EndIf,
+  PPD_Error,
+  PPD_If,
+  PPD_IfDef,
+  PPD_IfNDef,
+  PPD_Import,
+  PPD_Include,
+  PPD_Line,
+  PPD_Pragma,
+  PPD_Undef
+};
+
+PPDirectiveType getDirectiveType(StringRef Name) {
+  if (Name == "define") {
+    return PPD_Define;
+  } else if (Name == "elif") {
+    return PPD_ElIf;
+  } else if (Name == "else") {
+    return PPD_Else;
+  } else if (Name == "endif") {
+    return PPD_EndIf;
+  } else if (Name == "error") {
+    return PPD_Error;
+  } else if (Name == "if") {
+    return PPD_If;
+  } else if (Name == "ifdef") {
+    return PPD_IfDef;
+  } else if (Name == "ifndef") {
+    return PPD_IfNDef;
+  } else if (Name == "import") {
+    return PPD_Import;
+  } else if (Name == "include") {
+    return PPD_Include;
+  } else if (Name == "line") {
+    return PPD_Line;
+  } else if (Name == "pragma") {
+    return PPD_Pragma;
+  } else if (Name == "undef") {
+    return PPD_Undef;
+  }
+
+  return PPD_UnknownDirective;
+}
+
+struct PPDirective {
+  PPDirectiveType Type;
+  StringRef Text;
+  unsigned Offset;
+};
+
+} // end anonymous namespace
+
+// Determines whether 'Ranges' intersects with ('Start', 'End').
+static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
+                         unsigned End) {
+  for (auto Range : Ranges) {
+    if (Range.getOffset() < End &&
+        Range.getOffset() + Range.getLength() > Start)
+      return true;
+  }
+  return false;
+}
+
+// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
+// before sorting/deduplicating. Index is the index of the include under the
+// cursor in the original set of includes. If this include has duplicates, it is
+// the index of the first of the duplicates as the others are going to be
+// removed. OffsetToEOL describes the cursor's position relative to the end of
+// its current line.
+// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
+static std::pair<unsigned, unsigned>
+FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
+                const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
+  unsigned CursorIndex = UINT_MAX;
+  unsigned OffsetToEOL = 0;
+  for (int i = 0, e = Includes.size(); i != e; ++i) {
+    unsigned Start = Includes[Indices[i]].Offset;
+    unsigned End = Start + Includes[Indices[i]].Text.size();
+    if (!(Cursor >= Start && Cursor < End))
+      continue;
+    CursorIndex = Indices[i];
+    OffsetToEOL = End - Cursor;
+    // Put the cursor on the only remaining #include among the duplicate
+    // #includes.
+    while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
+      CursorIndex = i;
+    break;
+  }
+  return std::make_pair(CursorIndex, OffsetToEOL);
+}
+
+// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
+// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
+// source order.
+// #include directives with the same text will be deduplicated, and only the
+// first #include in the duplicate #includes remains. If the `Cursor` is
+// provided and put on a deleted #include, it will be moved to the remaining
+// #include in the duplicate #includes.
+static void sortCppIncludes(const FormatStyle &Style,
+                            const SmallVectorImpl<IncludeDirective> &Includes,
+                            ArrayRef<tooling::Range> Ranges, StringRef FileName,
+                            tooling::Replacements &Replaces, unsigned *Cursor) {
+  unsigned IncludesBeginOffset = Includes.front().Offset;
+  unsigned IncludesEndOffset =
+      Includes.back().Offset + Includes.back().Text.size();
+  unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
+  if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
+    return;
+  SmallVector<unsigned, 16> Indices;
+  for (unsigned i = 0, e = Includes.size(); i != e; ++i)
+    Indices.push_back(i);
+  std::stable_sort(
+      Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
+        return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
+               std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
+      });
+  // The index of the include on which the cursor will be put after
+  // sorting/deduplicating.
+  unsigned CursorIndex;
+  // The offset from cursor to the end of line.
+  unsigned CursorToEOLOffset;
+  if (Cursor)
+    std::tie(CursorIndex, CursorToEOLOffset) =
+        FindCursorIndex(Includes, Indices, *Cursor);
+
+  // Deduplicate #includes.
+  Indices.erase(std::unique(Indices.begin(), Indices.end(),
+                            [&](unsigned LHSI, unsigned RHSI) {
+                              return Includes[LHSI].Text == Includes[RHSI].Text;
+                            }),
+                Indices.end());
+
+  // If the #includes are out of order, we generate a single replacement fixing
+  // the entire block. Otherwise, no replacement is generated.
+  if (Indices.size() == Includes.size() &&
+      std::is_sorted(Indices.begin(), Indices.end()))
+    return;
+
+  std::string result;
+  for (unsigned Index : Indices) {
+    if (!result.empty())
+      result += "\n";
+    result += Includes[Index].Text;
+    if (Cursor && CursorIndex == Index)
+      *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
+  }
+
+  auto Err = Replaces.add(tooling::Replacement(
+      FileName, Includes.front().Offset, IncludesBlockSize, result));
+  // FIXME: better error handling. For now, just skip the replacement for the
+  // release version.
+  if (Err) {
+    llvm::errs() << llvm::toString(std::move(Err)) << "\n";
+    assert(false);
+  }
+}
+
+static bool hasIncludeGuards(const SmallVectorImpl<PPDirective> &Directives) {
+  if (Directives.size() < 3)
+    return false;
+
+  StringRef GuardText;
+
+  switch (Directives[0].Type) {
+  case PPD_If:
+    // We accept the forms:
+    // * #if defined(VAR)
+    // * #if defined VAR
+    GuardText = Directives[0].Text.drop_front(sizeof("#if ") - 1);
+    if (!GuardText.startswith("!defined"))
+      return false;
+    GuardText = GuardText.drop_front(sizeof("!defined") - 1);
+
+    if (GuardText.startswith("(")) {
+      if (!GuardText.endswith(")"))
+        return false;
+      GuardText = GuardText.drop_back(1); // Skip trailing ')'.
+    }
+
+    GuardText = GuardText.drop_front(1); // Skip ' ' or '('.
+    break;
+  case PPD_IfNDef:
+    GuardText = Directives[0].Text.drop_front(sizeof("#ifndef ") - 1);
+    break;
+  default:
+    return false;
+  }
+
+  if (Directives[1].Type != PPD_Define)
+    return false;
+  StringRef DefineText = Directives[1].Text.drop_front(sizeof("#define ") - 1);
+  if (DefineText != GuardText)
+    return false;
+
+  if (Directives.back().Type != PPD_EndIf)
+    return false;
+
+  return true;
+}
+
+static bool mayBeIncludeGuard(const SmallVectorImpl<PPDirective> &Directives,
+                              size_t Ordinal) {
+  bool IsLast = (Ordinal + 1 == Directives.size());
+  return ((Ordinal < 2) || IsLast);
+}
+
+static void formatCppDirectives(const FormatStyle &Style,
+                                const SmallVectorImpl<PPDirective> &Directives,
+                                ArrayRef<tooling::Range> Ranges,
+                                StringRef FileName,
+                                tooling::Replacements &Replaces,
+                                unsigned *Cursor) {
+  unsigned PPLevel = 0;
+  unsigned CurrentPPLevel = PPLevel;
+
+  const unsigned ReplacementOffset =
+      (Style.PPDirectiveIndentationStyle == FormatStyle::PPDIS_AfterHash) ? 1
+                                                                          : 0;
+
+  const bool HasIncludeGuards =
+      (Style.PPDirectiveIndentation == FormatStyle::PPDI_Inner) &&
+      hasIncludeGuards(Directives);
+
+  for (size_t i = 0; i < Directives.size(); ++i) {
+    const PPDirective &Directive = Directives[i];
+
+    CurrentPPLevel = PPLevel;
+    bool IncludeGuard = HasIncludeGuards && mayBeIncludeGuard(Directives, i);
+
+    if (!IncludeGuard) {
+      switch (Directive.Type) {
+      case PPD_If:
+      case PPD_IfDef:
+      case PPD_IfNDef:
+        ++PPLevel;
+        break;
+
+      case PPD_ElIf:
+      case PPD_Else:
+        assert(PPLevel > 0);
+        if (PPLevel == 0) {
+          llvm::errs() << "Directive #else/#elif without corresponding #if";
+          break;
+        }
+        CurrentPPLevel = PPLevel - 1;
+        break;
+
+      case PPD_EndIf:
+        assert(PPLevel > 0);
+        if (PPLevel == 0) {
+          llvm::errs() << "Directive #endif without corresponding #if";
+          break;
+        }
+        --PPLevel;
+        CurrentPPLevel = PPLevel;
+        break;
+
+      default:
+        // Do nothing.
+        break;
+      }
+    }
+
+    if (!affectsRange(Ranges, Directive.Offset, Directive.Text.size()))
+      return;
+
+    if (CurrentPPLevel) {
+      // Add spaces to indent directive, count '#' (-1) into indentation.
+      std::string result(CurrentPPLevel * Style.IndentWidth - 1, ' ');
+      // FIXME: +1 is wrong when '#' is not the first character on the line
+      auto Err = Replaces.add(tooling::Replacement(
+          FileName, Directive.Offset + ReplacementOffset, 0, result));
+      // FIXME: better error handling. For now, just skip the replacement for
+      // the release version.
+      if (Err)
+        llvm::errs() << llvm::toString(std::move(Err)) << "\n";
+      assert(!Err);
+    }
+  }
+}
+
+namespace {
+
+// This class manages priorities of #include categories and calculates
+// priorities for headers.
+class IncludeCategoryManager {
+public:
+  IncludeCategoryManager(const FormatStyle &Style, StringRef FileName)
+      : Style(Style), FileName(FileName) {
+    FileStem = llvm::sys::path::stem(FileName);
+    for (const auto &Category : Style.IncludeCategories)
+      CategoryRegexs.emplace_back(Category.Regex);
+    IsMainFile = FileName.endswith(".c") || FileName.endswith(".cc") ||
+                 FileName.endswith(".cpp") || FileName.endswith(".c++") ||
+                 FileName.endswith(".cxx") || FileName.endswith(".m") ||
+                 FileName.endswith(".mm");
+  }
+
+  // Returns the priority of the category which \p IncludeName belongs to.
+  // If \p CheckMainHeader is true and \p IncludeName is a main header, returns
+  // 0. Otherwise, returns the priority of the matching category or INT_MAX.
+  int getIncludePriority(StringRef IncludeName, bool CheckMainHeader) {
+    int Ret = INT_MAX;
+    for (unsigned i = 0, e = CategoryRegexs.size(); i != e; ++i)
+      if (CategoryRegexs[i].match(IncludeName)) {
+        Ret = Style.IncludeCategories[i].Priority;
+        break;
+      }
+    if (CheckMainHeader && IsMainFile && Ret > 0 && isMainHeader(IncludeName))
+      Ret = 0;
+    return Ret;
+  }
+
+private:
+  bool isMainHeader(StringRef IncludeName) const {
+    if (!IncludeName.startswith("\""))
+      return false;
+    StringRef HeaderStem =
+        llvm::sys::path::stem(IncludeName.drop_front(1).drop_back(1));
+    if (FileStem.startswith(HeaderStem)) {
+      llvm::Regex MainIncludeRegex(
+          (HeaderStem + Style.IncludeIsMainRegex).str());
+      if (MainIncludeRegex.match(FileStem))
+        return true;
+    }
+    return false;
+  }
+
+  const FormatStyle &Style;
+  bool IsMainFile;
+  StringRef FileName;
+  StringRef FileStem;
+  SmallVector<llvm::Regex, 4> CategoryRegexs;
+};
+
+const char IncludeRegexPattern[] =
+    R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
+
+const char DirectiveRegexPattern[] =
+    R"(^[\t\ ]*#[\t\ ]*(define|elif|else|endif|error|if|ifdef|ifndef|import|line|include|pragma|undef)(.*))";
+
+} // anonymous namespace
+
+tooling::Replacements
+formatPPDirectives(const FormatStyle &Style, StringRef Code,
+                   ArrayRef<tooling::Range> Ranges, StringRef FileName,
+                   tooling::Replacements &Replaces, unsigned *Cursor) {
+  unsigned Prev = 0;
+  unsigned SearchFrom = 0;
+  llvm::Regex DirectiveRegex(DirectiveRegexPattern);
+  SmallVector<StringRef, 4> Matches;
+  SmallVector<PPDirective, 16> DirectivesInBlock;
+
+  bool FormattingOff = false;
+
+  for (;;) {
+    auto Pos = Code.find('\n', SearchFrom);
+    StringRef Line =
+        Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
+
+    StringRef Trimmed = Line.trim();
+    // FIXME: What about C-style comments? And different whitespace after "//"?
+    if (Trimmed == "// clang-format off")
+      FormattingOff = true;
+    else if (Trimmed == "// clang-format on")
+      FormattingOff = false;
+
+    if (!FormattingOff && !Line.endswith("\\")) {
+      if (DirectiveRegex.match(Line, &Matches)) {
+        StringRef DirectiveName = Matches[1];
+        DirectivesInBlock.push_back(
+            {getDirectiveType(DirectiveName), Line, Prev});
+      }
+      Prev = Pos + 1;
+    }
+    if (Pos == StringRef::npos || Pos + 1 == Code.size())
+      break;
+    SearchFrom = Pos + 1;
+  }
+  if (!DirectivesInBlock.empty()) {
+    formatCppDirectives(Style, DirectivesInBlock, Ranges, FileName, Replaces,
+                        Cursor);
+  }
+  return Replaces;
+}
+
+tooling::Replacements formatPPDirectives(const FormatStyle &Style,
+                                         StringRef Code,
+                                         ArrayRef<tooling::Range> Ranges,
+                                         StringRef FileName, unsigned *Cursor) {
+  tooling::Replacements Replaces;
+  if (Style.PPDirectiveIndentation == FormatStyle::PPDI_None)
+    return Replaces;
+  formatPPDirectives(Style, Code, Ranges, FileName, Replaces, Cursor);
+  return Replaces;
+}
+
+tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
+                                      ArrayRef<tooling::Range> Ranges,
+                                      StringRef FileName,
+                                      tooling::Replacements &Replaces,
+                                      unsigned *Cursor) {
+  unsigned Prev = 0;
+  unsigned SearchFrom = 0;
+  llvm::Regex IncludeRegex(IncludeRegexPattern);
+  SmallVector<StringRef, 4> Matches;
+  SmallVector<IncludeDirective, 16> IncludesInBlock;
+
+  // In compiled files, consider the first #include to be the main #include of
+  // the file if it is not a system #include. This ensures that the header
+  // doesn't have hidden dependencies
+  // (http://llvm.org/docs/CodingStandards.html#include-style).
+  //
+  // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
+  // cases where the first #include is unlikely to be the main header.
+  IncludeCategoryManager Categories(Style, FileName);
+  bool FirstIncludeBlock = true;
+  bool MainIncludeFound = false;
+  bool FormattingOff = false;
+
+  for (;;) {
+    auto Pos = Code.find('\n', SearchFrom);
+    StringRef Line =
+        Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
+
+    StringRef Trimmed = Line.trim();
+    if (Trimmed == "// clang-format off")
+      FormattingOff = true;
+    else if (Trimmed == "// clang-format on")
+      FormattingOff = false;
+
+    if (!FormattingOff && !Line.endswith("\\")) {
+      if (IncludeRegex.match(Line, &Matches)) {
+        StringRef IncludeName = Matches[2];
+        int Category = Categories.getIncludePriority(
+            IncludeName,
+            /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
+        if (Category == 0)
+          MainIncludeFound = true;
+        IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
+      } else if (!IncludesInBlock.empty()) {
+        sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
+                        Cursor);
+        IncludesInBlock.clear();
+        FirstIncludeBlock = false;
+      }
+      Prev = Pos + 1;
+    }
+    if (Pos == StringRef::npos || Pos + 1 == Code.size())
+      break;
+    SearchFrom = Pos + 1;
+  }
+  if (!IncludesInBlock.empty())
+    sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
+  return Replaces;
+}
+
+bool isMpegTS(StringRef Code) {
+  // MPEG transport streams use the ".ts" file extension. clang-format should
+  // not attempt to format those. MPEG TS' frame format starts with 0x47 every
+  // 189 bytes - detect that and return.
+  return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
+}
+
+tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
+                                   ArrayRef<tooling::Range> Ranges,
+                                   StringRef FileName, unsigned *Cursor) {
+  tooling::Replacements Replaces;
+  if (!Style.SortIncludes)
+    return Replaces;
+  if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
+      isMpegTS(Code))
+    return Replaces;
+  if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
+    return sortJavaScriptImports(Style, Code, Ranges, FileName);
+  sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
+  return Replaces;
+}
+
+template <typename T>
+static llvm::Expected<tooling::Replacements>
+processReplacements(T ProcessFunc, StringRef Code,
+                    const tooling::Replacements &Replaces,
+                    const FormatStyle &Style) {
+  if (Replaces.empty())
+    return tooling::Replacements();
+
+  auto NewCode = applyAllReplacements(Code, Replaces);
+  if (!NewCode)
+    return NewCode.takeError();
+  std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
+  StringRef FileName = Replaces.begin()->getFilePath();
+
+  tooling::Replacements FormatReplaces =
+      ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
+
+  return Replaces.merge(FormatReplaces);
+}
+
+llvm::Expected<tooling::Replacements>
+formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
+                   const FormatStyle &Style) {
+  // We need to use lambda function here since there are two versions of
+  // `sortIncludes`.
+  auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
+                         std::vector<tooling::Range> Ranges,
+                         StringRef FileName) -> tooling::Replacements {
+    return sortIncludes(Style, Code, Ranges, FileName);
+  };
+  auto SortedReplaces =
+      processReplacements(SortIncludes, Code, Replaces, Style);
+  if (!SortedReplaces)
+    return SortedReplaces.takeError();
+
+  // We need to use lambda function here since there are two versions of
+  // `reformat`.
+  auto Reformat = [](const FormatStyle &Style, StringRef Code,
+                     std::vector<tooling::Range> Ranges,
+                     StringRef FileName) -> tooling::Replacements {
+    return reformat(Style, Code, Ranges, FileName);
+  };
+  return processReplacements(Reformat, Code, *SortedReplaces, Style);
+
+  // We need to use lambda function here since there are two versions of
+  // `formatPPDirectives`.
+  auto FormatPPDirectives = [](const FormatStyle &Style, StringRef Code,
+                               std::vector<tooling::Range> Ranges,
+                               StringRef FileName) -> tooling::Replacements {
+    return formatPPDirectives(Style, Code, Ranges, FileName);
+  };
+  return processReplacements(FormatPPDirectives, Code, *SortedReplaces, Style);
+}
+
+namespace {
+
+inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
+  return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
+         llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
+}
+
+inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
+  return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
+}
+
+// Returns the offset after skipping a sequence of tokens, matched by \p
+// GetOffsetAfterSequence, from the start of the code.
+// \p GetOffsetAfterSequence should be a function that matches a sequence of
+// tokens and returns an offset after the sequence.
+unsigned getOffsetAfterTokenSequence(
+    StringRef FileName, StringRef Code, const FormatStyle &Style,
+    llvm::function_ref<unsigned(const SourceManager &, Lexer &, Token &)>
+        GetOffsetAfterSequence) {
+  std::unique_ptr<Environment> Env =
+      Environment::CreateVirtualEnvironment(Code, FileName, /*Ranges=*/{});
+  const SourceManager &SourceMgr = Env->getSourceManager();
+  Lexer Lex(Env->getFileID(), SourceMgr.getBuffer(Env->getFileID()), SourceMgr,
+            getFormattingLangOpts(Style));
+  Token Tok;
+  // Get the first token.
+  Lex.LexFromRawLexer(Tok);
+  return GetOffsetAfterSequence(SourceMgr, Lex, Tok);
+}
+
+// Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is,
+// \p Tok will be the token after this directive; otherwise, it can be any token
+// after the given \p Tok (including \p Tok).
+bool checkAndConsumeDirectiveWithName(Lexer &Lex, StringRef Name, Token &Tok) {
+  bool Matched = Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
+                 Tok.is(tok::raw_identifier) &&
+                 Tok.getRawIdentifier() == Name && !Lex.LexFromRawLexer(Tok) &&
+                 Tok.is(tok::raw_identifier);
+  if (Matched)
+    Lex.LexFromRawLexer(Tok);
+  return Matched;
+}
+
+void skipComments(Lexer &Lex, Token &Tok) {
+  while (Tok.is(tok::comment))
+    if (Lex.LexFromRawLexer(Tok))
+      return;
+}
+
+// Returns the offset after header guard directives and any comments
+// before/after header guards. If no header guard presents in the code, this
+// will returns the offset after skipping all comments from the start of the
+// code.
+unsigned getOffsetAfterHeaderGuardsAndComments(StringRef FileName,
+                                               StringRef Code,
+                                               const FormatStyle &Style) {
+  return getOffsetAfterTokenSequence(
+      FileName, Code, Style,
+      [](const SourceManager &SM, Lexer &Lex, Token Tok) {
+        skipComments(Lex, Tok);
+        unsigned InitialOffset = SM.getFileOffset(Tok.getLocation());
+        if (checkAndConsumeDirectiveWithName(Lex, "ifndef", Tok)) {
+          skipComments(Lex, Tok);
+          if (checkAndConsumeDirectiveWithName(Lex, "define", Tok))
+            return SM.getFileOffset(Tok.getLocation());
+        }
+        return InitialOffset;
+      });
+}
+
+// Check if a sequence of tokens is like
+//    "#include ("header.h" | <header.h>)".
+// If it is, \p Tok will be the token after this directive; otherwise, it can be
+// any token after the given \p Tok (including \p Tok).
+bool checkAndConsumeInclusiveDirective(Lexer &Lex, Token &Tok) {
+  auto Matched = [&]() {
+    Lex.LexFromRawLexer(Tok);
+    return true;
+  };
+  if (Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
+      Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "include") {
+    if (Lex.LexFromRawLexer(Tok))
+      return false;
+    if (Tok.is(tok::string_literal))
+      return Matched();
+    if (Tok.is(tok::less)) {
+      while (!Lex.LexFromRawLexer(Tok) && Tok.isNot(tok::greater)) {
+      }
+      if (Tok.is(tok::greater))
+        return Matched();
+    }
+  }
+  return false;
+}
+
+// Returns the offset of the last #include directive after which a new
+// #include can be inserted. This ignores #include's after the #include block(s)
+// in the beginning of a file to avoid inserting headers into code sections
+// where new #include's should not be added by default.
+// These code sections include:
+//      - raw string literals (containing #include).
+//      - #if blocks.
+//      - Special #include's among declarations (e.g. functions).
+//
+// If no #include after which a new #include can be inserted, this returns the
+// offset after skipping all comments from the start of the code.
+// Inserting after an #include is not allowed if it comes after code that is not
+// #include (e.g. pre-processing directive that is not #include, declarations).
+unsigned getMaxHeaderInsertionOffset(StringRef FileName, StringRef Code,
+                                     const FormatStyle &Style) {
+  return getOffsetAfterTokenSequence(
+      FileName, Code, Style,
+      [](const SourceManager &SM, Lexer &Lex, Token Tok) {
+        skipComments(Lex, Tok);
+        unsigned MaxOffset = SM.getFileOffset(Tok.getLocation());
+        while (checkAndConsumeInclusiveDirective(Lex, Tok))
+          MaxOffset = SM.getFileOffset(Tok.getLocation());
+        return MaxOffset;
+      });
+}
+
+bool isDeletedHeader(llvm::StringRef HeaderName,
+                     const std::set<llvm::StringRef> &HeadersToDelete) {
+  return HeadersToDelete.count(HeaderName) ||
+         HeadersToDelete.count(HeaderName.trim("\"<>"));
+}
+
+// FIXME: insert empty lines between newly created blocks.
+tooling::Replacements
+fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
+                        const FormatStyle &Style) {
+  if (!Style.IsCpp())
+    return Replaces;
+
+  tooling::Replacements HeaderInsertions;
+  std::set<llvm::StringRef> HeadersToDelete;
+  tooling::Replacements Result;
+  for (const auto &R : Replaces) {
+    if (isHeaderInsertion(R)) {
+      // Replacements from \p Replaces must be conflict-free already, so we can
+      // simply consume the error.
+      llvm::consumeError(HeaderInsertions.add(R));
+    } else if (isHeaderDeletion(R)) {
+      HeadersToDelete.insert(R.getReplacementText());
+    } else if (R.getOffset() == UINT_MAX) {
+      llvm::errs() << "Insertions other than header #include insertion are "
+                      "not supported! "
+                   << R.getReplacementText() << "\n";
+    } else {
+      llvm::consumeError(Result.add(R));
+    }
+  }
+  if (HeaderInsertions.empty() && HeadersToDelete.empty())
+    return Replaces;
+
+  llvm::Regex IncludeRegex(IncludeRegexPattern);
+  llvm::Regex DefineRegex(R"(^[\t\ ]*#[\t\ ]*define[\t\ ]*[^\\]*$)");
+  SmallVector<StringRef, 4> Matches;
+
+  StringRef FileName = Replaces.begin()->getFilePath();
+  IncludeCategoryManager Categories(Style, FileName);
+
+  // Record the offset of the end of the last include in each category.
+  std::map<int, int> CategoryEndOffsets;
+  // All possible priorities.
+  // Add 0 for main header and INT_MAX for headers that are not in any category.
+  std::set<int> Priorities = {0, INT_MAX};
+  for (const auto &Category : Style.IncludeCategories)
+    Priorities.insert(Category.Priority);
+  int FirstIncludeOffset = -1;
+  // All new headers should be inserted after this offset.
+  unsigned MinInsertOffset =
+      getOffsetAfterHeaderGuardsAndComments(FileName, Code, Style);
+  StringRef TrimmedCode = Code.drop_front(MinInsertOffset);
+  // Max insertion offset in the original code.
+  unsigned MaxInsertOffset =
+      MinInsertOffset +
+      getMaxHeaderInsertionOffset(FileName, TrimmedCode, Style);
+  SmallVector<StringRef, 32> Lines;
+  TrimmedCode.split(Lines, '\n');
+  unsigned Offset = MinInsertOffset;
+  unsigned NextLineOffset;
+  std::set<StringRef> ExistingIncludes;
+  for (auto Line : Lines) {
+    NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
+    if (IncludeRegex.match(Line, &Matches)) {
+      // The header name with quotes or angle brackets.
+      StringRef IncludeName = Matches[2];
+      ExistingIncludes.insert(IncludeName);
+      // Only record the offset of current #include if we can insert after it.
+      if (Offset <= MaxInsertOffset) {
+        int Category = Categories.getIncludePriority(
+            IncludeName, /*CheckMainHeader=*/FirstIncludeOffset < 0);
+        CategoryEndOffsets[Category] = NextLineOffset;
+        if (FirstIncludeOffset < 0)
+          FirstIncludeOffset = Offset;
+      }
+      if (isDeletedHeader(IncludeName, HeadersToDelete)) {
+        // If this is the last line without trailing newline, we need to make
+        // sure we don't delete across the file boundary.
+        unsigned Length = std::min(Line.size() + 1, Code.size() - Offset);
+        llvm::Error Err =
+            Result.add(tooling::Replacement(FileName, Offset, Length, ""));
+        if (Err) {
+          // Ignore the deletion on conflict.
+          llvm::errs() << "Failed to add header deletion replacement for "
+                       << IncludeName << ": " << llvm::toString(std::move(Err))
+                       << "\n";
+        }
+      }
+    }
+    Offset = NextLineOffset;
+  }
+
+  // Populate CategoryEndOfssets:
+  // - Ensure that CategoryEndOffset[Highest] is always populated.
+  // - If CategoryEndOffset[Priority] isn't set, use the next higher value that
+  //   is set, up to CategoryEndOffset[Highest].
+  auto Highest = Priorities.begin();
+  if (CategoryEndOffsets.find(*Highest) == CategoryEndOffsets.end()) {
+    if (FirstIncludeOffset >= 0)
+      CategoryEndOffsets[*Highest] = FirstIncludeOffset;
+    else
+      CategoryEndOffsets[*Highest] = MinInsertOffset;
+  }
+  // By this point, CategoryEndOffset[Highest] is always set appropriately:
+  //  - to an appropriate location before/after existing #includes, or
+  //  - to right after the header guard, or
+  //  - to the beginning of the file.
+  for (auto I = ++Priorities.begin(), E = Priorities.end(); I != E; ++I)
+    if (CategoryEndOffsets.find(*I) == CategoryEndOffsets.end())
+      CategoryEndOffsets[*I] = CategoryEndOffsets[*std::prev(I)];
+
+  bool NeedNewLineAtEnd = !Code.empty() && Code.back() != '\n';
+  for (const auto &R : HeaderInsertions) {
+    auto IncludeDirective = R.getReplacementText();
+    bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
+    assert(Matched && "Header insertion replacement must have replacement text "
+                      "'#include ...'");
+    (void)Matched;
+    auto IncludeName = Matches[2];
+    if (ExistingIncludes.find(IncludeName) != ExistingIncludes.end()) {
+      DEBUG(llvm::dbgs() << "Skip adding existing include : " << IncludeName
+                         << "\n");
+      continue;
+    }
+    int Category =
+        Categories.getIncludePriority(IncludeName, /*CheckMainHeader=*/true);
+    Offset = CategoryEndOffsets[Category];
+    std::string NewInclude = !IncludeDirective.endswith("\n")
+                                 ? (IncludeDirective + "\n").str()
+                                 : IncludeDirective.str();
+    // When inserting headers at end of the code, also append '\n' to the code
+    // if it does not end with '\n'.
+    if (NeedNewLineAtEnd && Offset == Code.size()) {
+      NewInclude = "\n" + NewInclude;
+      NeedNewLineAtEnd = false;
+    }
+    auto NewReplace = tooling::Replacement(FileName, Offset, 0, NewInclude);
+    auto Err = Result.add(NewReplace);
+    if (Err) {
+      llvm::consumeError(std::move(Err));
+      unsigned NewOffset = Result.getShiftedCodePosition(Offset);
+      NewReplace = tooling::Replacement(FileName, NewOffset, 0, NewInclude);
+      Result = Result.merge(tooling::Replacements(NewReplace));
+    }
+  }
+  return Result;
+}
+
+} // anonymous namespace
+
+llvm::Expected<tooling::Replacements>
+cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
+                          const FormatStyle &Style) {
+  // We need to use lambda function here since there are two versions of
+  // `cleanup`.
+  auto Cleanup = [](const FormatStyle &Style, StringRef Code,
+                    std::vector<tooling::Range> Ranges,
+                    StringRef FileName) -> tooling::Replacements {
+    return cleanup(Style, Code, Ranges, FileName);
+  };
+  // Make header insertion replacements insert new headers into correct blocks.
+  tooling::Replacements NewReplaces =
+      fixCppIncludeInsertions(Code, Replaces, Style);
+  return processReplacements(Cleanup, Code, NewReplaces, Style);
+}
+
+tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+                               ArrayRef<tooling::Range> Ranges,
+                               StringRef FileName, bool *IncompleteFormat) {
+  FormatStyle Expanded = expandPresets(Style);
+  if (Expanded.DisableFormat)
+    return tooling::Replacements();
+  if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
+    return tooling::Replacements();
+  auto Env = Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
+
+  auto reformatAfterApplying = [&](TokenAnalyzer &Fixer) {
+    tooling::Replacements Fixes = Fixer.process();
+    if (!Fixes.empty()) {
+      auto NewCode = applyAllReplacements(Code, Fixes);
+      if (NewCode) {
+        auto NewEnv = Environment::CreateVirtualEnvironment(
+            *NewCode, FileName,
+            tooling::calculateRangesAfterReplacements(Fixes, Ranges));
+        Formatter Format(*NewEnv, Expanded, IncompleteFormat);
+        return Fixes.merge(Format.process());
+      }
+    }
+    Formatter Format(*Env, Expanded, IncompleteFormat);
+    return Format.process();
+  };
+
+  if (Style.Language == FormatStyle::LK_Cpp && Style.FixNamespaceComments) {
+    NamespaceEndCommentsFixer CommentsFixer(*Env, Expanded);
+    return reformatAfterApplying(CommentsFixer);
+  }
+
+  if (Style.Language == FormatStyle::LK_JavaScript &&
+      Style.JavaScriptQuotes != FormatStyle::JSQS_Leave) {
+    JavaScriptRequoter Requoter(*Env, Expanded);
+    return reformatAfterApplying(Requoter);
+  }
+
+  Formatter Format(*Env, Expanded, IncompleteFormat);
+  return Format.process();
+}
+
+tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
+                              ArrayRef<tooling::Range> Ranges,
+                              StringRef FileName) {
+  std::unique_ptr<Environment> Env =
+      Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
+  Cleaner Clean(*Env, Style);
+  return Clean.process();
+}
+
+tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
+                                              StringRef Code,
+                                              ArrayRef<tooling::Range> Ranges,
+                                              StringRef FileName) {
+  std::unique_ptr<Environment> Env =
+      Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
+  NamespaceEndCommentsFixer Fix(*Env, Style);
+  return Fix.process();
+}
+
+LangOptions getFormattingLangOpts(const FormatStyle &Style) {
+  LangOptions LangOpts;
+  LangOpts.CPlusPlus = 1;
+  LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
+  LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
+  LangOpts.LineComment = 1;
+  bool AlternativeOperators = Style.IsCpp();
+  LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
+  LangOpts.Bool = 1;
+  LangOpts.ObjC1 = 1;
+  LangOpts.ObjC2 = 1;
+  LangOpts.MicrosoftExt = 1;    // To get kw___try, kw___finally.
+  LangOpts.DeclSpecKeyword = 1; // To get __declspec.
+  return LangOpts;
+}
+
+const char *StyleOptionHelpDescription =
+    "Coding style, currently supports:\n"
+    "  LLVM, Google, Chromium, Mozilla, WebKit.\n"
+    "Use -style=file to load style configuration from\n"
+    ".clang-format file located in one of the parent\n"
+    "directories of the source file (or current\n"
+    "directory for stdin).\n"
+    "Use -style=\"{key: value, ...}\" to set specific\n"
+    "parameters, e.g.:\n"
+    "  -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
+
+static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
+  if (FileName.endswith(".java"))
+    return FormatStyle::LK_Java;
+  if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
+    return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
+  if (FileName.endswith(".m") || FileName.endswith(".mm"))
+    return FormatStyle::LK_ObjC;
+  if (FileName.endswith_lower(".proto") ||
+      FileName.endswith_lower(".protodevel"))
+    return FormatStyle::LK_Proto;
+  if (FileName.endswith_lower(".td"))
+    return FormatStyle::LK_TableGen;
+  return FormatStyle::LK_Cpp;
+}
+
+llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
+                                     StringRef FallbackStyleName,
+                                     StringRef Code, vfs::FileSystem *FS) {
+  if (!FS) {
+    FS = vfs::getRealFileSystem().get();
+  }
+  FormatStyle Style = getLLVMStyle();
+  Style.Language = getLanguageByFileName(FileName);
+
+  // This is a very crude detection of whether a header contains ObjC code that
+  // should be improved over time and probably be done on tokens, not one the
+  // bare content of the file.
+  if (Style.Language == FormatStyle::LK_Cpp && FileName.endswith(".h") &&
+      (Code.contains("\n- (") || Code.contains("\n+ (")))
+    Style.Language = FormatStyle::LK_ObjC;
+
+  FormatStyle FallbackStyle = getNoStyle();
+  if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
+    return make_string_error("Invalid fallback style \"" + FallbackStyleName);
+
+  if (StyleName.startswith("{")) {
+    // Parse YAML/JSON style from the command line.
+    if (std::error_code ec = parseConfiguration(StyleName, &Style))
+      return make_string_error("Error parsing -style: " + ec.message());
+    return Style;
+  }
+
+  if (!StyleName.equals_lower("file")) {
+    if (!getPredefinedStyle(StyleName, Style.Language, &Style))
+      return make_string_error("Invalid value for -style");
+    return Style;
+  }
+
+  // Look for .clang-format/_clang-format file in the file's parent directories.
+  SmallString<128> UnsuitableConfigFiles;
+  SmallString<128> Path(FileName);
+  if (std::error_code EC = FS->makeAbsolute(Path))
+    return make_string_error(EC.message());
+
+  for (StringRef Directory = Path; !Directory.empty();
+       Directory = llvm::sys::path::parent_path(Directory)) {
+
+    auto Status = FS->status(Directory);
+    if (!Status ||
+        Status->getType() != llvm::sys::fs::file_type::directory_file) {
+      continue;
+    }
+
+    SmallString<128> ConfigFile(Directory);
+
+    llvm::sys::path::append(ConfigFile, ".clang-format");
+    DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
+
+    Status = FS->status(ConfigFile.str());
+    bool FoundConfigFile =
+        Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
+    if (!FoundConfigFile) {
+      // Try _clang-format too, since dotfiles are not commonly used on Windows.
+      ConfigFile = Directory;
+      llvm::sys::path::append(ConfigFile, "_clang-format");
+      DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
+      Status = FS->status(ConfigFile.str());
+      FoundConfigFile = Status && (Status->getType() ==
+                                   llvm::sys::fs::file_type::regular_file);
+    }
+
+    if (FoundConfigFile) {
+      llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
+          FS->getBufferForFile(ConfigFile.str());
+      if (std::error_code EC = Text.getError())
+        return make_string_error(EC.message());
+      if (std::error_code ec =
+              parseConfiguration(Text.get()->getBuffer(), &Style)) {
+        if (ec == ParseError::Unsuitable) {
+          if (!UnsuitableConfigFiles.empty())
+            UnsuitableConfigFiles.append(", ");
+          UnsuitableConfigFiles.append(ConfigFile);
+          continue;
+        }
+        return make_string_error("Error reading " + ConfigFile + ": " +
+                                 ec.message());
+      }
+      DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
+      return Style;
+    }
+  }
+  if (!UnsuitableConfigFiles.empty())
+    return make_string_error("Configuration file(s) do(es) not support " +
+                             getLanguageName(Style.Language) + ": " +
+                             UnsuitableConfigFiles);
+  return FallbackStyle;
+}
+
+} // namespace format
+} // namespace clang

tools/clang-format/ClangFormat.cpp

-//===-- clang-format/ClangFormat.cpp - Clang format tool ------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file implements a clang-format tool that automatically formats
-/// (fragments of) C++ code.
-///
-//===----------------------------------------------------------------------===//
-
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Basic/Version.h"
-#include "clang/Format/Format.h"
-#include "clang/Rewrite/Core/Rewriter.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Signals.h"
-
-using namespace llvm;
-using clang::tooling::Replacements;
-
-static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
-
-// Mark all our options with this category, everything else (except for -version
-// and -help) will be hidden.
-static cl::OptionCategory ClangFormatCategory("Clang-format options");
-
-static cl::list<unsigned>
-    Offsets("offset",
-            cl::desc("Format a range starting at this byte offset.\n"
-                     "Multiple ranges can be formatted by specifying\n"
-                     "several -offset and -length pairs.\n"
-                     "Can only be used with one input file."),
-            cl::cat(ClangFormatCategory));
-static cl::list<unsigned>
-    Lengths("length",
-            cl::desc("Format a range of this length (in bytes).\n"
-                     "Multiple ranges can be formatted by specifying\n"
-                     "several -offset and -length pairs.\n"
-                     "When only a single -offset is specified without\n"
-                     "-length, clang-format will format up to the end\n"
-                     "of the file.\n"
-                     "Can only be used with one input file."),
-            cl::cat(ClangFormatCategory));
-static cl::list<std::string>
-LineRanges("lines", cl::desc("<start line>:<end line> - format a range of\n"
-                             "lines (both 1-based).\n"
-                             "Multiple ranges can be formatted by specifying\n"
-                             "several -lines arguments.\n"
-                             "Can't be used with -offset and -length.\n"
-                             "Can only be used with one input file."),
-           cl::cat(ClangFormatCategory));
-static cl::opt<std::string>
-    Style("style",
-          cl::desc(clang::format::StyleOptionHelpDescription),
-          cl::init("file"), cl::cat(ClangFormatCategory));
-static cl::opt<std::string>
-FallbackStyle("fallback-style",
-              cl::desc("The name of the predefined style used as a\n"
-                       "fallback in case clang-format is invoked with\n"
-                       "-style=file, but can not find the .clang-format\n"
-                       "file to use.\n"
-                       "Use -fallback-style=none to skip formatting."),
-              cl::init("LLVM"), cl::cat(ClangFormatCategory));
-
-static cl::opt<std::string>
-AssumeFileName("assume-filename",
-               cl::desc("When reading from stdin, clang-format assumes this\n"
-                        "filename to look for a style config file (with\n"
-                        "-style=file) and to determine the language."),
-               cl::init("<stdin>"), cl::cat(ClangFormatCategory));
-
-static cl::opt<bool> Inplace("i",
-                             cl::desc("Inplace edit <file>s, if specified."),
-                             cl::cat(ClangFormatCategory));
-
-static cl::opt<bool> OutputXML("output-replacements-xml",
-                               cl::desc("Output replacements as XML."),
-                               cl::cat(ClangFormatCategory));
-static cl::opt<bool>
-    DumpConfig("dump-config",
-               cl::desc("Dump configuration options to stdout and exit.\n"
-                        "Can be used with -style option."),
-               cl::cat(ClangFormatCategory));
-static cl::opt<unsigned>
-    Cursor("cursor",
-           cl::desc("The position of the cursor when invoking\n"
-                    "clang-format from an editor integration"),
-           cl::init(0), cl::cat(ClangFormatCategory));
-
-static cl::opt<bool> SortIncludes(
-    "sort-includes",
-    cl::desc("If set, overrides the include sorting behavior determined by the "
-             "SortIncludes style flag"),
-    cl::cat(ClangFormatCategory));
-
-static cl::list<std::string> FileNames(cl::Positional, cl::desc("[<file> ...]"),
-                                       cl::cat(ClangFormatCategory));
-
-namespace clang {
-namespace format {
-
-static FileID createInMemoryFile(StringRef FileName, MemoryBuffer *Source,
-                                 SourceManager &Sources, FileManager &Files,
-                                 vfs::InMemoryFileSystem *MemFS) {
-  MemFS->addFileNoOwn(FileName, 0, Source);
-  return Sources.createFileID(Files.getFile(FileName), SourceLocation(),
-                              SrcMgr::C_User);
-}
-
-// Parses <start line>:<end line> input to a pair of line numbers.
-// Returns true on error.
-static bool parseLineRange(StringRef Input, unsigned &FromLine,
-                           unsigned &ToLine) {
-  std::pair<StringRef, StringRef> LineRange = Input.split(':');
-  return LineRange.first.getAsInteger(0, FromLine) ||
-         LineRange.second.getAsInteger(0, ToLine);
-}
-
-static bool fillRanges(MemoryBuffer *Code,
-                       std::vector<tooling::Range> &Ranges) {
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
-      new vfs::InMemoryFileSystem);
-  FileManager Files(FileSystemOptions(), InMemoryFileSystem);
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-      new DiagnosticOptions);
-  SourceManager Sources(Diagnostics, Files);
-  FileID ID = createInMemoryFile("<irrelevant>", Code, Sources, Files,
-                                 InMemoryFileSystem.get());
-  if (!LineRanges.empty()) {
-    if (!Offsets.empty() || !Lengths.empty()) {
-      errs() << "error: cannot use -lines with -offset/-length\n";
-      return true;
-    }
-
-    for (unsigned i = 0, e = LineRanges.size(); i < e; ++i) {
-      unsigned FromLine, ToLine;
-      if (parseLineRange(LineRanges[i], FromLine, ToLine)) {
-        errs() << "error: invalid <start line>:<end line> pair\n";
-        return true;
-      }
-      if (FromLine > ToLine) {
-        errs() << "error: start line should be less than end line\n";
-        return true;
-      }
-      SourceLocation Start = Sources.translateLineCol(ID, FromLine, 1);
-      SourceLocation End = Sources.translateLineCol(ID, ToLine, UINT_MAX);
-      if (Start.isInvalid() || End.isInvalid())
-        return true;
-      unsigned Offset = Sources.getFileOffset(Start);
-      unsigned Length = Sources.getFileOffset(End) - Offset;
-      Ranges.push_back(tooling::Range(Offset, Length));
-    }
-    return false;
-  }
-
-  if (Offsets.empty())
-    Offsets.push_back(0);
-  if (Offsets.size() != Lengths.size() &&
-      !(Offsets.size() == 1 && Lengths.empty())) {
-    errs() << "error: number of -offset and -length arguments must match.\n";
-    return true;
-  }
-  for (unsigned i = 0, e = Offsets.size(); i != e; ++i) {
-    if (Offsets[i] >= Code->getBufferSize()) {
-      errs() << "error: offset " << Offsets[i] << " is outside the file\n";
-      return true;
-    }
-    SourceLocation Start =
-        Sources.getLocForStartOfFile(ID).getLocWithOffset(Offsets[i]);
-    SourceLocation End;
-    if (i < Lengths.size()) {
-      if (Offsets[i] + Lengths[i] > Code->getBufferSize()) {
-        errs() << "error: invalid length " << Lengths[i]
-               << ", offset + length (" << Offsets[i] + Lengths[i]
-               << ") is outside the file.\n";
-        return true;
-      }
-      End = Start.getLocWithOffset(Lengths[i]);
-    } else {
-      End = Sources.getLocForEndOfFile(ID);
-    }
-    unsigned Offset = Sources.getFileOffset(Start);
-    unsigned Length = Sources.getFileOffset(End) - Offset;
-    Ranges.push_back(tooling::Range(Offset, Length));
-  }
-  return false;
-}
-
-static void outputReplacementXML(StringRef Text) {
-  // FIXME: When we sort includes, we need to make sure the stream is correct
-  // utf-8.
-  size_t From = 0;
-  size_t Index;
-  while ((Index = Text.find_first_of("\n\r<&", From)) != StringRef::npos) {
-    outs() << Text.substr(From, Index - From);
-    switch (Text[Index]) {
-    case '\n':
-      outs() << "&#10;";
-      break;
-    case '\r':
-      outs() << "&#13;";
-      break;
-    case '<':
-      outs() << "&lt;";
-      break;
-    case '&':
-      outs() << "&amp;";
-      break;
-    default:
-      llvm_unreachable("Unexpected character encountered!");
-    }
-    From = Index + 1;
-  }
-  outs() << Text.substr(From);
-}
-
-static void outputReplacementsXML(const Replacements &Replaces) {
-  for (const auto &R : Replaces) {
-    outs() << "<replacement "
-           << "offset='" << R.getOffset() << "' "
-           << "length='" << R.getLength() << "'>";
-    outputReplacementXML(R.getReplacementText());
-    outs() << "</replacement>\n";
-  }
-}
-
-// Returns true on error.
-static bool format(StringRef FileName) {
-  if (!OutputXML && Inplace && FileName == "-") {
-    errs() << "error: cannot use -i when reading from stdin.\n";
-    return false;
-  }
-  // On Windows, overwriting a file with an open file mapping doesn't work,
-  // so read the whole file into memory when formatting in-place.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
-      !OutputXML && Inplace ? MemoryBuffer::getFileAsStream(FileName) :
-                              MemoryBuffer::getFileOrSTDIN(FileName);
-  if (std::error_code EC = CodeOrErr.getError()) {
-    errs() << EC.message() << "\n";
-    return true;
-  }
-  std::unique_ptr<llvm::MemoryBuffer> Code = std::move(CodeOrErr.get());
-  if (Code->getBufferSize() == 0)
-    return false; // Empty files are formatted correctly.
-  std::vector<tooling::Range> Ranges;
-  if (fillRanges(Code.get(), Ranges))
-    return true;
-  StringRef AssumedFileName = (FileName == "-") ? AssumeFileName : FileName;
-
-  llvm::Expected<FormatStyle> FormatStyle =
-      getStyle(Style, AssumedFileName, FallbackStyle, Code->getBuffer());
-  if (!FormatStyle) {
-    llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
-    return true;
-  }
-
-  if (SortIncludes.getNumOccurrences() != 0)
-    FormatStyle->SortIncludes = SortIncludes;
-  unsigned CursorPosition = Cursor;
-  Replacements Replaces = sortIncludes(*FormatStyle, Code->getBuffer(), Ranges,
-                                       AssumedFileName, &CursorPosition);
-  auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
-  if (!ChangedCode) {
-    llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
-    return true;
-  }
-  // Get new affected ranges after sorting `#includes`.
-  Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
-  bool IncompleteFormat = false;
-  Replacements FormatChanges = reformat(*FormatStyle, *ChangedCode, Ranges,
-                                        AssumedFileName, &IncompleteFormat);
-  Replaces = Replaces.merge(FormatChanges);
-  if (OutputXML) {
-    outs() << "<?xml version='1.0'?>\n<replacements "
-              "xml:space='preserve' incomplete_format='"
-           << (IncompleteFormat ? "true" : "false") << "'>\n";
-    if (Cursor.getNumOccurrences() != 0)
-      outs() << "<cursor>"
-             << FormatChanges.getShiftedCodePosition(CursorPosition)
-             << "</cursor>\n";
-
-    outputReplacementsXML(Replaces);
-    outs() << "</replacements>\n";
-  } else {
-    IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
-        new vfs::InMemoryFileSystem);
-    FileManager Files(FileSystemOptions(), InMemoryFileSystem);
-    DiagnosticsEngine Diagnostics(
-        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-        new DiagnosticOptions);
-    SourceManager Sources(Diagnostics, Files);
-    FileID ID = createInMemoryFile(AssumedFileName, Code.get(), Sources, Files,
-                                   InMemoryFileSystem.get());
-    Rewriter Rewrite(Sources, LangOptions());
-    tooling::applyAllReplacements(Replaces, Rewrite);
-    if (Inplace) {
-      if (Rewrite.overwriteChangedFiles())
-        return true;
-    } else {
-      if (Cursor.getNumOccurrences() != 0)
-        outs() << "{ \"Cursor\": "
-               << FormatChanges.getShiftedCodePosition(CursorPosition)
-               << ", \"IncompleteFormat\": "
-               << (IncompleteFormat ? "true" : "false") << " }\n";
-      Rewrite.getEditBuffer(ID).write(outs());
-    }
-  }
-  return false;
-}
-
-}  // namespace format
-}  // namespace clang
-
-static void PrintVersion() {
-  raw_ostream &OS = outs();
-  OS << clang::getClangToolFullVersion("clang-format") << '\n';
-}
-
-int main(int argc, const char **argv) {
-  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
-
-  cl::HideUnrelatedOptions(ClangFormatCategory);
-
-  cl::SetVersionPrinter(PrintVersion);
-  cl::ParseCommandLineOptions(
-      argc, argv,
-      "A tool to format C/C++/Java/JavaScript/Objective-C/Protobuf code.\n\n"
-      "If no arguments are specified, it formats the code from standard input\n"
-      "and writes the result to the standard output.\n"
-      "If <file>s are given, it reformats the files. If -i is specified\n"
-      "together with <file>s, the files are edited in-place. Otherwise, the\n"
-      "result is written to the standard output.\n");
-
-  if (Help)
-    cl::PrintHelpMessage();
-
-  if (DumpConfig) {
-    llvm::Expected<clang::format::FormatStyle> FormatStyle =
-        clang::format::getStyle(
-            Style, FileNames.empty() ? AssumeFileName : FileNames[0],
-            FallbackStyle);
-    if (!FormatStyle) {
-      llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
-      return 1;
-    }
-    std::string Config = clang::format::configurationAsText(*FormatStyle);
-    outs() << Config << "\n";
-    return 0;
-  }
-
-  bool Error = false;
-  switch (FileNames.size()) {
-  case 0:
-    Error = clang::format::format("-");
-    break;
-  case 1:
-    Error = clang::format::format(FileNames[0]);
-    break;
-  default:
-    if (!Offsets.empty() || !Lengths.empty() || !LineRanges.empty()) {
-      errs() << "error: -offset, -length and -lines can only be used for "
-                "single file.\n";
-      return 1;
-    }
-    for (unsigned i = 0; i < FileNames.size(); ++i)
-      Error |= clang::format::format(FileNames[i]);
-    break;
-  }
-  return Error ? 1 : 0;
-}
-
+//===-- clang-format/ClangFormat.cpp - Clang format tool ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file implements a clang-format tool that automatically formats
+/// (fragments of) C++ code.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/Version.h"
+#include "clang/Format/Format.h"
+#include "clang/Rewrite/Core/Rewriter.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Signals.h"
+
+using namespace llvm;
+using clang::tooling::Replacements;
+
+static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden);
+
+// Mark all our options with this category, everything else (except for -version
+// and -help) will be hidden.
+static cl::OptionCategory ClangFormatCategory("Clang-format options");
+
+static cl::list<unsigned>
+    Offsets("offset",
+            cl::desc("Format a range starting at this byte offset.\n"
+                     "Multiple ranges can be formatted by specifying\n"
+                     "several -offset and -length pairs.\n"
+                     "Can only be used with one input file."),
+            cl::cat(ClangFormatCategory));
+static cl::list<unsigned>
+    Lengths("length",
+            cl::desc("Format a range of this length (in bytes).\n"
+                     "Multiple ranges can be formatted by specifying\n"
+                     "several -offset and -length pairs.\n"
+                     "When only a single -offset is specified without\n"
+                     "-length, clang-format will format up to the end\n"
+                     "of the file.\n"
+                     "Can only be used with one input file."),
+            cl::cat(ClangFormatCategory));
+static cl::list<std::string>
+LineRanges("lines", cl::desc("<start line>:<end line> - format a range of\n"
+                             "lines (both 1-based).\n"
+                             "Multiple ranges can be formatted by specifying\n"
+                             "several -lines arguments.\n"
+                             "Can't be used with -offset and -length.\n"
+                             "Can only be used with one input file."),
+           cl::cat(ClangFormatCategory));
+static cl::opt<std::string>
+    Style("style",
+          cl::desc(clang::format::StyleOptionHelpDescription),
+          cl::init("file"), cl::cat(ClangFormatCategory));
+static cl::opt<std::string>
+FallbackStyle("fallback-style",
+              cl::desc("The name of the predefined style used as a\n"
+                       "fallback in case clang-format is invoked with\n"
+                       "-style=file, but can not find the .clang-format\n"
+                       "file to use.\n"
+                       "Use -fallback-style=none to skip formatting."),
+              cl::init("LLVM"), cl::cat(ClangFormatCategory));
+
+static cl::opt<std::string>
+AssumeFileName("assume-filename",
+               cl::desc("When reading from stdin, clang-format assumes this\n"
+                        "filename to look for a style config file (with\n"
+                        "-style=file) and to determine the language."),
+               cl::init("<stdin>"), cl::cat(ClangFormatCategory));
+
+static cl::opt<bool> Inplace("i",
+                             cl::desc("Inplace edit <file>s, if specified."),
+                             cl::cat(ClangFormatCategory));
+
+static cl::opt<bool> OutputXML("output-replacements-xml",
+                               cl::desc("Output replacements as XML."),
+                               cl::cat(ClangFormatCategory));
+static cl::opt<bool>
+    DumpConfig("dump-config",
+               cl::desc("Dump configuration options to stdout and exit.\n"
+                        "Can be used with -style option."),
+               cl::cat(ClangFormatCategory));
+static cl::opt<unsigned>
+    Cursor("cursor",
+           cl::desc("The position of the cursor when invoking\n"
+                    "clang-format from an editor integration"),
+           cl::init(0), cl::cat(ClangFormatCategory));
+
+static cl::opt<bool> SortIncludes(
+    "sort-includes",
+    cl::desc("If set, overrides the include sorting behavior determined by the "
+             "SortIncludes style flag"),
+    cl::cat(ClangFormatCategory));
+
+static cl::list<std::string> FileNames(cl::Positional, cl::desc("[<file> ...]"),
+                                       cl::cat(ClangFormatCategory));
+
+namespace clang {
+namespace format {
+
+static FileID createInMemoryFile(StringRef FileName, MemoryBuffer *Source,
+                                 SourceManager &Sources, FileManager &Files,
+                                 vfs::InMemoryFileSystem *MemFS) {
+  MemFS->addFileNoOwn(FileName, 0, Source);
+  return Sources.createFileID(Files.getFile(FileName), SourceLocation(),
+                              SrcMgr::C_User);
+}
+
+// Parses <start line>:<end line> input to a pair of line numbers.
+// Returns true on error.
+static bool parseLineRange(StringRef Input, unsigned &FromLine,
+                           unsigned &ToLine) {
+  std::pair<StringRef, StringRef> LineRange = Input.split(':');
+  return LineRange.first.getAsInteger(0, FromLine) ||
+         LineRange.second.getAsInteger(0, ToLine);
+}
+
+static bool fillRanges(MemoryBuffer *Code,
+                       std::vector<tooling::Range> &Ranges) {
+  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+      new vfs::InMemoryFileSystem);
+  FileManager Files(FileSystemOptions(), InMemoryFileSystem);
+  DiagnosticsEngine Diagnostics(
+      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
+      new DiagnosticOptions);
+  SourceManager Sources(Diagnostics, Files);
+  FileID ID = createInMemoryFile("<irrelevant>", Code, Sources, Files,
+                                 InMemoryFileSystem.get());
+  if (!LineRanges.empty()) {
+    if (!Offsets.empty() || !Lengths.empty()) {
+      errs() << "error: cannot use -lines with -offset/-length\n";
+      return true;
+    }
+
+    for (unsigned i = 0, e = LineRanges.size(); i < e; ++i) {
+      unsigned FromLine, ToLine;
+      if (parseLineRange(LineRanges[i], FromLine, ToLine)) {
+        errs() << "error: invalid <start line>:<end line> pair\n";
+        return true;
+      }
+      if (FromLine > ToLine) {
+        errs() << "error: start line should be less than end line\n";
+        return true;
+      }
+      SourceLocation Start = Sources.translateLineCol(ID, FromLine, 1);
+      SourceLocation End = Sources.translateLineCol(ID, ToLine, UINT_MAX);
+      if (Start.isInvalid() || End.isInvalid())
+        return true;
+      unsigned Offset = Sources.getFileOffset(Start);
+      unsigned Length = Sources.getFileOffset(End) - Offset;
+      Ranges.push_back(tooling::Range(Offset, Length));
+    }
+    return false;
+  }
+
+  if (Offsets.empty())
+    Offsets.push_back(0);
+  if (Offsets.size() != Lengths.size() &&
+      !(Offsets.size() == 1 && Lengths.empty())) {
+    errs() << "error: number of -offset and -length arguments must match.\n";
+    return true;
+  }
+  for (unsigned i = 0, e = Offsets.size(); i != e; ++i) {
+    if (Offsets[i] >= Code->getBufferSize()) {
+      errs() << "error: offset " << Offsets[i] << " is outside the file\n";
+      return true;
+    }
+    SourceLocation Start =
+        Sources.getLocForStartOfFile(ID).getLocWithOffset(Offsets[i]);
+    SourceLocation End;
+    if (i < Lengths.size()) {
+      if (Offsets[i] + Lengths[i] > Code->getBufferSize()) {
+        errs() << "error: invalid length " << Lengths[i]
+               << ", offset + length (" << Offsets[i] + Lengths[i]
+               << ") is outside the file.\n";
+        return true;
+      }
+      End = Start.getLocWithOffset(Lengths[i]);
+    } else {
+      End = Sources.getLocForEndOfFile(ID);
+    }
+    unsigned Offset = Sources.getFileOffset(Start);
+    unsigned Length = Sources.getFileOffset(End) - Offset;
+    Ranges.push_back(tooling::Range(Offset, Length));
+  }
+  return false;
+}
+
+static void outputReplacementXML(StringRef Text) {
+  // FIXME: When we sort includes, we need to make sure the stream is correct
+  // utf-8.
+  size_t From = 0;
+  size_t Index;
+  while ((Index = Text.find_first_of("\n\r<&", From)) != StringRef::npos) {
+    outs() << Text.substr(From, Index - From);
+    switch (Text[Index]) {
+    case '\n':
+      outs() << "&#10;";
+      break;
+    case '\r':
+      outs() << "&#13;";
+      break;
+    case '<':
+      outs() << "&lt;";
+      break;
+    case '&':
+      outs() << "&amp;";
+      break;
+    default:
+      llvm_unreachable("Unexpected character encountered!");
+    }
+    From = Index + 1;
+  }
+  outs() << Text.substr(From);
+}
+
+static void outputReplacementsXML(const Replacements &Replaces) {
+  for (const auto &R : Replaces) {
+    outs() << "<replacement "
+           << "offset='" << R.getOffset() << "' "
+           << "length='" << R.getLength() << "'>";
+    outputReplacementXML(R.getReplacementText());
+    outs() << "</replacement>\n";
+  }
+}
+
+// Returns true on error.
+static bool format(StringRef FileName) {
+  if (!OutputXML && Inplace && FileName == "-") {
+    errs() << "error: cannot use -i when reading from stdin.\n";
+    return false;
+  }
+  // On Windows, overwriting a file with an open file mapping doesn't work,
+  // so read the whole file into memory when formatting in-place.
+  ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
+      !OutputXML && Inplace ? MemoryBuffer::getFileAsStream(FileName) :
+                              MemoryBuffer::getFileOrSTDIN(FileName);
+  if (std::error_code EC = CodeOrErr.getError()) {
+    errs() << EC.message() << "\n";
+    return true;
+  }
+  std::unique_ptr<llvm::MemoryBuffer> Code = std::move(CodeOrErr.get());
+  if (Code->getBufferSize() == 0)
+    return false; // Empty files are formatted correctly.
+  std::vector<tooling::Range> Ranges;
+  if (fillRanges(Code.get(), Ranges))
+    return true;
+  StringRef AssumedFileName = (FileName == "-") ? AssumeFileName : FileName;
+
+  llvm::Expected<FormatStyle> FormatStyle =
+      getStyle(Style, AssumedFileName, FallbackStyle, Code->getBuffer());
+  if (!FormatStyle) {
+    llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
+    return true;
+  }
+
+  if (SortIncludes.getNumOccurrences() != 0)
+    FormatStyle->SortIncludes = SortIncludes;
+  unsigned CursorPosition = Cursor;
+  Replacements Replaces = sortIncludes(*FormatStyle, Code->getBuffer(), Ranges,
+                                       AssumedFileName, &CursorPosition);
+  auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
+  if (!ChangedCode) {
+    llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
+    return true;
+  }
+  // Get new affected ranges after sorting `#includes`.
+  Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
+  bool IncompleteFormat = false;
+  Replacements FormatChanges = reformat(*FormatStyle, *ChangedCode, Ranges,
+                                        AssumedFileName, &IncompleteFormat);
+  Replaces = Replaces.merge(FormatChanges);
+  ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
+  if (!ChangedCode) {
+    llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
+    return true;
+  }
+  // Format preprocessor directives.
+  Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
+  Replacements FormatPPChanges =
+      formatPPDirectives(*FormatStyle, *ChangedCode, Ranges, AssumedFileName);
+  Replaces = Replaces.merge(FormatPPChanges);
+  if (OutputXML) {
+    outs() << "<?xml version='1.0'?>\n<replacements "
+              "xml:space='preserve' incomplete_format='"
+           << (IncompleteFormat ? "true" : "false") << "'>\n";
+    if (Cursor.getNumOccurrences() != 0)
+      outs() << "<cursor>"
+             << FormatChanges.getShiftedCodePosition(CursorPosition)
+             << "</cursor>\n";
+
+    outputReplacementsXML(Replaces);
+    outs() << "</replacements>\n";
+  } else {
+    IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+        new vfs::InMemoryFileSystem);
+    FileManager Files(FileSystemOptions(), InMemoryFileSystem);
+    DiagnosticsEngine Diagnostics(
+        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
+        new DiagnosticOptions);
+    SourceManager Sources(Diagnostics, Files);
+    FileID ID = createInMemoryFile(AssumedFileName, Code.get(), Sources, Files,
+                                   InMemoryFileSystem.get());
+    Rewriter Rewrite(Sources, LangOptions());
+    tooling::applyAllReplacements(Replaces, Rewrite);
+    if (Inplace) {
+      if (Rewrite.overwriteChangedFiles())
+        return true;
+    } else {
+      if (Cursor.getNumOccurrences() != 0)
+        outs() << "{ \"Cursor\": "
+               << FormatChanges.getShiftedCodePosition(CursorPosition)
+               << ", \"IncompleteFormat\": "
+               << (IncompleteFormat ? "true" : "false") << " }\n";
+      Rewrite.getEditBuffer(ID).write(outs());
+    }
+  }
+  return false;
+}
+
+}  // namespace format
+}  // namespace clang
+
+static void PrintVersion() {
+  raw_ostream &OS = outs();
+  OS << clang::getClangToolFullVersion("clang-format") << '\n';
+}
+
+int main(int argc, const char **argv) {
+  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
+
+  cl::HideUnrelatedOptions(ClangFormatCategory);
+
+  cl::SetVersionPrinter(PrintVersion);
+  cl::ParseCommandLineOptions(
+      argc, argv,
+      "A tool to format C/C++/Java/JavaScript/Objective-C/Protobuf code.\n\n"
+      "If no arguments are specified, it formats the code from standard input\n"
+      "and writes the result to the standard output.\n"
+      "If <file>s are given, it reformats the files. If -i is specified\n"
+      "together with <file>s, the files are edited in-place. Otherwise, the\n"
+      "result is written to the standard output.\n");
+
+  if (Help)
+    cl::PrintHelpMessage();
+
+  if (DumpConfig) {
+    llvm::Expected<clang::format::FormatStyle> FormatStyle =
+        clang::format::getStyle(
+            Style, FileNames.empty() ? AssumeFileName : FileNames[0],
+            FallbackStyle);
+    if (!FormatStyle) {
+      llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
+      return 1;
+    }
+    std::string Config = clang::format::configurationAsText(*FormatStyle);
+    outs() << Config << "\n";
+    return 0;
+  }
+
+  bool Error = false;
+  switch (FileNames.size()) {
+  case 0:
+    Error = clang::format::format("-");
+    break;
+  case 1:
+    Error = clang::format::format(FileNames[0]);
+    break;
+  default:
+    if (!Offsets.empty() || !Lengths.empty() || !LineRanges.empty()) {
+      errs() << "error: -offset, -length and -lines can only be used for "
+                "single file.\n";
+      return 1;
+    }
+    for (unsigned i = 0; i < FileNames.size(); ++i)
+      Error |= clang::format::format(FileNames[i]);
+    break;
+  }
+  return Error ? 1 : 0;
+}
+

unittests/Format/CMakeLists.txt

-set(LLVM_LINK_COMPONENTS
-  Support
-  )
-
-add_clang_unittest(FormatTests
-  CleanupTest.cpp
-  FormatTest.cpp
-  FormatTestComments.cpp
-  FormatTestJS.cpp
-  FormatTestJava.cpp
-  FormatTestObjC.cpp
-  FormatTestProto.cpp
-  FormatTestSelective.cpp
-  NamespaceEndCommentsFixerTest.cpp
-  SortImportsTestJS.cpp
-  SortIncludesTest.cpp
-  )
-
-target_link_libraries(FormatTests
-  clangBasic
-  clangFormat
-  clangFrontend
-  clangRewrite
-  clangToolingCore
-  )
+set(LLVM_LINK_COMPONENTS
+  Support
+  )
+
+add_clang_unittest(FormatTests
+  CleanupTest.cpp
+  FormatPreprocessorTest.cpp
+  FormatTest.cpp
+  FormatTestComments.cpp
+  FormatTestJS.cpp
+  FormatTestJava.cpp
+  FormatTestObjC.cpp
+  FormatTestProto.cpp
+  FormatTestSelective.cpp
+  NamespaceEndCommentsFixerTest.cpp
+  SortImportsTestJS.cpp
+  SortIncludesTest.cpp
+  )
+
+target_link_libraries(FormatTests
+  clangBasic
+  clangFormat
+  clangFrontend
+  clangRewrite
+  clangToolingCore
+  )

unittests/Format/FormatPreprocessorTest.cpp

+//===- unittest/Format/FormatPreprocessorTest.cpp - Format unit tests -----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "FormatTestUtils.h"
+#include "clang/Format/Format.h"
+#include "llvm/Support/Debug.h"
+#include "gtest/gtest.h"
+
+#define DEBUG_TYPE "format-test"
+
+namespace clang {
+namespace format {
+namespace {
+
+class FormatPreprocessorTest : public ::testing::Test {
+protected:
+  std::vector<tooling::Range> GetCodeRange(StringRef Code) {
+    return std::vector<tooling::Range>(1, tooling::Range(0, Code.size()));
+  }
+
+  std::string format(StringRef Code, const FormatStyle &Style = getLLVMStyle(),
+                     StringRef FileName = "input.cpp") {
+    auto Ranges = GetCodeRange(Code);
+    auto Replaces = reformat(Style, Code, Ranges, "<stdin>");
+    auto Formatted = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE(static_cast<bool>(Formatted));
+    auto Result = applyAllReplacements(
+        *Formatted, formatPPDirectives(Style, *Formatted, Ranges, FileName));
+    EXPECT_TRUE(static_cast<bool>(Result));
+    return *Result;
+  }
+
+  void verifyFormat(llvm::StringRef Code,
+                    const FormatStyle &Style = getLLVMStyle()) {
+    EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
+  }
+
+  int ReplacementCount;
+};
+
+TEST_F(FormatPreprocessorTest, NoPPIndent) {
+  verifyFormat("#ifndef A\n"
+               "#define A\n"
+               "#endif\n");
+}
+
+TEST_F(FormatPreprocessorTest, UseIndentWidthForPP) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifndef A\n"
+            "# define A\n"
+            "#endif\n",
+            format("#ifndef A\n"
+                   "#define A\n"
+                   "#endif\n",
+                   Style));
+  Style.IndentWidth = 4;
+  EXPECT_EQ("#ifndef A\n"
+            "#   define A\n"
+            "#endif\n",
+            format("#ifndef A\n"
+                   "#define A\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, MultiLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifdef A\n"
+            "# ifdef B\n"
+            "#   undef B\n"
+            "# endif\n"
+            "#endif\n",
+            format("#ifdef A\n"
+                   "#ifdef B\n"
+                   "#undef B\n"
+                   "#endif\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, Inner) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_Inner;
+  EXPECT_EQ("#ifndef INCLUDE_GUARD\n"
+            "#define INCLUDE_GUARD\n"
+            "#define A\n"
+            "#endif // INCLUDE_GUARD\n",
+            format("#       ifndef  INCLUDE_GUARD\n"
+                   "  # define   INCLUDE_GUARD\n"
+                   "#       define A\n"
+                   "    #   endif // INCLUDE_GUARD\n",
+                   Style));
+
+  EXPECT_EQ("#if !defined INCLUDE_GUARD\n"
+            "#define INCLUDE_GUARD\n"
+            "#define A\n"
+            "#endif\n",
+            format("#       if !  defined   INCLUDE_GUARD \n"
+                   "#define INCLUDE_GUARD\n"
+                   "    # define A\n"
+                   "    #   endif\n",
+                   Style));
+
+  EXPECT_EQ("#if !defined(INCLUDE_GUARD)\n"
+            "#define INCLUDE_GUARD\n"
+            "#define A\n"
+            "#endif\n",
+            format("#       if   !  defined  (  INCLUDE_GUARD  )\n"
+                   "#define INCLUDE_GUARD\n"
+                   "    # define A\n"
+                   "    #   endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, InnerIfDefIsNotAnIncludeGuard) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_Inner;
+  EXPECT_EQ("#ifdef NOT_INCLUDE_GUARD\n"
+            "# define NOT_INCLUDE_GUARD\n"
+            "# define A\n"
+            "#endif\n",
+            format("#       ifdef NOT_INCLUDE_GUARD\n"
+                   "#define NOT_INCLUDE_GUARD\n"
+                   "# define A\n"
+                   "    #   endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, InnerDifferentVariableIsNotAnIncludeGuard) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_Inner;
+  EXPECT_EQ("#ifndef NOT_INCLUDE_GUARD\n"
+            "# define A\n"
+            "# define B\n"
+            "#endif\n",
+            format("#       ifndef NOT_INCLUDE_GUARD\n"
+                   "# define A\n"
+                   "# define B\n"
+                   "    #   endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, IfKeepsLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#if A\n"
+            "# define A\n"
+            "#endif\n",
+            format("#if A\n"
+                   "#define A\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, IfDefChangesLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifdef A\n"
+            "# undef A\n"
+            "#endif\n",
+            format("#ifdef A\n"
+                   "#undef A\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, IfNDefChangesLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifndef A\n"
+            "# define A\n"
+            "#endif\n",
+            format("#ifndef A\n"
+                   "#define A\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, EndIfChangesLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifndef A\n"
+            "# define A\n"
+            "#endif\n"
+            "#define B\n",
+            format("#ifndef A\n"
+                   "#define A\n"
+                   "#endif\n"
+                   "#define B\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, ElseKeepsLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifndef A\n"
+            "#else\n"
+            "# define A\n"
+            "#endif\n",
+            format("#ifndef A\n"
+                   "#else\n"
+                   "#define A\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, ElIfKeepsLevel) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifndef A\n"
+            "#elif !defined(B)\n"
+            "# define B\n"
+            "#endif\n",
+            format("#ifndef A\n"
+                   "#elif !defined(B)\n"
+                   "#define B\n"
+                   "#endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, HashAfterWhitespace) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  EXPECT_EQ("#ifndef A\n"
+            "# define A\n"
+            "#endif\n",
+            format("  #ifndef A\n"
+                   "     #define A\n"
+                   "    #endif\n",
+                   Style));
+}
+
+TEST_F(FormatPreprocessorTest, StyleSpaceBeforeHash) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  Style.PPDirectiveIndentationStyle = FormatStyle::PPDIS_BeforeHash;
+  EXPECT_EQ("#ifndef A\n"
+            " #define A\n"
+            "#endif\n",
+            format("  #ifndef A\n"
+                   "  #define A\n"
+                   "  #endif\n",
+                   Style));
+}
+
+} // end namespace
+} // end namespace format
+} // end namespace clang

unittests/Format/FormatTest.cpp

-//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Format/Format.h"
-
-#include "../Tooling/ReplacementTest.h"
-#include "FormatTestUtils.h"
-
-#include "clang/Frontend/TextDiagnosticPrinter.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "gtest/gtest.h"
-
-#define DEBUG_TYPE "format-test"
-
-using clang::tooling::ReplacementTest;
-using clang::tooling::toReplacements;
-
-namespace clang {
-namespace format {
-namespace {
-
-FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
-
-class FormatTest : public ::testing::Test {
-protected:
-  enum IncompleteCheck {
-    IC_ExpectComplete,
-    IC_ExpectIncomplete,
-    IC_DoNotCheck
-  };
-
-  std::string format(llvm::StringRef Code,
-                     const FormatStyle &Style = getLLVMStyle(),
-                     IncompleteCheck CheckIncomplete = IC_ExpectComplete) {
-    DEBUG(llvm::errs() << "---\n");
-    DEBUG(llvm::errs() << Code << "\n\n");
-    std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
-    bool IncompleteFormat = false;
-    tooling::Replacements Replaces =
-        reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
-    if (CheckIncomplete != IC_DoNotCheck) {
-      bool ExpectedIncompleteFormat = CheckIncomplete == IC_ExpectIncomplete;
-      EXPECT_EQ(ExpectedIncompleteFormat, IncompleteFormat) << Code << "\n\n";
-    }
-    ReplacementCount = Replaces.size();
-    auto Result = applyAllReplacements(Code, Replaces);
-    EXPECT_TRUE(static_cast<bool>(Result));
-    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
-    return *Result;
-  }
-
-  FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
-    FormatStyle Style = getLLVMStyle();
-    Style.ColumnLimit = ColumnLimit;
-    return Style;
-  }
-
-  FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
-    FormatStyle Style = getGoogleStyle();
-    Style.ColumnLimit = ColumnLimit;
-    return Style;
-  }
-
-  void verifyFormat(llvm::StringRef Code,
-                    const FormatStyle &Style = getLLVMStyle()) {
-    EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
-    if (Style.Language == FormatStyle::LK_Cpp) {
-      // Objective-C++ is a superset of C++, so everything checked for C++
-      // needs to be checked for Objective-C++ as well.
-      FormatStyle ObjCStyle = Style;
-      ObjCStyle.Language = FormatStyle::LK_ObjC;
-      EXPECT_EQ(Code.str(), format(test::messUp(Code), ObjCStyle));
-    }
-  }
-
-  void verifyIncompleteFormat(llvm::StringRef Code,
-                              const FormatStyle &Style = getLLVMStyle()) {
-    EXPECT_EQ(Code.str(),
-              format(test::messUp(Code), Style, IC_ExpectIncomplete));
-  }
-
-  void verifyGoogleFormat(llvm::StringRef Code) {
-    verifyFormat(Code, getGoogleStyle());
-  }
-
-  void verifyIndependentOfContext(llvm::StringRef text) {
-    verifyFormat(text);
-    verifyFormat(llvm::Twine("void f() { " + text + " }").str());
-  }
-
-  /// \brief Verify that clang-format does not crash on the given input.
-  void verifyNoCrash(llvm::StringRef Code,
-                     const FormatStyle &Style = getLLVMStyle()) {
-    format(Code, Style, IC_DoNotCheck);
-  }
-
-  int ReplacementCount;
-};
-
-TEST_F(FormatTest, MessUp) {
-  EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
-  EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
-  EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
-  EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
-  EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
-}
-
-//===----------------------------------------------------------------------===//
-// Basic function tests.
-//===----------------------------------------------------------------------===//
-
-TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
-  EXPECT_EQ(";", format(";"));
-}
-
-TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
-  EXPECT_EQ("int i;", format("  int i;"));
-  EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
-  EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
-  EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
-}
-
-TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
-  EXPECT_EQ("int i;", format("int\ni;"));
-}
-
-TEST_F(FormatTest, FormatsNestedBlockStatements) {
-  EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
-}
-
-TEST_F(FormatTest, FormatsNestedCall) {
-  verifyFormat("Method(f1, f2(f3));");
-  verifyFormat("Method(f1(f2, f3()));");
-  verifyFormat("Method(f1(f2, (f3())));");
-}
-
-TEST_F(FormatTest, NestedNameSpecifiers) {
-  verifyFormat("vector<::Type> v;");
-  verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
-  verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
-  verifyFormat("bool a = 2 < ::SomeFunction();");
-  verifyFormat("ALWAYS_INLINE ::std::string getName();");
-  verifyFormat("some::string getName();");
-}
-
-TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
-  EXPECT_EQ("if (a) {\n"
-            "  f();\n"
-            "}",
-            format("if(a){f();}"));
-  EXPECT_EQ(4, ReplacementCount);
-  EXPECT_EQ("if (a) {\n"
-            "  f();\n"
-            "}",
-            format("if (a) {\n"
-                   "  f();\n"
-                   "}"));
-  EXPECT_EQ(0, ReplacementCount);
-  EXPECT_EQ("/*\r\n"
-            "\r\n"
-            "*/\r\n",
-            format("/*\r\n"
-                   "\r\n"
-                   "*/\r\n"));
-  EXPECT_EQ(0, ReplacementCount);
-}
-
-TEST_F(FormatTest, RemovesEmptyLines) {
-  EXPECT_EQ("class C {\n"
-            "  int i;\n"
-            "};",
-            format("class C {\n"
-                   " int i;\n"
-                   "\n"
-                   "};"));
-
-  // Don't remove empty lines at the start of namespaces or extern "C" blocks.
-  EXPECT_EQ("namespace N {\n"
-            "\n"
-            "int i;\n"
-            "}",
-            format("namespace N {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-  EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
-            "\n"
-            "int i;\n"
-            "}",
-            format("extern /**/ \"C\" /**/ {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-
-  // ...but do keep inlining and removing empty lines for non-block extern "C"
-  // functions.
-  verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
-  EXPECT_EQ("extern \"C\" int f() {\n"
-            "  int i = 42;\n"
-            "  return i;\n"
-            "}",
-            format("extern \"C\" int f() {\n"
-                   "\n"
-                   "  int i = 42;\n"
-                   "  return i;\n"
-                   "}",
-                   getGoogleStyle()));
-
-  // Remove empty lines at the beginning and end of blocks.
-  EXPECT_EQ("void f() {\n"
-            "\n"
-            "  if (a) {\n"
-            "\n"
-            "    f();\n"
-            "  }\n"
-            "}",
-            format("void f() {\n"
-                   "\n"
-                   "  if (a) {\n"
-                   "\n"
-                   "    f();\n"
-                   "\n"
-                   "  }\n"
-                   "\n"
-                   "}",
-                   getLLVMStyle()));
-  EXPECT_EQ("void f() {\n"
-            "  if (a) {\n"
-            "    f();\n"
-            "  }\n"
-            "}",
-            format("void f() {\n"
-                   "\n"
-                   "  if (a) {\n"
-                   "\n"
-                   "    f();\n"
-                   "\n"
-                   "  }\n"
-                   "\n"
-                   "}",
-                   getGoogleStyle()));
-
-  // Don't remove empty lines in more complex control statements.
-  EXPECT_EQ("void f() {\n"
-            "  if (a) {\n"
-            "    f();\n"
-            "\n"
-            "  } else if (b) {\n"
-            "    f();\n"
-            "  }\n"
-            "}",
-            format("void f() {\n"
-                   "  if (a) {\n"
-                   "    f();\n"
-                   "\n"
-                   "  } else if (b) {\n"
-                   "    f();\n"
-                   "\n"
-                   "  }\n"
-                   "\n"
-                   "}"));
-
-  // FIXME: This is slightly inconsistent.
-  FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
-  LLVMWithNoNamespaceFix.FixNamespaceComments = false;
-  EXPECT_EQ("namespace {\n"
-            "int i;\n"
-            "}",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "}", LLVMWithNoNamespaceFix));
-  EXPECT_EQ("namespace {\n"
-            "int i;\n"
-            "}",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "}"));
-  EXPECT_EQ("namespace {\n"
-            "int i;\n"
-            "\n"
-            "} // namespace",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "}  // namespace"));
-
-  FormatStyle Style = getLLVMStyle();
-  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
-  Style.MaxEmptyLinesToKeep = 2;
-  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
-  Style.BraceWrapping.AfterClass = true;
-  Style.BraceWrapping.AfterFunction = true;
-  Style.KeepEmptyLinesAtTheStartOfBlocks = false;
-
-  EXPECT_EQ("class Foo\n"
-            "{\n"
-            "  Foo() {}\n"
-            "\n"
-            "  void funk() {}\n"
-            "};",
-            format("class Foo\n"
-                   "{\n"
-                   "  Foo()\n"
-                   "  {\n"
-                   "  }\n"
-                   "\n"
-                   "  void funk() {}\n"
-                   "};",
-                   Style));
-}
-
-TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
-  verifyFormat("x = (a) and (b);");
-  verifyFormat("x = (a) or (b);");
-  verifyFormat("x = (a) bitand (b);");
-  verifyFormat("x = (a) bitor (b);");
-  verifyFormat("x = (a) not_eq (b);");
-  verifyFormat("x = (a) and_eq (b);");
-  verifyFormat("x = (a) or_eq (b);");
-  verifyFormat("x = (a) xor (b);");
-}
-
-//===----------------------------------------------------------------------===//
-// Tests for control statements.
-//===----------------------------------------------------------------------===//
-
-TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
-  verifyFormat("if (true)\n  f();\ng();");
-  verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
-  verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
-
-  FormatStyle AllowsMergedIf = getLLVMStyle();
-  AllowsMergedIf.AlignEscapedNewlinesLeft = true;
-  AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
-  verifyFormat("if (a)\n"
-               "  // comment\n"
-               "  f();",
-               AllowsMergedIf);
-  verifyFormat("{\n"
-               "  if (a)\n"
-               "  label:\n"
-               "    f();\n"
-               "}",
-               AllowsMergedIf);
-  verifyFormat("#define A \\\n"
-               "  if (a)  \\\n"
-               "  label:  \\\n"
-               "    f()",
-               AllowsMergedIf);
-  verifyFormat("if (a)\n"
-               "  ;",
-               AllowsMergedIf);
-  verifyFormat("if (a)\n"
-               "  if (b) return;",
-               AllowsMergedIf);
-
-  verifyFormat("if (a) // Can't merge this\n"
-               "  f();\n",
-               AllowsMergedIf);
-  verifyFormat("if (a) /* still don't merge */\n"
-               "  f();",
-               AllowsMergedIf);
-  verifyFormat("if (a) { // Never merge this\n"
-               "  f();\n"
-               "}",
-               AllowsMergedIf);
-  verifyFormat("if (a) { /* Never merge this */\n"
-               "  f();\n"
-               "}",
-               AllowsMergedIf);
-
-  AllowsMergedIf.ColumnLimit = 14;
-  verifyFormat("if (a) return;", AllowsMergedIf);
-  verifyFormat("if (aaaaaaaaa)\n"
-               "  return;",
-               AllowsMergedIf);
-
-  AllowsMergedIf.ColumnLimit = 13;
-  verifyFormat("if (a)\n  return;", AllowsMergedIf);
-}
-
-TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
-  FormatStyle AllowsMergedLoops = getLLVMStyle();
-  AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
-  verifyFormat("while (true) continue;", AllowsMergedLoops);
-  verifyFormat("for (;;) continue;", AllowsMergedLoops);
-  verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
-  verifyFormat("while (true)\n"
-               "  ;",
-               AllowsMergedLoops);
-  verifyFormat("for (;;)\n"
-               "  ;",
-               AllowsMergedLoops);
-  verifyFormat("for (;;)\n"
-               "  for (;;) continue;",
-               AllowsMergedLoops);
-  verifyFormat("for (;;) // Can't merge this\n"
-               "  continue;",
-               AllowsMergedLoops);
-  verifyFormat("for (;;) /* still don't merge */\n"
-               "  continue;",
-               AllowsMergedLoops);
-}
-
-TEST_F(FormatTest, FormatShortBracedStatements) {
-  FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
-  AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true;
-
-  AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
-  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
-
-  verifyFormat("if (true) {}", AllowSimpleBracedStatements);
-  verifyFormat("while (true) {}", AllowSimpleBracedStatements);
-  verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
-  verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
-  verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
-  verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
-  verifyFormat("if (true) { //\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-  verifyFormat("if (true) {\n"
-               "  f();\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-  verifyFormat("if (true) {\n"
-               "  f();\n"
-               "} else {\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-
-  verifyFormat("template <int> struct A2 {\n"
-               "  struct B {};\n"
-               "};",
-               AllowSimpleBracedStatements);
-
-  AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
-  verifyFormat("if (true) {\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-  verifyFormat("if (true) {\n"
-               "  f();\n"
-               "} else {\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-
-  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
-  verifyFormat("while (true) {\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-  verifyFormat("for (;;) {\n"
-               "  f();\n"
-               "}",
-               AllowSimpleBracedStatements);
-}
-
-TEST_F(FormatTest, ParseIfElse) {
-  verifyFormat("if (true)\n"
-               "  if (true)\n"
-               "    if (true)\n"
-               "      f();\n"
-               "    else\n"
-               "      g();\n"
-               "  else\n"
-               "    h();\n"
-               "else\n"
-               "  i();");
-  verifyFormat("if (true)\n"
-               "  if (true)\n"
-               "    if (true) {\n"
-               "      if (true)\n"
-               "        f();\n"
-               "    } else {\n"
-               "      g();\n"
-               "    }\n"
-               "  else\n"
-               "    h();\n"
-               "else {\n"
-               "  i();\n"
-               "}");
-  verifyFormat("void f() {\n"
-               "  if (a) {\n"
-               "  } else {\n"
-               "  }\n"
-               "}");
-}
-
-TEST_F(FormatTest, ElseIf) {
-  verifyFormat("if (a) {\n} else if (b) {\n}");
-  verifyFormat("if (a)\n"
-               "  f();\n"
-               "else if (b)\n"
-               "  g();\n"
-               "else\n"
-               "  h();");
-  verifyFormat("if (a) {\n"
-               "  f();\n"
-               "}\n"
-               "// or else ..\n"
-               "else {\n"
-               "  g()\n"
-               "}");
-
-  verifyFormat("if (a) {\n"
-               "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
-               "}");
-  verifyFormat("if (a) {\n"
-               "} else if (\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
-               "}",
-               getLLVMStyleWithColumns(62));
-}
-
-TEST_F(FormatTest, FormatsForLoop) {
-  verifyFormat(
-      "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
-      "     ++VeryVeryLongLoopVariable)\n"
-      "  ;");
-  verifyFormat("for (;;)\n"
-               "  f();");
-  verifyFormat("for (;;) {\n}");
-  verifyFormat("for (;;) {\n"
-               "  f();\n"
-               "}");
-  verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
-
-  verifyFormat(
-      "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
-      "                                          E = UnwrappedLines.end();\n"
-      "     I != E; ++I) {\n}");
-
-  verifyFormat(
-      "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
-      "     ++IIIII) {\n}");
-  verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
-               "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
-               "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
-  verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
-               "         I = FD->getDeclsInPrototypeScope().begin(),\n"
-               "         E = FD->getDeclsInPrototypeScope().end();\n"
-               "     I != E; ++I) {\n}");
-  verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
-               "         I = Container.begin(),\n"
-               "         E = Container.end();\n"
-               "     I != E; ++I) {\n}",
-               getLLVMStyleWithColumns(76));
-
-  verifyFormat(
-      "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
-      "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
-      "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
-      "     ++aaaaaaaaaaa) {\n}");
-  verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
-               "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
-               "     ++i) {\n}");
-  verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
-               "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
-               "}");
-  verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
-               "         aaaaaaaaaa);\n"
-               "     iter; ++iter) {\n"
-               "}");
-  verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
-               "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
-               "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
-
-  FormatStyle NoBinPacking = getLLVMStyle();
-  NoBinPacking.BinPackParameters = false;
-  verifyFormat("for (int aaaaaaaaaaa = 1;\n"
-               "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
-               "                                           aaaaaaaaaaaaaaaa,\n"
-               "                                           aaaaaaaaaaaaaaaa,\n"
-               "                                           aaaaaaaaaaaaaaaa);\n"
-               "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
-               "}",
-               NoBinPacking);
-  verifyFormat(
-      "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
-      "                                          E = UnwrappedLines.end();\n"
-      "     I != E;\n"
-      "     ++I) {\n}",
-      NoBinPacking);
-}
-
-TEST_F(FormatTest, RangeBasedForLoops) {
-  verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-               "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
-  verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
-               "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
-  verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
-               "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
-  verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
-               "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
-}
-
-TEST_F(FormatTest, ForEachLoops) {
-  verifyFormat("void f() {\n"
-               "  foreach (Item *item, itemlist) {}\n"
-               "  Q_FOREACH (Item *item, itemlist) {}\n"
-               "  BOOST_FOREACH (Item *item, itemlist) {}\n"
-               "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
-               "}");
-
-  // As function-like macros.
-  verifyFormat("#define foreach(x, y)\n"
-               "#define Q_FOREACH(x, y)\n"
-               "#define BOOST_FOREACH(x, y)\n"
-               "#define UNKNOWN_FOREACH(x, y)\n");
-
-  // Not as function-like macros.
-  verifyFormat("#define foreach (x, y)\n"
-               "#define Q_FOREACH (x, y)\n"
-               "#define BOOST_FOREACH (x, y)\n"
-               "#define UNKNOWN_FOREACH (x, y)\n");
-}
-
-TEST_F(FormatTest, FormatsWhileLoop) {
-  verifyFormat("while (true) {\n}");
-  verifyFormat("while (true)\n"
-               "  f();");
-  verifyFormat("while () {\n}");
-  verifyFormat("while () {\n"
-               "  f();\n"
-               "}");
-}
-
-TEST_F(FormatTest, FormatsDoWhile) {
-  verifyFormat("do {\n"
-               "  do_something();\n"
-               "} while (something());");
-  verifyFormat("do\n"
-               "  do_something();\n"
-               "while (something());");
-}
-
-TEST_F(FormatTest, FormatsSwitchStatement) {
-  verifyFormat("switch (x) {\n"
-               "case 1:\n"
-               "  f();\n"
-               "  break;\n"
-               "case kFoo:\n"
-               "case ns::kBar:\n"
-               "case kBaz:\n"
-               "  break;\n"
-               "default:\n"
-               "  g();\n"
-               "  break;\n"
-               "}");
-  verifyFormat("switch (x) {\n"
-               "case 1: {\n"
-               "  f();\n"
-               "  break;\n"
-               "}\n"
-               "case 2: {\n"
-               "  break;\n"
-               "}\n"
-               "}");
-  verifyFormat("switch (x) {\n"
-               "case 1: {\n"
-               "  f();\n"
-               "  {\n"
-               "    g();\n"
-               "    h();\n"
-               "  }\n"
-               "  break;\n"
-               "}\n"
-               "}");
-  verifyFormat("switch (x) {\n"
-               "case 1: {\n"
-               "  f();\n"
-               "  if (foo) {\n"
-               "    g();\n"
-               "    h();\n"
-               "  }\n"
-               "  break;\n"
-               "}\n"
-               "}");
-  verifyFormat("switch (x) {\n"
-               "case 1: {\n"
-               "  f();\n"
-               "  g();\n"
-               "} break;\n"
-               "}");
-  verifyFormat("switch (test)\n"
-               "  ;");
-  verifyFormat("switch (x) {\n"
-               "default: {\n"
-               "  // Do nothing.\n"
-               "}\n"
-               "}");
-  verifyFormat("switch (x) {\n"
-               "// comment\n"
-               "// if 1, do f()\n"
-               "case 1:\n"
-               "  f();\n"
-               "}");
-  verifyFormat("switch (x) {\n"
-               "case 1:\n"
-               "  // Do amazing stuff\n"
-               "  {\n"
-               "    f();\n"
-               "    g();\n"
-               "  }\n"
-               "  break;\n"
-               "}");
-  verifyFormat("#define A          \\\n"
-               "  switch (x) {     \\\n"
-               "  case a:          \\\n"
-               "    foo = b;       \\\n"
-               "  }",
-               getLLVMStyleWithColumns(20));
-  verifyFormat("#define OPERATION_CASE(name)           \\\n"
-               "  case OP_name:                        \\\n"
-               "    return operations::Operation##name\n",
-               getLLVMStyleWithColumns(40));
-  verifyFormat("switch (x) {\n"
-               "case 1:;\n"
-               "default:;\n"
-               "  int i;\n"
-               "}");
-
-  verifyGoogleFormat("switch (x) {\n"
-                     "  case 1:\n"
-                     "    f();\n"
-                     "    break;\n"
-                     "  case kFoo:\n"
-                     "  case ns::kBar:\n"
-                     "  case kBaz:\n"
-                     "    break;\n"
-                     "  default:\n"
-                     "    g();\n"
-                     "    break;\n"
-                     "}");
-  verifyGoogleFormat("switch (x) {\n"
-                     "  case 1: {\n"
-                     "    f();\n"
-                     "    break;\n"
-                     "  }\n"
-                     "}");
-  verifyGoogleFormat("switch (test)\n"
-                     "  ;");
-
-  verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
-                     "  case OP_name:              \\\n"
-                     "    return operations::Operation##name\n");
-  verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
-                     "  // Get the correction operation class.\n"
-                     "  switch (OpCode) {\n"
-                     "    CASE(Add);\n"
-                     "    CASE(Subtract);\n"
-                     "    default:\n"
-                     "      return operations::Unknown;\n"
-                     "  }\n"
-                     "#undef OPERATION_CASE\n"
-                     "}");
-  verifyFormat("DEBUG({\n"
-               "  switch (x) {\n"
-               "  case A:\n"
-               "    f();\n"
-               "    break;\n"
-               "  // On B:\n"
-               "  case B:\n"
-               "    g();\n"
-               "    break;\n"
-               "  }\n"
-               "});");
-  verifyFormat("switch (a) {\n"
-               "case (b):\n"
-               "  return;\n"
-               "}");
-
-  verifyFormat("switch (a) {\n"
-               "case some_namespace::\n"
-               "    some_constant:\n"
-               "  return;\n"
-               "}",
-               getLLVMStyleWithColumns(34));
-}
-
-TEST_F(FormatTest, CaseRanges) {
-  verifyFormat("switch (x) {\n"
-               "case 'A' ... 'Z':\n"
-               "case 1 ... 5:\n"
-               "case a ... b:\n"
-               "  break;\n"
-               "}");
-}
-
-TEST_F(FormatTest, ShortCaseLabels) {
-  FormatStyle Style = getLLVMStyle();
-  Style.AllowShortCaseLabelsOnASingleLine = true;
-  verifyFormat("switch (a) {\n"
-               "case 1: x = 1; break;\n"
-               "case 2: return;\n"
-               "case 3:\n"
-               "case 4:\n"
-               "case 5: return;\n"
-               "case 6: // comment\n"
-               "  return;\n"
-               "case 7:\n"
-               "  // comment\n"
-               "  return;\n"
-               "case 8:\n"
-               "  x = 8; // comment\n"
-               "  break;\n"
-               "default: y = 1; break;\n"
-               "}",
-               Style);
-  verifyFormat("switch (a) {\n"
-               "#if FOO\n"
-               "case 0: return 0;\n"
-               "#endif\n"
-               "}",
-               Style);
-  verifyFormat("switch (a) {\n"
-               "case 1: {\n"
-               "}\n"
-               "case 2: {\n"
-               "  return;\n"
-               "}\n"
-               "case 3: {\n"
-               "  x = 1;\n"
-               "  return;\n"
-               "}\n"
-               "case 4:\n"
-               "  if (x)\n"
-               "    return;\n"
-               "}",
-               Style);
-  Style.ColumnLimit = 21;
-  verifyFormat("switch (a) {\n"
-               "case 1: x = 1; break;\n"
-               "case 2: return;\n"
-               "case 3:\n"
-               "case 4:\n"
-               "case 5: return;\n"
-               "default:\n"
-               "  y = 1;\n"
-               "  break;\n"
-               "}",
-               Style);
-}
-
-TEST_F(FormatTest, FormatsLabels) {
-  verifyFormat("void f() {\n"
-               "  some_code();\n"
-               "test_label:\n"
-               "  some_other_code();\n"
-               "  {\n"
-               "    some_more_code();\n"
-               "  another_label:\n"
-               "    some_more_code();\n"
-               "  }\n"
-               "}");
-  verifyFormat("{\n"
-               "  some_code();\n"
-               "test_label:\n"
-               "  some_other_code();\n"
-               "}");
-  verifyFormat("{\n"
-               "  some_code();\n"
-               "test_label:;\n"
-               "  int i = 0;\n"
-               "}");
-}
-
-//===----------------------------------------------------------------------===//
-// Tests for classes, namespaces, etc.
-//===----------------------------------------------------------------------===//
-
-TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
-  verifyFormat("class A {};");
-}
-
-TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
-  verifyFormat("class A {\n"
-               "public:\n"
-               "public: // comment\n"
-               "protected:\n"
-               "private:\n"
-               "  void f() {}\n"
-               "};");
-  verifyGoogleFormat("class A {\n"
-                     " public:\n"
-                     " protected:\n"
-                     " private:\n"
-                     "  void f() {}\n"
-                     "};");
-  verifyFormat("class A {\n"
-               "public slots:\n"
-               "  void f1() {}\n"
-               "public Q_SLOTS:\n"
-               "  void f2() {}\n"
-               "protected slots:\n"
-               "  void f3() {}\n"
-               "protected Q_SLOTS:\n"
-               "  void f4() {}\n"
-               "private slots:\n"
-               "  void f5() {}\n"
-               "private Q_SLOTS:\n"
-               "  void f6() {}\n"
-               "signals:\n"
-               "  void g1();\n"
-               "Q_SIGNALS:\n"
-               "  void g2();\n"
-               "};");
-
-  // Don't interpret 'signals' the wrong way.
-  verifyFormat("signals.set();");
-  verifyFormat("for (Signals signals : f()) {\n}");
-  verifyFormat("{\n"
-               "  signals.set(); // This needs indentation.\n"
-               "}");
-  verifyFormat("void f() {\n"
-               "label:\n"
-               "  signals.baz();\n"
-               "}");
-}
-
-TEST_F(FormatTest, SeparatesLogicalBlocks) {
-  EXPECT_EQ("class A {\n"
-            "public:\n"
-            "  void f();\n"
-            "\n"
-            "private:\n"
-            "  void g() {}\n"
-            "  // test\n"
-            "protected:\n"
-            "  int h;\n"
-            "};",
-            format("class A {\n"
-                   "public:\n"
-                   "void f();\n"
-                   "private:\n"
-                   "void g() {}\n"
-                   "// test\n"
-                   "protected:\n"
-                   "int h;\n"
-                   "};"));
-  EXPECT_EQ("class A {\n"
-            "protected:\n"
-            "public:\n"
-            "  void f();\n"
-            "};",
-            format("class A {\n"
-                   "protected:\n"
-                   "\n"
-                   "public:\n"
-                   "\n"
-                   "  void f();\n"
-                   "};"));
-
-  // Even ensure proper spacing inside macros.
-  EXPECT_EQ("#define B     \\\n"
-            "  class A {   \\\n"
-            "   protected: \\\n"
-            "   public:    \\\n"
-            "    void f(); \\\n"
-            "  };",
-            format("#define B     \\\n"
-                   "  class A {   \\\n"
-                   "   protected: \\\n"
-                   "              \\\n"
-                   "   public:    \\\n"
-                   "              \\\n"
-                   "    void f(); \\\n"
-                   "  };",
-                   getGoogleStyle()));
-  // But don't remove empty lines after macros ending in access specifiers.
-  EXPECT_EQ("#define A private:\n"
-            "\n"
-            "int i;",
-            format("#define A         private:\n"
-                   "\n"
-                   "int              i;"));
-}
-
-TEST_F(FormatTest, FormatsClasses) {
-  verifyFormat("class A : public B {};");
-  verifyFormat("class A : public ::B {};");
-
-  verifyFormat(
-      "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
-      "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
-  verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
-               "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
-               "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
-  verifyFormat(
-      "class A : public B, public C, public D, public E, public F {};");
-  verifyFormat("class AAAAAAAAAAAA : public B,\n"
-               "                     public C,\n"
-               "                     public D,\n"
-               "                     public E,\n"
-               "                     public F,\n"
-               "                     public G {};");
-
-  verifyFormat("class\n"
-               "    ReallyReallyLongClassName {\n"
-               "  int i;\n"
-               "};",
-               getLLVMStyleWithColumns(32));
-  verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
-               "                           aaaaaaaaaaaaaaaa> {};");
-  verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
-               "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
-               "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
-  verifyFormat("template <class R, class C>\n"
-               "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
-               "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
-  verifyFormat("class ::A::B {};");
-}
-
-TEST_F(FormatTest, BreakBeforeInheritanceComma) {
-  FormatStyle StyleWithInheritanceBreak = getLLVMStyle();
-  StyleWithInheritanceBreak.BreakBeforeInheritanceComma = true;
-
-  verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreak);
-  verifyFormat("class MyClass\n"
-               "    : public X\n"
-               "    , public Y {};",
-               StyleWithInheritanceBreak);
-}
-
-TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
-  verifyFormat("class A {\n} a, b;");
-  verifyFormat("struct A {\n} a, b;");
-  verifyFormat("union A {\n} a;");
-}
-
-TEST_F(FormatTest, FormatsEnum) {
-  verifyFormat("enum {\n"
-               "  Zero,\n"
-               "  One = 1,\n"
-               "  Two = One + 1,\n"
-               "  Three = (One + Two),\n"
-               "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
-               "  Five = (One, Two, Three, Four, 5)\n"
-               "};");
-  verifyGoogleFormat("enum {\n"
-                     "  Zero,\n"
-                     "  One = 1,\n"
-                     "  Two = One + 1,\n"
-                     "  Three = (One + Two),\n"
-                     "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
-                     "  Five = (One, Two, Three, Four, 5)\n"
-                     "};");
-  verifyFormat("enum Enum {};");
-  verifyFormat("enum {};");
-  verifyFormat("enum X E {} d;");
-  verifyFormat("enum __attribute__((...)) E {} d;");
-  verifyFormat("enum __declspec__((...)) E {} d;");
-  verifyFormat("enum {\n"
-               "  Bar = Foo<int, int>::value\n"
-               "};",
-               getLLVMStyleWithColumns(30));
-
-  verifyFormat("enum ShortEnum { A, B, C };");
-  verifyGoogleFormat("enum ShortEnum { A, B, C };");
-
-  EXPECT_EQ("enum KeepEmptyLines {\n"
-            "  ONE,\n"
-            "\n"
-            "  TWO,\n"
-            "\n"
-            "  THREE\n"
-            "}",
-            format("enum KeepEmptyLines {\n"
-                   "  ONE,\n"
-                   "\n"
-                   "  TWO,\n"
-                   "\n"
-                   "\n"
-                   "  THREE\n"
-                   "}"));
-  verifyFormat("enum E { // comment\n"
-               "  ONE,\n"
-               "  TWO\n"
-               "};\n"
-               "int i;");
-  // Not enums.
-  verifyFormat("enum X f() {\n"
-               "  a();\n"
-               "  return 42;\n"
-               "}");
-  verifyFormat("enum X Type::f() {\n"
-               "  a();\n"
-               "  return 42;\n"
-               "}");
-  verifyFormat("enum ::X f() {\n"
-               "  a();\n"
-               "  return 42;\n"
-               "}");
-  verifyFormat("enum ns::X f() {\n"
-               "  a();\n"
-               "  return 42;\n"
-               "}");
-}
-
-TEST_F(FormatTest, FormatsEnumsWithErrors) {
-  verifyFormat("enum Type {\n"
-               "  One = 0; // These semicolons should be commas.\n"
-               "  Two = 1;\n"
-               "};");
-  verifyFormat("namespace n {\n"
-               "enum Type {\n"
-               "  One,\n"
-               "  Two, // missing };\n"
-               "  int i;\n"
-               "}\n"
-               "void g() {}");
-}
-
-TEST_F(FormatTest, FormatsEnumStruct) {
-  verifyFormat("enum struct {\n"
-               "  Zero,\n"
-               "  One = 1,\n"
-               "  Two = One + 1,\n"
-               "  Three = (One + Two),\n"
-               "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
-               "  Five = (One, Two, Three, Four, 5)\n"
-               "};");
-  verifyFormat("enum struct Enum {};");
-  verifyFormat("enum struct {};");
-  verifyFormat("enum struct X E {} d;");
-  verifyFormat("enum struct __attribute__((...)) E {} d;");
-  verifyFormat("enum struct __declspec__((...)) E {} d;");
-  verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
-}
-
-TEST_F(FormatTest, FormatsEnumClass) {
-  verifyFormat("enum class {\n"
-               "  Zero,\n"
-               "  One = 1,\n"
-               "  Two = One + 1,\n"
-               "  Three = (One + Two),\n"
-               "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
-               "  Five = (One, Two, Three, Four, 5)\n"
-               "};");
-  verifyFormat("enum class Enum {};");
-  verifyFormat("enum class {};");
-  verifyFormat("enum class X E {} d;");
-  verifyFormat("enum class __attribute__((...)) E {} d;");
-  verifyFormat("enum class __declspec__((...)) E {} d;");
-  verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
-}
-
-TEST_F(FormatTest, FormatsEnumTypes) {
-  verifyFormat("enum X : int {\n"
-               "  A, // Force multiple lines.\n"
-               "  B\n"
-               "};");
-  verifyFormat("enum X : int { A, B };");
-  verifyFormat("enum X : std::uint32_t { A, B };");
-}
-
-TEST_F(FormatTest, FormatsNSEnums) {
-  verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
-  verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
-                     "  // Information about someDecentlyLongValue.\n"
-                     "  someDecentlyLongValue,\n"
-                     "  // Information about anotherDecentlyLongValue.\n"
-                     "  anotherDecentlyLongValue,\n"
-                     "  // Information about aThirdDecentlyLongValue.\n"
-                     "  aThirdDecentlyLongValue\n"
-                     "};");
-  verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
-                     "  a = 1,\n"
-                     "  b = 2,\n"
-                     "  c = 3,\n"
-                     "};");
-  verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
-                     "  a = 1,\n"
-                     "  b = 2,\n"
-                     "  c = 3,\n"
-                     "};");
-  verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
-                     "  a = 1,\n"
-                     "  b = 2,\n"
-                     "  c = 3,\n"
-                     "};");
-}
-
-TEST_F(FormatTest, FormatsBitfields) {
-  verifyFormat("struct Bitfields {\n"
-               "  unsigned sClass : 8;\n"
-               "  unsigned ValueKind : 2;\n"
-               "};");
-  verifyFormat("struct A {\n"
-               "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
-               "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
-               "};");
-  verifyFormat("struct MyStruct {\n"
-               "  uchar data;\n"
-               "  uchar : 8;\n"
-               "  uchar : 8;\n"
-               "  uchar other;\n"
-               "};");
-}
-
-TEST_F(FormatTest, FormatsNamespaces) {
-  FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
-  LLVMWithNoNamespaceFix.FixNamespaceComments = false;
-
-  verifyFormat("namespace some_namespace {\n"
-               "class A {};\n"
-               "void f() { f(); }\n"
-               "}",
-               LLVMWithNoNamespaceFix);
-  verifyFormat("namespace {\n"
-               "class A {};\n"
-               "void f() { f(); }\n"
-               "}",
-               LLVMWithNoNamespaceFix);
-  verifyFormat("inline namespace X {\n"
-               "class A {};\n"
-               "void f() { f(); }\n"
-               "}",
-               LLVMWithNoNamespaceFix);
-  verifyFormat("using namespace some_namespace;\n"
-               "class A {};\n"
-               "void f() { f(); }",
-               LLVMWithNoNamespaceFix);
-
-  // This code is more common than we thought; if we
-  // layout this correctly the semicolon will go into
-  // its own line, which is undesirable.
-  verifyFormat("namespace {};",
-               LLVMWithNoNamespaceFix);
-  verifyFormat("namespace {\n"
-               "class A {};\n"
-               "};",
-               LLVMWithNoNamespaceFix);
-
-  verifyFormat("namespace {\n"
-               "int SomeVariable = 0; // comment\n"
-               "} // namespace",
-               LLVMWithNoNamespaceFix);
-  EXPECT_EQ("#ifndef HEADER_GUARD\n"
-            "#define HEADER_GUARD\n"
-            "namespace my_namespace {\n"
-            "int i;\n"
-            "} // my_namespace\n"
-            "#endif // HEADER_GUARD",
-            format("#ifndef HEADER_GUARD\n"
-                   " #define HEADER_GUARD\n"
-                   "   namespace my_namespace {\n"
-                   "int i;\n"
-                   "}    // my_namespace\n"
-                   "#endif    // HEADER_GUARD",
-                   LLVMWithNoNamespaceFix));
-
-  EXPECT_EQ("namespace A::B {\n"
-            "class C {};\n"
-            "}",
-            format("namespace A::B {\n"
-                   "class C {};\n"
-                   "}",
-                   LLVMWithNoNamespaceFix));
-
-  FormatStyle Style = getLLVMStyle();
-  Style.NamespaceIndentation = FormatStyle::NI_All;
-  EXPECT_EQ("namespace out {\n"
-            "  int i;\n"
-            "  namespace in {\n"
-            "    int i;\n"
-            "  } // namespace in\n"
-            "} // namespace out",
-            format("namespace out {\n"
-                   "int i;\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
-
-  Style.NamespaceIndentation = FormatStyle::NI_Inner;
-  EXPECT_EQ("namespace out {\n"
-            "int i;\n"
-            "namespace in {\n"
-            "  int i;\n"
-            "} // namespace in\n"
-            "} // namespace out",
-            format("namespace out {\n"
-                   "int i;\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
-}
-
-TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
-
-TEST_F(FormatTest, FormatsInlineASM) {
-  verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
-  verifyFormat("asm(\"nop\" ::: \"memory\");");
-  verifyFormat(
-      "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
-      "    \"cpuid\\n\\t\"\n"
-      "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
-      "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
-      "    : \"a\"(value));");
-  EXPECT_EQ(
-      "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
-      "  __asm {\n"
-      "        mov     edx,[that] // vtable in edx\n"
-      "        mov     eax,methodIndex\n"
-      "        call    [edx][eax*4] // stdcall\n"
-      "  }\n"
-      "}",
-      format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
-             "    __asm {\n"
-             "        mov     edx,[that] // vtable in edx\n"
-             "        mov     eax,methodIndex\n"
-             "        call    [edx][eax*4] // stdcall\n"
-             "    }\n"
-             "}"));
-  EXPECT_EQ("_asm {\n"
-            "  xor eax, eax;\n"
-            "  cpuid;\n"
-            "}",
-            format("_asm {\n"
-                   "  xor eax, eax;\n"
-                   "  cpuid;\n"
-                   "}"));
-  verifyFormat("void function() {\n"
-               "  // comment\n"
-               "  asm(\"\");\n"
-               "}");
-  EXPECT_EQ("__asm {\n"
-            "}\n"
-            "int i;",
-            format("__asm   {\n"
-                   "}\n"
-                   "int   i;"));
-}
-
-TEST_F(FormatTest, FormatTryCatch) {
-  verifyFormat("try {\n"
-               "  throw a * b;\n"
-               "} catch (int a) {\n"
-               "  // Do nothing.\n"
-               "} catch (...) {\n"
-               "  exit(42);\n"
-               "}");
-
-  // Function-level try statements.
-  verifyFormat("int f() try { return 4; } catch (...) {\n"
-               "  return 5;\n"
-               "}");
-  verifyFormat("class A {\n"
-               "  int a;\n"
-               "  A() try : a(0) {\n"
-               "  } catch (...) {\n"
-               "    throw;\n"
-               "  }\n"
-               "};\n");
-
-  // Incomplete try-catch blocks.
-  verifyIncompleteFormat("try {} catch (");
-}
-
-TEST_F(FormatTest, FormatSEHTryCatch) {
-  verifyFormat("__try {\n"
-               "  int a = b * c;\n"
-               "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
-               "  // Do nothing.\n"
-               "}");
-
-  verifyFormat("__try {\n"
-               "  int a = b * c;\n"
-               "} __finally {\n"
-               "  // Do nothing.\n"
-               "}");
-
-  verifyFormat("DEBUG({\n"
-               "  __try {\n"
-               "  } __finally {\n"
-               "  }\n"
-               "});\n");
-}
-
-TEST_F(FormatTest, IncompleteTryCatchBlocks) {
-  verifyFormat("try {\n"
-               "  f();\n"
-               "} catch {\n"
-               "  g();\n"
-               "}");
-  verifyFormat("try {\n"
-               "  f();\n"
-               "} catch (A a) MACRO(x) {\n"
-               "  g();\n"
-               "} catch (B b) MACRO(x) {\n"
-               "  g();\n"
-               "}");
-}
-
-TEST_F(FormatTest, FormatTryCatchBraceStyles) {
-  FormatStyle Style = getLLVMStyle();
-  for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
-                          FormatStyle::BS_WebKit}) {
-    Style.BreakBeforeBraces = BraceStyle;
-    verifyFormat("try {\n"
-                 "  // something\n"
-                 "} catch (...) {\n"
-                 "  // something\n"
-                 "}",
-                 Style);
-  }
-  Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
-  verifyFormat("try {\n"
-               "  // something\n"
-               "}\n"
-               "catch (...) {\n"
-               "  // something\n"
-               "}",
-               Style);
-  verifyFormat("__try {\n"
-               "  // something\n"
-               "}\n"
-               "__finally {\n"
-               "  // something\n"
-               "}",
-               Style);
-  verifyFormat("@try {\n"
-               "  // something\n"
-               "}\n"
-               "@finally {\n"
-               "  // something\n"
-               "}",
-               Style);
-  Style.BreakBeforeBraces = FormatStyle::BS_Allman;
-  verifyFormat("try\n"
-               "{\n"
-               "  // something\n"
-               "}\n"
-               "catch (...)\n"
-               "{\n"
-               "  // something\n"
-               "}",
-               Style);
-  Style.BreakBeforeBraces = FormatStyle::BS_GNU;
-  verifyFormat("try\n"
-               "  {\n"
-               "    // something\n"
-               "  }\n"
-               "catch (...)\n"
-               "  {\n"
-               "    // something\n"
-               "  }",
-               Style);
-  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
-  Style.BraceWrapping.BeforeCatch = true;
-  verifyFormat("try {\n"
-               "  // something\n"
-               "}\n"
-               "catch (...) {\n"
-               "  // something\n"
-               "}",
-               Style);
-}
-
-TEST_F(FormatTest, StaticInitializers) {
-  verifyFormat("static SomeClass SC = {1, 'a'};");
-
-  verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
-               "    100000000, "
-               "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
-
-  // Here, everything other than the "}" would fit on a line.
-  verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
-               "    10000000000000000000000000};");
-  EXPECT_EQ("S s = {a,\n"
-            "\n"
-            "       b};",
-            format("S s = {\n"
-                   "  a,\n"
-                   "\n"
-                   "  b\n"
-                   "};"));
-
-  // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
-  // line. However, the formatting looks a bit off and this probably doesn't
-  // happen often in practice.
-  verifyFormat("static int Variable[1] = {\n"
-               "    {1000000000000000000000000000000000000}};",
-               getLLVMStyleWithColumns(40));
-}
-
-TEST_F(FormatTest, DesignatedInitializers) {
-  verifyFormat("const struct A a = {.a = 1, .b = 2};");
-  verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
-               "                    .bbbbbbbbbb = 2,\n"
-               "                    .cccccccccc = 3,\n"
-               "                    .dddddddddd = 4,\n"
-               "                    .eeeeeeeeee = 5};");
-  verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
-               "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
-               "    .ccccccccccccccccccccccccccc = 3,\n"
-               "    .ddddddddddddddddddddddddddd = 4,\n"
-               "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
-
-  verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
-}
-
-TEST_F(FormatTest, NestedStaticInitializers) {
-  verifyFormat("static A x = {{{}}};\n");
-  verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
-               "               {init1, init2, init3, init4}}};",
-               getLLVMStyleWithColumns(50));
-
-  verifyFormat("somes Status::global_reps[3] = {\n"
-               "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
-               "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
-               "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
-               getLLVMStyleWithColumns(60));
-  verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
-                     "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
-                     "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
-                     "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
-  verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
-               "                  {rect.fRight - rect.fLeft, rect.fBottom - "
-               "rect.fTop}};");
-
-  verifyFormat(
-      "SomeArrayOfSomeType a = {\n"
-      "    {{1, 2, 3},\n"
-      "     {1, 2, 3},\n"
-      "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
-      "      333333333333333333333333333333},\n"
-      "     {1, 2, 3},\n"
-      "     {1, 2, 3}}};");
-  verifyFormat(
-      "SomeArrayOfSomeType a = {\n"
-      "    {{1, 2, 3}},\n"
-      "    {{1, 2, 3}},\n"
-      "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
-      "      333333333333333333333333333333}},\n"
-      "    {{1, 2, 3}},\n"
-      "    {{1, 2, 3}}};");
-
-  verifyFormat("struct {\n"
-               "  unsigned bit;\n"
-               "  const char *const name;\n"
-               "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
-               "                 {kOsWin, \"Windows\"},\n"
-               "                 {kOsLinux, \"Linux\"},\n"
-               "                 {kOsCrOS, \"Chrome OS\"}};");
-  verifyFormat("struct {\n"
-               "  unsigned bit;\n"
-               "  const char *const name;\n"
-               "} kBitsToOs[] = {\n"
-               "    {kOsMac, \"Mac\"},\n"
-               "    {kOsWin, \"Windows\"},\n"
-               "    {kOsLinux, \"Linux\"},\n"
-               "    {kOsCrOS, \"Chrome OS\"},\n"
-               "};");
-}
-
-TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
-  verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
-               "                      \\\n"
-               "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
-}
-
-TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
-  verifyFormat("virtual void write(ELFWriter *writerrr,\n"
-               "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
-
-  // Do break defaulted and deleted functions.
-  verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
-               "    default;",
-               getLLVMStyleWithColumns(40));
-  verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
-               "    delete;",
-               getLLVMStyleWithColumns(40));
-}
-
-TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
-  verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
-               getLLVMStyleWithColumns(40));
-  verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
-               getLLVMStyleWithColumns(40));
-  EXPECT_EQ("#define Q                              \\\n"
-            "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
-            "  \"aaaaaaaa.cpp\"",
-            format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
-                   getLLVMStyleWithColumns(40)));
-}
-
-TEST_F(FormatTest, UnderstandsLinePPDirective) {
-  EXPECT_EQ("# 123 \"A string literal\"",
-            format("   #     123    \"A string literal\""));
-}
-
-TEST_F(FormatTest, LayoutUnknownPPDirective) {
-  EXPECT_EQ("#;", format("#;"));
-  verifyFormat("#\n;\n;\n;");
-}
-
-TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
-  EXPECT_EQ("#line 42 \"test\"\n",
-            format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
-  EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
-                                    getLLVMStyleWithColumns(12)));
-}
-
-TEST_F(FormatTest, EndOfFileEndsPPDirective) {
-  EXPECT_EQ("#line 42 \"test\"",
-            format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
-  EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
-}
-
-TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
-  verifyFormat("#define A \\x20");
-  verifyFormat("#define A \\ x20");
-  EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
-  verifyFormat("#define A ''");
-  verifyFormat("#define A ''qqq");
-  verifyFormat("#define A `qqq");
-  verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
-  EXPECT_EQ("const char *c = STRINGIFY(\n"
-            "\\na : b);",
-            format("const char * c = STRINGIFY(\n"
-                   "\\na : b);"));
-
-  verifyFormat("a\r\\");
-  verifyFormat("a\v\\");
-  verifyFormat("a\f\\");
-}
-
-TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
-  verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
-  verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
-  verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
-  // FIXME: We never break before the macro name.
-  verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
-
-  verifyFormat("#define A A\n#define A A");
-  verifyFormat("#define A(X) A\n#define A A");
-
-  verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
-  verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
-}
-
-TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
-  EXPECT_EQ("// somecomment\n"
-            "#include \"a.h\"\n"
-            "#define A(  \\\n"
-            "    A, B)\n"
-            "#include \"b.h\"\n"
-            "// somecomment\n",
-            format("  // somecomment\n"
-                   "  #include \"a.h\"\n"
-                   "#define A(A,\\\n"
-                   "    B)\n"
-                   "    #include \"b.h\"\n"
-                   " // somecomment\n",
-                   getLLVMStyleWithColumns(13)));
-}
-
-TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
-
-TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
-  EXPECT_EQ("#define A    \\\n"
-            "  c;         \\\n"
-            "  e;\n"
-            "f;",
-            format("#define A c; e;\n"
-                   "f;",
-                   getLLVMStyleWithColumns(14)));
-}
-
-TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
-
-TEST_F(FormatTest, MacroDefinitionInsideStatement) {
-  EXPECT_EQ("int x,\n"
-            "#define A\n"
-            "    y;",
-            format("int x,\n#define A\ny;"));
-}
-
-TEST_F(FormatTest, HashInMacroDefinition) {
-  EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
-  verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
-  verifyFormat("#define A  \\\n"
-               "  {        \\\n"
-               "    f(#c); \\\n"
-               "  }",
-               getLLVMStyleWithColumns(11));
-
-  verifyFormat("#define A(X)         \\\n"
-               "  void function##X()",
-               getLLVMStyleWithColumns(22));
-
-  verifyFormat("#define A(a, b, c)   \\\n"
-               "  void a##b##c()",
-               getLLVMStyleWithColumns(22));
-
-  verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
-}
-
-TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
-  EXPECT_EQ("#define A (x)", format("#define A (x)"));
-  EXPECT_EQ("#define A(x)", format("#define A(x)"));
-}
-
-TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
-  EXPECT_EQ("#define A b;", format("#define A \\\n"
-                                   "          \\\n"
-                                   "  b;",
-                                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("#define A \\\n"
-            "          \\\n"
-            "  a;      \\\n"
-            "  b;",
-            format("#define A \\\n"
-                   "          \\\n"
-                   "  a;      \\\n"
-                   "  b;",
-                   getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("#define A \\\n"
-            "  a;      \\\n"
-            "          \\\n"
-            "  b;",
-            format("#define A \\\n"
-                   "  a;      \\\n"
-                   "          \\\n"
-                   "  b;",
-                   getLLVMStyleWithColumns(11)));
-}
-
-TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
-  verifyIncompleteFormat("#define A :");
-  verifyFormat("#define SOMECASES  \\\n"
-               "  case 1:          \\\n"
-               "  case 2\n",
-               getLLVMStyleWithColumns(20));
-  verifyFormat("#define MACRO(a) \\\n"
-               "  if (a)         \\\n"
-               "    f();         \\\n"
-               "  else           \\\n"
-               "    g()",
-               getLLVMStyleWithColumns(18));
-  verifyFormat("#define A template <typename T>");
-  verifyIncompleteFormat("#define STR(x) #x\n"
-                         "f(STR(this_is_a_string_literal{));");
-  verifyFormat("#pragma omp threadprivate( \\\n"
-               "    y)), // expected-warning",
-               getLLVMStyleWithColumns(28));
-  verifyFormat("#d, = };");
-  verifyFormat("#if \"a");
-  verifyIncompleteFormat("({\n"
-                         "#define b     \\\n"
-                         "  }           \\\n"
-                         "  a\n"
-                         "a",
-                         getLLVMStyleWithColumns(15));
-  verifyFormat("#define A     \\\n"
-               "  {           \\\n"
-               "    {\n"
-               "#define B     \\\n"
-               "  }           \\\n"
-               "  }",
-               getLLVMStyleWithColumns(15));
-  verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
-  verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
-  verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
-  verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
-}
-
-TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
-  verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
-  EXPECT_EQ("class A : public QObject {\n"
-            "  Q_OBJECT\n"
-            "\n"
-            "  A() {}\n"
-            "};",
-            format("class A  :  public QObject {\n"
-                   "     Q_OBJECT\n"
-                   "\n"
-                   "  A() {\n}\n"
-                   "}  ;"));
-  EXPECT_EQ("MACRO\n"
-            "/*static*/ int i;",
-            format("MACRO\n"
-                   " /*static*/ int   i;"));
-  EXPECT_EQ("SOME_MACRO\n"
-            "namespace {\n"
-            "void f();\n"
-            "} // namespace",
-            format("SOME_MACRO\n"
-                   "  namespace    {\n"
-                   "void   f(  );\n"
-                   "} // namespace"));
-  // Only if the identifier contains at least 5 characters.
-  EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
-  EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
-  // Only if everything is upper case.
-  EXPECT_EQ("class A : public QObject {\n"
-            "  Q_Object A() {}\n"
-            "};",
-            format("class A  :  public QObject {\n"
-                   "     Q_Object\n"
-                   "  A() {\n}\n"
-                   "}  ;"));
-
-  // Only if the next line can actually start an unwrapped line.
-  EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
-            format("SOME_WEIRD_LOG_MACRO\n"
-                   "<< SomeThing;"));
-
-  verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
-               "(n, buffers))\n",
-               getChromiumStyle(FormatStyle::LK_Cpp));
-}
-
-TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
-  EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
-            "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
-            "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
-            "class X {};\n"
-            "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
-            "int *createScopDetectionPass() { return 0; }",
-            format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
-                   "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
-                   "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
-                   "  class X {};\n"
-                   "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
-                   "  int *createScopDetectionPass() { return 0; }"));
-  // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
-  // braces, so that inner block is indented one level more.
-  EXPECT_EQ("int q() {\n"
-            "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
-            "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
-            "  IPC_END_MESSAGE_MAP()\n"
-            "}",
-            format("int q() {\n"
-                   "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
-                   "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
-                   "  IPC_END_MESSAGE_MAP()\n"
-                   "}"));
-
-  // Same inside macros.
-  EXPECT_EQ("#define LIST(L) \\\n"
-            "  L(A)          \\\n"
-            "  L(B)          \\\n"
-            "  L(C)",
-            format("#define LIST(L) \\\n"
-                   "  L(A) \\\n"
-                   "  L(B) \\\n"
-                   "  L(C)",
-                   getGoogleStyle()));
-
-  // These must not be recognized as macros.
-  EXPECT_EQ("int q() {\n"
-            "  f(x);\n"
-            "  f(x) {}\n"
-            "  f(x)->g();\n"
-            "  f(x)->*g();\n"
-            "  f(x).g();\n"
-            "  f(x) = x;\n"
-            "  f(x) += x;\n"
-            "  f(x) -= x;\n"
-            "  f(x) *= x;\n"
-            "  f(x) /= x;\n"
-            "  f(x) %= x;\n"
-            "  f(x) &= x;\n"
-            "  f(x) |= x;\n"
-            "  f(x) ^= x;\n"
-            "  f(x) >>= x;\n"
-            "  f(x) <<= x;\n"
-            "  f(x)[y].z();\n"
-            "  LOG(INFO) << x;\n"
-            "  ifstream(x) >> x;\n"
-            "}\n",
-            format("int q() {\n"
-                   "  f(x)\n;\n"
-                   "  f(x)\n {}\n"
-                   "  f(x)\n->g();\n"
-                   "  f(x)\n->*g();\n"
-                   "  f(x)\n.g();\n"
-                   "  f(x)\n = x;\n"
-                   "  f(x)\n += x;\n"
-                   "  f(x)\n -= x;\n"
-                   "  f(x)\n *= x;\n"
-                   "  f(x)\n /= x;\n"
-                   "  f(x)\n %= x;\n"
-                   "  f(x)\n &= x;\n"
-                   "  f(x)\n |= x;\n"
-                   "  f(x)\n ^= x;\n"
-                   "  f(x)\n >>= x;\n"
-                   "  f(x)\n <<= x;\n"
-                   "  f(x)\n[y].z();\n"
-                   "  LOG(INFO)\n << x;\n"
-                   "  ifstream(x)\n >> x;\n"
-                   "}\n"));
-  EXPECT_EQ("int q() {\n"
-            "  F(x)\n"
-            "  if (1) {\n"
-            "  }\n"
-            "  F(x)\n"
-            "  while (1) {\n"
-            "  }\n"
-            "  F(x)\n"
-            "  G(x);\n"
-            "  F(x)\n"
-            "  try {\n"
-            "    Q();\n"
-            "  } catch (...) {\n"
-            "  }\n"
-            "}\n",
-            format("int q() {\n"
-                   "F(x)\n"
-                   "if (1) {}\n"
-                   "F(x)\n"
-                   "while (1) {}\n"
-                   "F(x)\n"
-                   "G(x);\n"
-                   "F(x)\n"
-                   "try { Q(); } catch (...) {}\n"
-                   "}\n"));
-  EXPECT_EQ("class A {\n"
-            "  A() : t(0) {}\n"
-            "  A(int i) noexcept() : {}\n"
-            "  A(X x)\n" // FIXME: function-level try blocks are broken.
-            "  try : t(0) {\n"
-            "  } catch (...) {\n"
-            "  }\n"
-            "};",
-            format("class A {\n"
-                   "  A()\n : t(0) {}\n"
-                   "  A(int i)\n noexcept() : {}\n"
-                   "  A(X x)\n"
-                   "  try : t(0) {} catch (...) {}\n"
-                   "};"));
-  EXPECT_EQ("class SomeClass {\n"
-            "public:\n"
-            "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
-            "};",
-            format("class SomeClass {\n"
-                   "public:\n"
-                   "  SomeClass()\n"
-                   "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
-                   "};"));
-  EXPECT_EQ("class SomeClass {\n"
-            "public:\n"
-            "  SomeClass()\n"
-            "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
-            "};",
-            format("class SomeClass {\n"
-                   "public:\n"
-                   "  SomeClass()\n"
-                   "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
-                   "};",
-                   getLLVMStyleWithColumns(40)));
-
-  verifyFormat("MACRO(>)");
-}
-
-TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
-  verifyFormat("#define A \\\n"
-               "  f({     \\\n"
-               "    g();  \\\n"
-               "  });",
-               getLLVMStyleWithColumns(11));
-}
-
-TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
-  EXPECT_EQ("{\n  {\n#define A\n  }\n}", format("{{\n#define A\n}}"));
-}
-
-TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
-  verifyFormat("{\n  { a #c; }\n}");
-}
-
-TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
-  EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
-            format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
-            format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
-}
-
-TEST_F(FormatTest, EscapedNewlines) {
-  EXPECT_EQ(
-      "#define A \\\n  int i;  \\\n  int j;",
-      format("#define A \\\nint i;\\\n  int j;", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
-  EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
-  EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
-  EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
-}
-
-TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
-  verifyFormat("#define A \\\n"
-               "  int v(  \\\n"
-               "      a); \\\n"
-               "  int i;",
-               getLLVMStyleWithColumns(11));
-}
-
-TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
-  EXPECT_EQ(
-      "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
-      "                      \\\n"
-      "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
-      "\n"
-      "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
-      "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
-      format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
-             "\\\n"
-             "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
-             "  \n"
-             "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
-             "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
-}
-
-TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
-  EXPECT_EQ("int\n"
-            "#define A\n"
-            "    a;",
-            format("int\n#define A\na;"));
-  verifyFormat("functionCallTo(\n"
-               "    someOtherFunction(\n"
-               "        withSomeParameters, whichInSequence,\n"
-               "        areLongerThanALine(andAnotherCall,\n"
-               "#define A B\n"
-               "                           withMoreParamters,\n"
-               "                           whichStronglyInfluenceTheLayout),\n"
-               "        andMoreParameters),\n"
-               "    trailing);",
-               getLLVMStyleWithColumns(69));
-  verifyFormat("Foo::Foo()\n"
-               "#ifdef BAR\n"
-               "    : baz(0)\n"
-               "#endif\n"
-               "{\n"
-               "}");
-  verifyFormat("void f() {\n"
-               "  if (true)\n"
-               "#ifdef A\n"
-               "    f(42);\n"
-               "  x();\n"
-               "#else\n"
-               "    g();\n"
-               "  x();\n"
-               "#endif\n"
-               "}");
-  verifyFormat("void f(param1, param2,\n"
-               "       param3,\n"
-               "#ifdef A\n"
-               "       param4(param5,\n"
-               "#ifdef A1\n"
-               "              param6,\n"
-               "#ifdef A2\n"
-               "              param7),\n"
-               "#else\n"
-               "              param8),\n"
-               "       param9,\n"
-               "#endif\n"
-               "       param10,\n"
-               "#endif\n"
-               "       param11)\n"
-               "#else\n"
-               "       param12)\n"
-               "#endif\n"
-               "{\n"
-               "  x();\n"
-               "}",
-               getLLVMStyleWithColumns(28));
-  verifyFormat("#if 1\n"
-               "int i;");
-  verifyFormat("#if 1\n"
-               "#endif\n"
-               "#if 1\n"
-               "#else\n"
-               "#endif\n");
-  verifyFormat("DEBUG({\n"
-               "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
-               "});\n"
-               "#if a\n"
-               "#else\n"
-               "#endif");
-
-  verifyIncompleteFormat("void f(\n"
-                         "#if A\n"
-                         "    );\n"
-                         "#else\n"
-                         "#endif");
-}
-
-TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
-  verifyFormat("#endif\n"
-               "#if B");
-}
-
-TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
-  FormatStyle SingleLine = getLLVMStyle();
-  SingleLine.AllowShortIfStatementsOnASingleLine = true;
-  verifyFormat("#if 0\n"
-               "#elif 1\n"
-               "#endif\n"
-               "void foo() {\n"
-               "  if (test) foo2();\n"
-               "}",
-               SingleLine);
-}
-
-TEST_F(FormatTest, LayoutBlockInsideParens) {
-  verifyFormat("functionCall({ int i; });");
-  verifyFormat("functionCall({\n"
-               "  int i;\n"
-               "  int j;\n"
-               "});");
-  verifyFormat("functionCall(\n"
-               "    {\n"
-               "      int i;\n"
-               "      int j;\n"
-               "    },\n"
-               "    aaaa, bbbb, cccc);");
-  verifyFormat("functionA(functionB({\n"
-               "            int i;\n"
-               "            int j;\n"
-               "          }),\n"
-               "          aaaa, bbbb, cccc);");
-  verifyFormat("functionCall(\n"
-               "    {\n"
-               "      int i;\n"
-               "      int j;\n"
-               "    },\n"
-               "    aaaa, bbbb, // comment\n"
-               "    cccc);");
-  verifyFormat("functionA(functionB({\n"
-               "            int i;\n"
-               "            int j;\n"
-               "          }),\n"
-               "          aaaa, bbbb, // comment\n"
-               "          cccc);");
-  verifyFormat("functionCall(aaaa, bbbb, { int i; });");
-  verifyFormat("functionCall(aaaa, bbbb, {\n"
-               "  int i;\n"
-               "  int j;\n"
-               "});");
-  verifyFormat(
-      "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
-      "    {\n"
-      "      int i; // break\n"
-      "    },\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
-      "                                     ccccccccccccccccc));");
-  verifyFormat("DEBUG({\n"
-               "  if (a)\n"
-               "    f();\n"
-               "});");
-}
-
-TEST_F(FormatTest, LayoutBlockInsideStatement) {
-  EXPECT_EQ("SOME_MACRO { int i; }\n"
-            "int i;",
-            format("  SOME_MACRO  {int i;}  int i;"));
-}
-
-TEST_F(FormatTest, LayoutNestedBlocks) {
-  verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
-               "  struct s {\n"
-               "    int i;\n"
-               "  };\n"
-               "  s kBitsToOs[] = {{10}};\n"
-               "  for (int i = 0; i < 10; ++i)\n"
-               "    return;\n"
-               "}");
-  verifyFormat("call(parameter, {\n"
-               "  something();\n"
-               "  // Comment using all columns.\n"
-               "  somethingelse();\n"
-               "});",
-               getLLVMStyleWithColumns(40));
-  verifyFormat("DEBUG( //\n"
-               "    { f(); }, a);");
-  verifyFormat("DEBUG( //\n"
-               "    {\n"
-               "      f(); //\n"
-               "    },\n"
-               "    a);");
-
-  EXPECT_EQ("call(parameter, {\n"
-            "  something();\n"
-            "  // Comment too\n"
-            "  // looooooooooong.\n"
-            "  somethingElse();\n"
-            "});",
-            format("call(parameter, {\n"
-                   "  something();\n"
-                   "  // Comment too looooooooooong.\n"
-                   "  somethingElse();\n"
-                   "});",
-                   getLLVMStyleWithColumns(29)));
-  EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
-  EXPECT_EQ("DEBUG({ // comment\n"
-            "  int i;\n"
-            "});",
-            format("DEBUG({ // comment\n"
-                   "int  i;\n"
-                   "});"));
-  EXPECT_EQ("DEBUG({\n"
-            "  int i;\n"
-            "\n"
-            "  // comment\n"
-            "  int j;\n"
-            "});",
-            format("DEBUG({\n"
-                   "  int  i;\n"
-                   "\n"
-                   "  // comment\n"
-                   "  int  j;\n"
-                   "});"));
-
-  verifyFormat("DEBUG({\n"
-               "  if (a)\n"
-               "    return;\n"
-               "});");
-  verifyGoogleFormat("DEBUG({\n"
-                     "  if (a) return;\n"
-                     "});");
-  FormatStyle Style = getGoogleStyle();
-  Style.ColumnLimit = 45;
-  verifyFormat("Debug(aaaaa,\n"
-               "      {\n"
-               "        if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
-               "      },\n"
-               "      a);",
-               Style);
-
-  verifyFormat("SomeFunction({MACRO({ return output; }), b});");
-
-  verifyNoCrash("^{v^{a}}");
-}
-
-TEST_F(FormatTest, FormatNestedBlocksInMacros) {
-  EXPECT_EQ("#define MACRO()                     \\\n"
-            "  Debug(aaa, /* force line break */ \\\n"
-            "        {                           \\\n"
-            "          int i;                    \\\n"
-            "          int j;                    \\\n"
-            "        })",
-            format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
-                   "          {  int   i;  int  j;   })",
-                   getGoogleStyle()));
-
-  EXPECT_EQ("#define A                                       \\\n"
-            "  [] {                                          \\\n"
-            "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
-            "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
-            "  }",
-            format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
-                   "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
-                   getGoogleStyle()));
-}
-
-TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
-  EXPECT_EQ("{}", format("{}"));
-  verifyFormat("enum E {};");
-  verifyFormat("enum E {}");
-}
-
-TEST_F(FormatTest, FormatBeginBlockEndMacros) {
-  FormatStyle Style = getLLVMStyle();
-  Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
-  Style.MacroBlockEnd = "^[A-Z_]+_END$";
-  verifyFormat("FOO_BEGIN\n"
-               "  FOO_ENTRY\n"
-               "FOO_END", Style);
-  verifyFormat("FOO_BEGIN\n"
-               "  NESTED_FOO_BEGIN\n"
-               "    NESTED_FOO_ENTRY\n"
-               "  NESTED_FOO_END\n"
-               "FOO_END", Style);
-  verifyFormat("FOO_BEGIN(Foo, Bar)\n"
-               "  int x;\n"
-               "  x = 1;\n"
-               "FOO_END(Baz)", Style);
-}
-
-//===----------------------------------------------------------------------===//
-// Line break tests.
-//===----------------------------------------------------------------------===//
-
-TEST_F(FormatTest, PreventConfusingIndents) {
-  verifyFormat(
-      "void f() {\n"
-      "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
-      "                         parameter, parameter, parameter)),\n"
-      "                     SecondLongCall(parameter));\n"
-      "}");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
-      "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
-  verifyFormat("int a = bbbb && ccc &&\n"
-               "        fffff(\n"
-               "#define A Just forcing a new line\n"
-               "            ddd);");
-}
-
-TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
-  verifyFormat(
-      "bool aaaaaaa =\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
-      "    bbbbbbbb();");
-  verifyFormat(
-      "bool aaaaaaa =\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
-      "    bbbbbbbb();");
-
-  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
-               "    ccccccccc == ddddddddddd;");
-  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
-               "    ccccccccc == ddddddddddd;");
-  verifyFormat(
-      "bool aaaaaaaaaaaaaaaaaaaaa =\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
-      "    ccccccccc == ddddddddddd;");
-
-  verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
-               "                 aaaaaa) &&\n"
-               "         bbbbbb && cccccc;");
-  verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
-               "                 aaaaaa) >>\n"
-               "         bbbbbb;");
-  verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
-               "    SourceMgr.getSpellingColumnNumber(\n"
-               "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
-               "    1);");
-
-  verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
-               "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
-               "    cccccc) {\n}");
-  verifyFormat("b = a &&\n"
-               "    // Comment\n"
-               "    b.c && d;");
-
-  // If the LHS of a comparison is not a binary expression itself, the
-  // additional linebreak confuses many people.
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
-      "}");
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
-      "}");
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
-      "}");
-  // Even explicit parentheses stress the precedence enough to make the
-  // additional break unnecessary.
-  verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
-               "}");
-  // This cases is borderline, but with the indentation it is still readable.
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
-      "}",
-      getLLVMStyleWithColumns(75));
-
-  // If the LHS is a binary expression, we should still use the additional break
-  // as otherwise the formatting hides the operator precedence.
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
-               "    5) {\n"
-               "}");
-
-  FormatStyle OnePerLine = getLLVMStyle();
-  OnePerLine.BinPackParameters = false;
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
-      OnePerLine);
-
-  verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
-               "                .aaa(aaaaaaaaaaaaa) *\n"
-               "            aaaaaaa +\n"
-               "        aaaaaaa;",
-               getLLVMStyleWithColumns(40));
-}
-
-TEST_F(FormatTest, ExpressionIndentation) {
-  verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
-               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
-               "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
-               "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
-               "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
-               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
-               "                 ccccccccccccccccccccccccccccccccccccccccc;");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
-               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
-               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
-               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
-               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
-               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
-  verifyFormat("if () {\n"
-               "} else if (aaaaa && bbbbb > // break\n"
-               "                        ccccc) {\n"
-               "}");
-  verifyFormat("if () {\n"
-               "} else if (aaaaa &&\n"
-               "           bbbbb > // break\n"
-               "               ccccc &&\n"
-               "           ddddd) {\n"
-               "}");
-
-  // Presence of a trailing comment used to change indentation of b.
-  verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
-               "       b;\n"
-               "return aaaaaaaaaaaaaaaaaaa +\n"
-               "       b; //",
-               getLLVMStyleWithColumns(30));
-}
-
-TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
-  // Not sure what the best system is here. Like this, the LHS can be found
-  // immediately above an operator (everything with the same or a higher
-  // indent). The RHS is aligned right of the operator and so compasses
-  // everything until something with the same indent as the operator is found.
-  // FIXME: Is this a good system?
-  FormatStyle Style = getLLVMStyle();
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  verifyFormat(
-      "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-      "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-      "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                    > ccccccccccccccccccccccccccccccccccccccccc;",
-      Style);
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
-               Style);
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
-               Style);
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
-               Style);
-  verifyFormat("if () {\n"
-               "} else if (aaaaa\n"
-               "           && bbbbb // break\n"
-               "                  > ccccc) {\n"
-               "}",
-               Style);
-  verifyFormat("return (a)\n"
-               "       // comment\n"
-               "       + b;",
-               Style);
-  verifyFormat(
-      "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-      "             + cc;",
-      Style);
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
-               Style);
-
-  // Forced by comments.
-  verifyFormat(
-      "unsigned ContentSize =\n"
-      "    sizeof(int16_t)   // DWARF ARange version number\n"
-      "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
-      "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
-      "    + sizeof(int8_t); // Segment Size (in bytes)");
-
-  verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
-               "       == boost::fusion::at_c<1>(iiii).second;",
-               Style);
-
-  Style.ColumnLimit = 60;
-  verifyFormat("zzzzzzzzzz\n"
-               "    = bbbbbbbbbbbbbbbbb\n"
-               "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               Style);
-}
-
-TEST_F(FormatTest, EnforcedOperatorWraps) {
-  // Here we'd like to wrap after the || operators, but a comment is forcing an
-  // earlier wrap.
-  verifyFormat("bool x = aaaaa //\n"
-               "         || bbbbb\n"
-               "         //\n"
-               "         || cccc;");
-}
-
-TEST_F(FormatTest, NoOperandAlignment) {
-  FormatStyle Style = getLLVMStyle();
-  Style.AlignOperands = false;
-  verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
-               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               Style);
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
-  verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-               "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-               "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        > ccccccccccccccccccccccccccccccccccccccccc;",
-               Style);
-
-  verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-               "    + cc;",
-               Style);
-  verifyFormat("int a = aa\n"
-               "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-               "        * cccccccccccccccccccccccccccccccccccc;\n",
-               Style);
-
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  verifyFormat("return (a > b\n"
-               "    // comment1\n"
-               "    // comment2\n"
-               "    || c);",
-               Style);
-}
-
-TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
-  FormatStyle Style = getLLVMStyle();
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
-  verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
-               Style);
-}
-
-TEST_F(FormatTest, ConstructorInitializers) {
-  verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
-  verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
-               getLLVMStyleWithColumns(45));
-  verifyFormat("Constructor()\n"
-               "    : Inttializer(FitsOnTheLine) {}",
-               getLLVMStyleWithColumns(44));
-  verifyFormat("Constructor()\n"
-               "    : Inttializer(FitsOnTheLine) {}",
-               getLLVMStyleWithColumns(43));
-
-  verifyFormat("template <typename T>\n"
-               "Constructor() : Initializer(FitsOnTheLine) {}",
-               getLLVMStyleWithColumns(45));
-
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
-
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-      "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-      "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
-  verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    : aaaaaaaaaa(aaaaaa) {}");
-
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
-
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
-
-  verifyFormat("Constructor(int Parameter = 0)\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
-               "}",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
-
-  // Here a line could be saved by splitting the second initializer onto two
-  // lines, but that is not desirable.
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
-
-  FormatStyle OnePerLine = getLLVMStyle();
-  OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
-  OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
-               OnePerLine);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
-               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
-               OnePerLine);
-  verifyFormat("MyClass::MyClass(int var)\n"
-               "    : some_var_(var),            // 4 space indent\n"
-               "      some_other_var_(var + 1) { // lined up\n"
-               "}",
-               OnePerLine);
-  verifyFormat("Constructor()\n"
-               "    : aaaaa(aaaaaa),\n"
-               "      aaaaa(aaaaaa),\n"
-               "      aaaaa(aaaaaa),\n"
-               "      aaaaa(aaaaaa),\n"
-               "      aaaaa(aaaaaa) {}",
-               OnePerLine);
-  verifyFormat("Constructor()\n"
-               "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
-               "            aaaaaaaaaaaaaaaaaaaaaa) {}",
-               OnePerLine);
-  OnePerLine.BinPackParameters = false;
-  verifyFormat(
-      "Constructor()\n"
-      "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "          aaaaaaaaaaa().aaa(),\n"
-      "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-      OnePerLine);
-  OnePerLine.ColumnLimit = 60;
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
-               "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
-               OnePerLine);
-
-  EXPECT_EQ("Constructor()\n"
-            "    : // Comment forcing unwanted break.\n"
-            "      aaaa(aaaa) {}",
-            format("Constructor() :\n"
-                   "    // Comment forcing unwanted break.\n"
-                   "    aaaa(aaaa) {}"));
-}
-
-TEST_F(FormatTest, MemoizationTests) {
-  // This breaks if the memoization lookup does not take \c Indent and
-  // \c LastSpace into account.
-  verifyFormat(
-      "extern CFRunLoopTimerRef\n"
-      "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
-      "                     CFTimeInterval interval, CFOptionFlags flags,\n"
-      "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
-      "                     CFRunLoopTimerContext *context) {}");
-
-  // Deep nesting somewhat works around our memoization.
-  verifyFormat(
-      "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
-      "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
-      "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
-      "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
-      "                aaaaa())))))))))))))))))))))))))))))))))))))));",
-      getLLVMStyleWithColumns(65));
-  verifyFormat(
-      "aaaaa(\n"
-      "    aaaaa,\n"
-      "    aaaaa(\n"
-      "        aaaaa,\n"
-      "        aaaaa(\n"
-      "            aaaaa,\n"
-      "            aaaaa(\n"
-      "                aaaaa,\n"
-      "                aaaaa(\n"
-      "                    aaaaa,\n"
-      "                    aaaaa(\n"
-      "                        aaaaa,\n"
-      "                        aaaaa(\n"
-      "                            aaaaa,\n"
-      "                            aaaaa(\n"
-      "                                aaaaa,\n"
-      "                                aaaaa(\n"
-      "                                    aaaaa,\n"
-      "                                    aaaaa(\n"
-      "                                        aaaaa,\n"
-      "                                        aaaaa(\n"
-      "                                            aaaaa,\n"
-      "                                            aaaaa(\n"
-      "                                                aaaaa,\n"
-      "                                                aaaaa))))))))))));",
-      getLLVMStyleWithColumns(65));
-  verifyFormat(
-      "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
-      "                                  a),\n"
-      "                                a),\n"
-      "                              a),\n"
-      "                            a),\n"
-      "                          a),\n"
-      "                        a),\n"
-      "                      a),\n"
-      "                    a),\n"
-      "                  a),\n"
-      "                a),\n"
-      "              a),\n"
-      "            a),\n"
-      "          a),\n"
-      "        a),\n"
-      "      a),\n"
-      "    a),\n"
-      "  a)",
-      getLLVMStyleWithColumns(65));
-
-  // This test takes VERY long when memoization is broken.
-  FormatStyle OnePerLine = getLLVMStyle();
-  OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
-  OnePerLine.BinPackParameters = false;
-  std::string input = "Constructor()\n"
-                      "    : aaaa(a,\n";
-  for (unsigned i = 0, e = 80; i != e; ++i) {
-    input += "           a,\n";
-  }
-  input += "           a) {}";
-  verifyFormat(input, OnePerLine);
-}
-
-TEST_F(FormatTest, BreaksAsHighAsPossible) {
-  verifyFormat(
-      "void f() {\n"
-      "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
-      "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
-      "    f();\n"
-      "}");
-  verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
-               "    Intervals[i - 1].getRange().getLast()) {\n}");
-}
-
-TEST_F(FormatTest, BreaksFunctionDeclarations) {
-  // Principially, we break function declarations in a certain order:
-  // 1) break amongst arguments.
-  verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
-               "                              Cccccccccccccc cccccccccccccc);");
-  verifyFormat("template <class TemplateIt>\n"
-               "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
-               "                            TemplateIt *stop) {}");
-
-  // 2) break after return type.
-  verifyFormat(
-      "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
-      getGoogleStyle());
-
-  // 3) break after (.
-  verifyFormat(
-      "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
-      "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
-      getGoogleStyle());
-
-  // 4) break before after nested name specifiers.
-  verifyFormat(
-      "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
-      "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
-      getGoogleStyle());
-
-  // However, there are exceptions, if a sufficient amount of lines can be
-  // saved.
-  // FIXME: The precise cut-offs wrt. the number of saved lines might need some
-  // more adjusting.
-  verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
-               "                                  Cccccccccccccc cccccccccc,\n"
-               "                                  Cccccccccccccc cccccccccc,\n"
-               "                                  Cccccccccccccc cccccccccc,\n"
-               "                                  Cccccccccccccc cccccccccc);");
-  verifyFormat(
-      "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
-      "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
-      "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
-      getGoogleStyle());
-  verifyFormat(
-      "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
-      "                                          Cccccccccccccc cccccccccc,\n"
-      "                                          Cccccccccccccc cccccccccc,\n"
-      "                                          Cccccccccccccc cccccccccc,\n"
-      "                                          Cccccccccccccc cccccccccc,\n"
-      "                                          Cccccccccccccc cccccccccc,\n"
-      "                                          Cccccccccccccc cccccccccc);");
-  verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
-               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
-               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
-               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
-               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
-
-  // Break after multi-line parameters.
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "    bbbb bbbb);");
-  verifyFormat("void SomeLoooooooooooongFunction(\n"
-               "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "    int bbbbbbbbbbbbb);");
-
-  // Treat overloaded operators like other functions.
-  verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
-               "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
-  verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
-               "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
-  verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
-               "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
-  verifyGoogleFormat(
-      "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
-      "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
-  verifyGoogleFormat(
-      "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
-      "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
-               "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
-  verifyGoogleFormat(
-      "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
-      "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
-  verifyGoogleFormat(
-      "template <typename T>\n"
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
-
-  FormatStyle Style = getLLVMStyle();
-  Style.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
-               Style);
-  verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
-               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-               Style);
-}
-
-TEST_F(FormatTest, TrailingReturnType) {
-  verifyFormat("auto foo() -> int;\n");
-  verifyFormat("struct S {\n"
-               "  auto bar() const -> int;\n"
-               "};");
-  verifyFormat("template <size_t Order, typename T>\n"
-               "auto load_img(const std::string &filename)\n"
-               "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
-  verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
-               "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
-  verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
-  verifyFormat("template <typename T>\n"
-               "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
-               "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
-
-  // Not trailing return types.
-  verifyFormat("void f() { auto a = b->c(); }");
-}
-
-TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
-  // Avoid breaking before trailing 'const' or other trailing annotations, if
-  // they are not function-like.
-  FormatStyle Style = getGoogleStyle();
-  Style.ColumnLimit = 47;
-  verifyFormat("void someLongFunction(\n"
-               "    int someLoooooooooooooongParameter) const {\n}",
-               getLLVMStyleWithColumns(47));
-  verifyFormat("LoooooongReturnType\n"
-               "someLoooooooongFunction() const {}",
-               getLLVMStyleWithColumns(47));
-  verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
-               "    const {}",
-               Style);
-  verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
-               "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
-  verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
-               "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
-  verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
-               "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
-  verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
-               "                   aaaaaaaaaaa aaaaa) const override;");
-  verifyGoogleFormat(
-      "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-      "    const override;");
-
-  // Even if the first parameter has to be wrapped.
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) const {}",
-               getLLVMStyleWithColumns(46));
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) const {}",
-               Style);
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) override {}",
-               Style);
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) OVERRIDE {}",
-               Style);
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) final {}",
-               Style);
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) FINAL {}",
-               Style);
-  verifyFormat("void someLongFunction(\n"
-               "    int parameter) const override {}",
-               Style);
-
-  Style.BreakBeforeBraces = FormatStyle::BS_Allman;
-  verifyFormat("void someLongFunction(\n"
-               "    int someLongParameter) const\n"
-               "{\n"
-               "}",
-               Style);
-
-  // Unless these are unknown annotations.
-  verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
-               "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    LONG_AND_UGLY_ANNOTATION;");
-
-  // Breaking before function-like trailing annotations is fine to keep them
-  // close to their arguments.
-  verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
-  verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
-               "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
-  verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
-               "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
-  verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
-                     "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
-  verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
-
-  verifyFormat(
-      "void aaaaaaaaaaaaaaaaaa()\n"
-      "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
-  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    __attribute__((unused));");
-  verifyGoogleFormat(
-      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    GUARDED_BY(aaaaaaaaaaaa);");
-  verifyGoogleFormat(
-      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    GUARDED_BY(aaaaaaaaaaaa);");
-  verifyGoogleFormat(
-      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
-      "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyGoogleFormat(
-      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
-}
-
-TEST_F(FormatTest, FunctionAnnotations) {
-  verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
-               "int OldFunction(const string &parameter) {}");
-  verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
-               "string OldFunction(const string &parameter) {}");
-  verifyFormat("template <typename T>\n"
-               "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
-               "string OldFunction(const string &parameter) {}");
-
-  // Not function annotations.
-  verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-  verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
-               "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
-  verifyFormat("MACRO(abc).function() // wrap\n"
-               "    << abc;");
-  verifyFormat("MACRO(abc)->function() // wrap\n"
-               "    << abc;");
-  verifyFormat("MACRO(abc)::function() // wrap\n"
-               "    << abc;");
-}
-
-TEST_F(FormatTest, BreaksDesireably) {
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
-               "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
-               "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
-               "}");
-
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
-
-  verifyFormat(
-      "aaaaaaaa(aaaaaaaaaaaaa,\n"
-      "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
-      "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
-               "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat(
-      "void f() {\n"
-      "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
-      "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
-      "}");
-  verifyFormat(
-      "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
-  verifyFormat(
-      "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
-  verifyFormat(
-      "aaaaaa(aaa,\n"
-      "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-      "       aaaa);");
-  verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-               "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  // Indent consistently independent of call expression and unary operator.
-  verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
-               "    dddddddddddddddddddddddddddddd));");
-  verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
-               "    dddddddddddddddddddddddddddddd));");
-  verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
-               "    dddddddddddddddddddddddddddddd));");
-
-  // This test case breaks on an incorrect memoization, i.e. an optimization not
-  // taking into account the StopAt value.
-  verifyFormat(
-      "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
-      "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
-      "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
-      "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat("{\n  {\n    {\n"
-               "      Annotation.SpaceRequiredBefore =\n"
-               "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
-               "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
-               "    }\n  }\n}");
-
-  // Break on an outer level if there was a break on an inner level.
-  EXPECT_EQ("f(g(h(a, // comment\n"
-            "      b, c),\n"
-            "    d, e),\n"
-            "  x, y);",
-            format("f(g(h(a, // comment\n"
-                   "    b, c), d, e), x, y);"));
-
-  // Prefer breaking similar line breaks.
-  verifyFormat(
-      "const int kTrackingOptions = NSTrackingMouseMoved |\n"
-      "                             NSTrackingMouseEnteredAndExited |\n"
-      "                             NSTrackingActiveAlways;");
-}
-
-TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
-  FormatStyle NoBinPacking = getGoogleStyle();
-  NoBinPacking.BinPackParameters = false;
-  NoBinPacking.BinPackArguments = true;
-  verifyFormat("void f() {\n"
-               "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
-               "}",
-               NoBinPacking);
-  verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
-               "       int aaaaaaaaaaaaaaaaaaaa,\n"
-               "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-               NoBinPacking);
-
-  NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
-  verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                        vector<int> bbbbbbbbbbbbbbb);",
-               NoBinPacking);
-  // FIXME: This behavior difference is probably not wanted. However, currently
-  // we cannot distinguish BreakBeforeParameter being set because of the wrapped
-  // template arguments from BreakBeforeParameter being set because of the
-  // one-per-line formatting.
-  verifyFormat(
-      "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                                             aaaaaaaaaa> aaaaaaaaaa);",
-      NoBinPacking);
-  verifyFormat(
-      "void fffffffffff(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
-      "        aaaaaaaaaa);");
-}
-
-TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
-  FormatStyle NoBinPacking = getGoogleStyle();
-  NoBinPacking.BinPackParameters = false;
-  NoBinPacking.BinPackArguments = false;
-  verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
-               "  aaaaaaaaaaaaaaaaaaaa,\n"
-               "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
-               NoBinPacking);
-  verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
-               "        aaaaaaaaaaaaa,\n"
-               "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
-               NoBinPacking);
-  verifyFormat(
-      "aaaaaaaa(aaaaaaaaaaaaa,\n"
-      "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
-      "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
-      NoBinPacking);
-  verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaaaaaaaaaaaaaaaaa();",
-               NoBinPacking);
-  verifyFormat("void f() {\n"
-               "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
-               "}",
-               NoBinPacking);
-
-  verifyFormat(
-      "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "             aaaaaaaaaaaa,\n"
-      "             aaaaaaaaaaaa);",
-      NoBinPacking);
-  verifyFormat(
-      "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
-      "                               ddddddddddddddddddddddddddddd),\n"
-      "             test);",
-      NoBinPacking);
-
-  verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
-               "    aaaaaaaaaaaaaaaaaa;",
-               NoBinPacking);
-  verifyFormat("a(\"a\"\n"
-               "  \"a\",\n"
-               "  a);");
-
-  NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
-  verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
-               "                aaaaaaaaa,\n"
-               "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               NoBinPacking);
-  verifyFormat(
-      "void f() {\n"
-      "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
-      "      .aaaaaaa();\n"
-      "}",
-      NoBinPacking);
-  verifyFormat(
-      "template <class SomeType, class SomeOtherType>\n"
-      "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
-      NoBinPacking);
-}
-
-TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
-  FormatStyle Style = getLLVMStyleWithColumns(15);
-  Style.ExperimentalAutoDetectBinPacking = true;
-  EXPECT_EQ("aaa(aaaa,\n"
-            "    aaaa,\n"
-            "    aaaa);\n"
-            "aaa(aaaa,\n"
-            "    aaaa,\n"
-            "    aaaa);",
-            format("aaa(aaaa,\n" // one-per-line
-                   "  aaaa,\n"
-                   "    aaaa  );\n"
-                   "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
-                   Style));
-  EXPECT_EQ("aaa(aaaa, aaaa,\n"
-            "    aaaa);\n"
-            "aaa(aaaa, aaaa,\n"
-            "    aaaa);",
-            format("aaa(aaaa,  aaaa,\n" // bin-packed
-                   "    aaaa  );\n"
-                   "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
-                   Style));
-}
-
-TEST_F(FormatTest, FormatsBuilderPattern) {
-  verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
-               "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
-               "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
-               "    .StartsWith(\".init\", ORDER_INIT)\n"
-               "    .StartsWith(\".fini\", ORDER_FINI)\n"
-               "    .StartsWith(\".hash\", ORDER_HASH)\n"
-               "    .Default(ORDER_TEXT);\n");
-
-  verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
-               "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
-  verifyFormat(
-      "aaaaaaa->aaaaaaa\n"
-      "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-      "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaa->aaaaaaa\n"
-      "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-      "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
-      "    aaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
-      "    aaaaaa->aaaaaaaaaaaa()\n"
-      "        ->aaaaaaaaaaaaaaaa(\n"
-      "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-      "        ->aaaaaaaaaaaaaaaaa();");
-  verifyGoogleFormat(
-      "void f() {\n"
-      "  someo->Add((new util::filetools::Handler(dir))\n"
-      "                 ->OnEvent1(NewPermanentCallback(\n"
-      "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
-      "                 ->OnEvent2(NewPermanentCallback(\n"
-      "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
-      "                 ->OnEvent3(NewPermanentCallback(\n"
-      "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
-      "                 ->OnEvent5(NewPermanentCallback(\n"
-      "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
-      "                 ->OnEvent6(NewPermanentCallback(\n"
-      "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
-      "}");
-
-  verifyFormat(
-      "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
-  verifyFormat("aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa();");
-  verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa();");
-  verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaa();");
-  verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    ->aaaaaaaaaaaaaae(0)\n"
-               "    ->aaaaaaaaaaaaaaa();");
-
-  // Don't linewrap after very short segments.
-  verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat("aaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
-
-  // Prefer not to break after empty parentheses.
-  verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
-               "    First->LastNewlineOffset);");
-
-  // Prefer not to create "hanging" indents.
-  verifyFormat(
-      "return !soooooooooooooome_map\n"
-      "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-      "            .second;");
-  verifyFormat(
-      "return aaaaaaaaaaaaaaaa\n"
-      "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
-      "    .aaaa(aaaaaaaaaaaaaa);");
-  // No hanging indent here.
-  verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("aaaaaaaaaaaaaaaaaa\n"
-               "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               getLLVMStyleWithColumns(59));
-  verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-}
-
-TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
-      "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
-      "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
-
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
-               "    ccccccccccccccccccccccccc) {\n}");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
-               "    ccccccccccccccccccccccccc) {\n}");
-
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
-               "    ccccccccccccccccccccccccc) {\n}");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
-               "    ccccccccccccccccccccccccc) {\n}");
-
-  verifyFormat(
-      "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
-      "    ccccccccccccccccccccccccc) {\n}");
-  verifyFormat(
-      "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
-      "    ccccccccccccccccccccccccc) {\n}");
-
-  verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
-               "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
-               "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
-               "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
-  verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
-               "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
-               "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
-               "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
-
-  verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
-               "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
-               "    aaaaaaaaaaaaaaa != aa) {\n}");
-  verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
-               "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
-               "    aaaaaaaaaaaaaaa != aa) {\n}");
-}
-
-TEST_F(FormatTest, BreaksAfterAssignments) {
-  verifyFormat(
-      "unsigned Cost =\n"
-      "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
-      "                        SI->getPointerAddressSpaceee());\n");
-  verifyFormat(
-      "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
-      "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
-
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("unsigned OriginalStartColumn =\n"
-               "    SourceMgr.getSpellingColumnNumber(\n"
-               "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
-               "    1;");
-}
-
-TEST_F(FormatTest, AlignsAfterAssignments) {
-  verifyFormat(
-      "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
-}
-
-TEST_F(FormatTest, AlignsAfterReturn) {
-  verifyFormat(
-      "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
-      "       aaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat(
-      "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
-      "        aaaaaaaaaaaaaaaaaaaaaa());");
-  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat("return\n"
-               "    // true if code is one of a or b.\n"
-               "    code == a || code == b;");
-}
-
-TEST_F(FormatTest, AlignsAfterOpenBracket) {
-  verifyFormat(
-      "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
-      "                                                aaaaaaaaa aaaaaaa) {}");
-  verifyFormat(
-      "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
-      "                                               aaaaaaaaaaa aaaaaaaaa);");
-  verifyFormat(
-      "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
-      "                                             aaaaaaaaaaaaaaaaaaaaa));");
-  FormatStyle Style = getLLVMStyle();
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
-               Style);
-  verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
-               "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
-               Style);
-  verifyFormat("SomeLongVariableName->someFunction(\n"
-               "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
-               Style);
-  verifyFormat(
-      "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
-      "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-      Style);
-  verifyFormat(
-      "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
-      "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
-      Style);
-
-  verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
-               "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
-               "        b));",
-               Style);
-
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  Style.BinPackArguments = false;
-  Style.BinPackParameters = false;
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaa aaaaaaaa,\n"
-               "    aaaaaaaaa aaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
-               Style);
-  verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
-               "    aaaaaaaaaaa aaaaaaaaa,\n"
-               "    aaaaaaaaaaa aaaaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               Style);
-  verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
-               "    aaaaaaaaaaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
-               Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
-      Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
-      Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
-      "    aaaaaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
-      "    aaaaaaaaaaaaaaaa);",
-      Style);
-}
-
-TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
-  FormatStyle Style = getLLVMStyleWithColumns(40);
-  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
-               "          bbbbbbbbbbbbbbbbbbbbbb);",
-               Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
-  Style.AlignOperands = false;
-  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
-               "          bbbbbbbbbbbbbbbbbbbbbb);",
-               Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  Style.AlignOperands = true;
-  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
-               "          bbbbbbbbbbbbbbbbbbbbbb);",
-               Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  Style.AlignOperands = false;
-  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
-               "    bbbbbbbbbbbbbbbbbbbbbb);",
-               Style);
-}
-
-TEST_F(FormatTest, BreaksConditionalExpressions) {
-  verifyFormat(
-      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
-      "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaa(aaaaaaaaa, aaaaaaaaa,\n"
-      "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
-      "                                                    : aaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaa);");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaa);");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        : aaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    ? aaaaaaaaaaaaaaa\n"
-      "    : aaaaaaaaaaaaaaa;");
-  verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
-               "          aaaaaaaaa\n"
-               "      ? b\n"
-               "      : c);");
-  verifyFormat("return aaaa == bbbb\n"
-               "           // comment\n"
-               "           ? aaaa\n"
-               "           : bbbb;");
-  verifyFormat("unsigned Indent =\n"
-               "    format(TheLine.First,\n"
-               "           IndentForLevel[TheLine.Level] >= 0\n"
-               "               ? IndentForLevel[TheLine.Level]\n"
-               "               : TheLine * 2,\n"
-               "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
-               "                  ? aaaaaaaaaaaaaaa\n"
-               "                  : bbbbbbbbbbbbbbb //\n"
-               "                        ? ccccccccccccccc\n"
-               "                        : ddddddddddddddd;");
-  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
-               "                  ? aaaaaaaaaaaaaaa\n"
-               "                  : (bbbbbbbbbbbbbbb //\n"
-               "                         ? ccccccccccccccc\n"
-               "                         : ddddddddddddddd);");
-  verifyFormat(
-      "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
-      "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
-      "                                            aaaaaaaaaaaaaaaaaaaaa\n"
-      "                                      : aaaaaaaaaa;");
-  verifyFormat(
-      "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
-      "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-
-  FormatStyle NoBinPacking = getLLVMStyle();
-  NoBinPacking.BinPackArguments = false;
-  verifyFormat(
-      "void f() {\n"
-      "  g(aaa,\n"
-      "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "        ? aaaaaaaaaaaaaaa\n"
-      "        : aaaaaaaaaaaaaaa);\n"
-      "}",
-      NoBinPacking);
-  verifyFormat(
-      "void f() {\n"
-      "  g(aaa,\n"
-      "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "        ?: aaaaaaaaaaaaaaa);\n"
-      "}",
-      NoBinPacking);
-
-  verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
-               "             // comment.\n"
-               "             ccccccccccccccccccccccccccccccccccccccc\n"
-               "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
-
-  // Assignments in conditional expressions. Apparently not uncommon :-(.
-  verifyFormat("return a != b\n"
-               "           // comment\n"
-               "           ? a = b\n"
-               "           : a = b;");
-  verifyFormat("return a != b\n"
-               "           // comment\n"
-               "           ? a = a != b\n"
-               "                     // comment\n"
-               "                     ? a = b\n"
-               "                     : a\n"
-               "           : a;\n");
-  verifyFormat("return a != b\n"
-               "           // comment\n"
-               "           ? a\n"
-               "           : a = a != b\n"
-               "                     // comment\n"
-               "                     ? a = b\n"
-               "                     : a;");
-}
-
-TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
-  FormatStyle Style = getLLVMStyle();
-  Style.BreakBeforeTernaryOperators = false;
-  Style.ColumnLimit = 70;
-  verifyFormat(
-      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-      "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-      "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
-      "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-      "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-      "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaa(aaaaaaaa, aaaaaaaaaa,\n"
-      "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-      "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
-      "                                                      aaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-      "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaa);",
-      Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaa);",
-      Style);
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               Style);
-  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
-               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               Style);
-  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
-               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
-               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               Style);
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
-               Style);
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
-               Style);
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-      "    aaaaaaaaaaaaaaa :\n"
-      "    aaaaaaaaaaaaaaa;",
-      Style);
-  verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
-               "          aaaaaaaaa ?\n"
-               "      b :\n"
-               "      c);",
-               Style);
-  verifyFormat("unsigned Indent =\n"
-               "    format(TheLine.First,\n"
-               "           IndentForLevel[TheLine.Level] >= 0 ?\n"
-               "               IndentForLevel[TheLine.Level] :\n"
-               "               TheLine * 2,\n"
-               "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
-               Style);
-  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
-               "                  aaaaaaaaaaaaaaa :\n"
-               "                  bbbbbbbbbbbbbbb ? //\n"
-               "                      ccccccccccccccc :\n"
-               "                      ddddddddddddddd;",
-               Style);
-  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
-               "                  aaaaaaaaaaaaaaa :\n"
-               "                  (bbbbbbbbbbbbbbb ? //\n"
-               "                       ccccccccccccccc :\n"
-               "                       ddddddddddddddd);",
-               Style);
-  verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-               "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
-               "            ccccccccccccccccccccccccccc;",
-               Style);
-  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
-               "           aaaaa :\n"
-               "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
-               Style);
-}
-
-TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
-  verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
-               "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
-  verifyFormat("bool a = true, b = false;");
-
-  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-               "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
-               "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
-               "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
-  verifyFormat(
-      "bool aaaaaaaaaaaaaaaaaaaaa =\n"
-      "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
-      "     d = e && f;");
-  verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
-               "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
-  verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
-               "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
-  verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
-               "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
-
-  FormatStyle Style = getGoogleStyle();
-  Style.PointerAlignment = FormatStyle::PAS_Left;
-  Style.DerivePointerAlignment = false;
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
-               "    *b = bbbbbbbbbbbbbbbbbbb;",
-               Style);
-  verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
-               "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
-               Style);
-  verifyFormat("vector<int*> a, b;", Style);
-  verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
-}
-
-TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
-  verifyFormat("arr[foo ? bar : baz];");
-  verifyFormat("f()[foo ? bar : baz];");
-  verifyFormat("(a + b)[foo ? bar : baz];");
-  verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
-}
-
-TEST_F(FormatTest, AlignsStringLiterals) {
-  verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
-               "                                      \"short literal\");");
-  verifyFormat(
-      "looooooooooooooooooooooooongFunction(\n"
-      "    \"short literal\"\n"
-      "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
-  verifyFormat("someFunction(\"Always break between multi-line\"\n"
-               "             \" string literals\",\n"
-               "             and, other, parameters);");
-  EXPECT_EQ("fun + \"1243\" /* comment */\n"
-            "      \"5678\";",
-            format("fun + \"1243\" /* comment */\n"
-                   "    \"5678\";",
-                   getLLVMStyleWithColumns(28)));
-  EXPECT_EQ(
-      "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
-      "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
-      "         \"aaaaaaaaaaaaaaaa\";",
-      format("aaaaaa ="
-             "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
-             "aaaaaaaaaaaaaaaaaaaaa\" "
-             "\"aaaaaaaaaaaaaaaa\";"));
-  verifyFormat("a = a + \"a\"\n"
-               "        \"a\"\n"
-               "        \"a\";");
-  verifyFormat("f(\"a\", \"b\"\n"
-               "       \"c\");");
-
-  verifyFormat(
-      "#define LL_FORMAT \"ll\"\n"
-      "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
-      "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
-
-  verifyFormat("#define A(X)          \\\n"
-               "  \"aaaaa\" #X \"bbbbbb\" \\\n"
-               "  \"ccccc\"",
-               getLLVMStyleWithColumns(23));
-  verifyFormat("#define A \"def\"\n"
-               "f(\"abc\" A \"ghi\"\n"
-               "  \"jkl\");");
-
-  verifyFormat("f(L\"a\"\n"
-               "  L\"b\");");
-  verifyFormat("#define A(X)            \\\n"
-               "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
-               "  L\"ccccc\"",
-               getLLVMStyleWithColumns(25));
-
-  verifyFormat("f(@\"a\"\n"
-               "  @\"b\");");
-  verifyFormat("NSString s = @\"a\"\n"
-               "             @\"b\"\n"
-               "             @\"c\";");
-  verifyFormat("NSString s = @\"a\"\n"
-               "              \"b\"\n"
-               "              \"c\";");
-}
-
-TEST_F(FormatTest, ReturnTypeBreakingStyle) {
-  FormatStyle Style = getLLVMStyle();
-  // No declarations or definitions should be moved to own line.
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
-  verifyFormat("class A {\n"
-               "  int f() { return 1; }\n"
-               "  int g();\n"
-               "};\n"
-               "int f() { return 1; }\n"
-               "int g();\n",
-               Style);
-
-  // All declarations and definitions should have the return type moved to its
-  // own
-  // line.
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
-  verifyFormat("class E {\n"
-               "  int\n"
-               "  f() {\n"
-               "    return 1;\n"
-               "  }\n"
-               "  int\n"
-               "  g();\n"
-               "};\n"
-               "int\n"
-               "f() {\n"
-               "  return 1;\n"
-               "}\n"
-               "int\n"
-               "g();\n",
-               Style);
-
-  // Top-level definitions, and no kinds of declarations should have the
-  // return type moved to its own line.
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
-  verifyFormat("class B {\n"
-               "  int f() { return 1; }\n"
-               "  int g();\n"
-               "};\n"
-               "int\n"
-               "f() {\n"
-               "  return 1;\n"
-               "}\n"
-               "int g();\n",
-               Style);
-
-  // Top-level definitions and declarations should have the return type moved
-  // to its own line.
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
-  verifyFormat("class C {\n"
-               "  int f() { return 1; }\n"
-               "  int g();\n"
-               "};\n"
-               "int\n"
-               "f() {\n"
-               "  return 1;\n"
-               "}\n"
-               "int\n"
-               "g();\n",
-               Style);
-
-  // All definitions should have the return type moved to its own line, but no
-  // kinds of declarations.
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
-  verifyFormat("class D {\n"
-               "  int\n"
-               "  f() {\n"
-               "    return 1;\n"
-               "  }\n"
-               "  int g();\n"
-               "};\n"
-               "int\n"
-               "f() {\n"
-               "  return 1;\n"
-               "}\n"
-               "int g();\n",
-               Style);
-  verifyFormat("const char *\n"
-               "f(void) {\n" // Break here.
-               "  return \"\";\n"
-               "}\n"
-               "const char *bar(void);\n", // No break here.
-               Style);
-  verifyFormat("template <class T>\n"
-               "T *\n"
-               "f(T &c) {\n" // Break here.
-               "  return NULL;\n"
-               "}\n"
-               "template <class T> T *f(T &c);\n", // No break here.
-               Style);
-  verifyFormat("class C {\n"
-               "  int\n"
-               "  operator+() {\n"
-               "    return 1;\n"
-               "  }\n"
-               "  int\n"
-               "  operator()() {\n"
-               "    return 1;\n"
-               "  }\n"
-               "};\n",
-               Style);
-  verifyFormat("void\n"
-               "A::operator()() {}\n"
-               "void\n"
-               "A::operator>>() {}\n"
-               "void\n"
-               "A::operator+() {}\n",
-               Style);
-  verifyFormat("void *operator new(std::size_t s);", // No break here.
-               Style);
-  verifyFormat("void *\n"
-               "operator new(std::size_t s) {}",
-               Style);
-  verifyFormat("void *\n"
-               "operator delete[](void *ptr) {}",
-               Style);
-  Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
-  verifyFormat("const char *\n"
-               "f(void)\n" // Break here.
-               "{\n"
-               "  return \"\";\n"
-               "}\n"
-               "const char *bar(void);\n", // No break here.
-               Style);
-  verifyFormat("template <class T>\n"
-               "T *\n"     // Problem here: no line break
-               "f(T &c)\n" // Break here.
-               "{\n"
-               "  return NULL;\n"
-               "}\n"
-               "template <class T> T *f(T &c);\n", // No break here.
-               Style);
-}
-
-TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
-  FormatStyle NoBreak = getLLVMStyle();
-  NoBreak.AlwaysBreakBeforeMultilineStrings = false;
-  FormatStyle Break = getLLVMStyle();
-  Break.AlwaysBreakBeforeMultilineStrings = true;
-  verifyFormat("aaaa = \"bbbb\"\n"
-               "       \"cccc\";",
-               NoBreak);
-  verifyFormat("aaaa =\n"
-               "    \"bbbb\"\n"
-               "    \"cccc\";",
-               Break);
-  verifyFormat("aaaa(\"bbbb\"\n"
-               "     \"cccc\");",
-               NoBreak);
-  verifyFormat("aaaa(\n"
-               "    \"bbbb\"\n"
-               "    \"cccc\");",
-               Break);
-  verifyFormat("aaaa(qqq, \"bbbb\"\n"
-               "          \"cccc\");",
-               NoBreak);
-  verifyFormat("aaaa(qqq,\n"
-               "     \"bbbb\"\n"
-               "     \"cccc\");",
-               Break);
-  verifyFormat("aaaa(qqq,\n"
-               "     L\"bbbb\"\n"
-               "     L\"cccc\");",
-               Break);
-  verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
-               "                      \"bbbb\"));",
-               Break);
-  verifyFormat("string s = someFunction(\n"
-               "    \"abc\"\n"
-               "    \"abc\");",
-               Break);
-
-  // As we break before unary operators, breaking right after them is bad.
-  verifyFormat("string foo = abc ? \"x\"\n"
-               "                   \"blah blah blah blah blah blah\"\n"
-               "                 : \"y\";",
-               Break);
-
-  // Don't break if there is no column gain.
-  verifyFormat("f(\"aaaa\"\n"
-               "  \"bbbb\");",
-               Break);
-
-  // Treat literals with escaped newlines like multi-line string literals.
-  EXPECT_EQ("x = \"a\\\n"
-            "b\\\n"
-            "c\";",
-            format("x = \"a\\\n"
-                   "b\\\n"
-                   "c\";",
-                   NoBreak));
-  EXPECT_EQ("xxxx =\n"
-            "    \"a\\\n"
-            "b\\\n"
-            "c\";",
-            format("xxxx = \"a\\\n"
-                   "b\\\n"
-                   "c\";",
-                   Break));
-
-  // Exempt ObjC strings for now.
-  EXPECT_EQ("NSString *const kString = @\"aaaa\"\n"
-            "                          @\"bbbb\";",
-            format("NSString *const kString = @\"aaaa\"\n"
-                   "@\"bbbb\";",
-                   Break));
-
-  Break.ColumnLimit = 0;
-  verifyFormat("const char *hello = \"hello llvm\";", Break);
-}
-
-TEST_F(FormatTest, AlignsPipes) {
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
-      "                     << aaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
-      "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
-      "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
-      "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
-  verifyFormat(
-      "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-      "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
-  verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
-               "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
-  verifyFormat(
-      "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
-      "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
-               "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
-  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                    aaaaaaaaaaaaaaaaaaaaa)\n"
-               "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat("LOG_IF(aaa == //\n"
-               "       bbb)\n"
-               "    << a << b;");
-
-  // But sometimes, breaking before the first "<<" is desirable.
-  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
-               "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
-  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
-               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
-               "    << BEF << IsTemplate << Description << E->getType();");
-  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
-               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
-               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    << aaa;");
-
-  verifyFormat(
-      "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-
-  // Incomplete string literal.
-  EXPECT_EQ("llvm::errs() << \"\n"
-            "             << a;",
-            format("llvm::errs() << \"\n<<a;"));
-
-  verifyFormat("void f() {\n"
-               "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
-               "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
-               "}");
-
-  // Handle 'endl'.
-  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
-               "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
-  verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
-
-  // Handle '\n'.
-  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
-               "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
-  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
-               "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
-  verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
-               "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
-  verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
-}
-
-TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
-  verifyFormat("return out << \"somepacket = {\\n\"\n"
-               "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
-               "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
-               "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
-               "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
-               "           << \"}\";");
-
-  verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
-               "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
-               "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
-      "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
-      "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
-      "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
-      "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
-  verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
-               "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
-  verifyFormat(
-      "void f() {\n"
-      "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
-      "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
-      "}");
-
-  // Breaking before the first "<<" is generally not desirable.
-  verifyFormat(
-      "llvm::errs()\n"
-      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
-      getLLVMStyleWithColumns(70));
-  verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
-               "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
-               "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
-               "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
-               getLLVMStyleWithColumns(70));
-
-  verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
-               "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
-               "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
-  verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
-               "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
-               "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
-  verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
-               "           (aaaa + aaaa);",
-               getLLVMStyleWithColumns(40));
-  verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
-               "                  (aaaaaaa + aaaaa));",
-               getLLVMStyleWithColumns(40));
-  verifyFormat(
-      "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
-      "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
-      "                  bbbbbbbbbbbbbbbbbbbbbbb);");
-}
-
-TEST_F(FormatTest, UnderstandsEquals) {
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaa =\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat(
-      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
-  verifyFormat(
-      "if (a) {\n"
-      "  f();\n"
-      "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-      "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
-      "}");
-
-  verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-               "        100000000 + 10000000) {\n}");
-}
-
-TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
-               "    .looooooooooooooooooooooooooooooooooooooongFunction();");
-
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
-               "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
-
-  verifyFormat(
-      "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
-      "                                                          Parameter2);");
-
-  verifyFormat(
-      "ShortObject->shortFunction(\n"
-      "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
-      "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
-
-  verifyFormat("loooooooooooooongFunction(\n"
-               "    LoooooooooooooongObject->looooooooooooooooongFunction());");
-
-  verifyFormat(
-      "function(LoooooooooooooooooooooooooooooooooooongObject\n"
-      "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
-
-  verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
-               "    .WillRepeatedly(Return(SomeValue));");
-  verifyFormat("void f() {\n"
-               "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
-               "      .Times(2)\n"
-               "      .WillRepeatedly(Return(SomeValue));\n"
-               "}");
-  verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
-               "    ccccccccccccccccccccccc);");
-  verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "          .aaaaa(aaaaa),\n"
-               "      aaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("void f() {\n"
-               "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
-               "}");
-  verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
-               "}");
-
-  // Here, it is not necessary to wrap at "." or "->".
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
-               "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
-  verifyFormat(
-      "aaaaaaaaaaa->aaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
-
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
-  verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
-               "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
-  verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
-               "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
-
-  verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    .a();");
-
-  FormatStyle NoBinPacking = getLLVMStyle();
-  NoBinPacking.BinPackParameters = false;
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
-               "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
-               "                         aaaaaaaaaaaaaaaaaaa,\n"
-               "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-               NoBinPacking);
-
-  // If there is a subsequent call, change to hanging indentation.
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
-      "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
-  verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
-}
-
-TEST_F(FormatTest, WrapsTemplateDeclarations) {
-  verifyFormat("template <typename T>\n"
-               "virtual void loooooooooooongFunction(int Param1, int Param2);");
-  verifyFormat("template <typename T>\n"
-               "// T should be one of {A, B}.\n"
-               "virtual void loooooooooooongFunction(int Param1, int Param2);");
-  verifyFormat(
-      "template <typename T>\n"
-      "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
-  verifyFormat("template <typename T>\n"
-               "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
-               "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
-  verifyFormat(
-      "template <typename T>\n"
-      "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
-      "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
-  verifyFormat(
-      "template <typename T>\n"
-      "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
-      "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
-      "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("template <typename T>\n"
-               "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    int aaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat(
-      "template <typename T1, typename T2 = char, typename T3 = char,\n"
-      "          typename T4 = char>\n"
-      "void f();");
-  verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
-               "          template <typename> class cccccccccccccccccccccc,\n"
-               "          typename ddddddddddddd>\n"
-               "class C {};");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat("void f() {\n"
-               "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
-               "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
-               "}");
-
-  verifyFormat("template <typename T> class C {};");
-  verifyFormat("template <typename T> void f();");
-  verifyFormat("template <typename T> void f() {}");
-  verifyFormat(
-      "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
-      "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
-      "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
-      "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
-      "        bbbbbbbbbbbbbbbbbbbbbbbb);",
-      getLLVMStyleWithColumns(72));
-  EXPECT_EQ("static_cast<A< //\n"
-            "    B> *>(\n"
-            "\n"
-            "    );",
-            format("static_cast<A<//\n"
-                   "    B>*>(\n"
-                   "\n"
-                   "    );"));
-  verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
-
-  FormatStyle AlwaysBreak = getLLVMStyle();
-  AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
-  verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
-  verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
-  verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
-  verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
-               "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
-  verifyFormat("template <template <typename> class Fooooooo,\n"
-               "          template <typename> class Baaaaaaar>\n"
-               "struct C {};",
-               AlwaysBreak);
-  verifyFormat("template <typename T> // T can be A, B or C.\n"
-               "struct C {};",
-               AlwaysBreak);
-  verifyFormat("template <enum E> class A {\n"
-               "public:\n"
-               "  E *f();\n"
-               "};");
-}
-
-TEST_F(FormatTest, WrapsTemplateParameters) {
-  FormatStyle Style = getLLVMStyle();
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
-  verifyFormat(
-      "template <typename... a> struct q {};\n"
-      "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
-      "    y;",
-      Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  verifyFormat(
-      "template <typename... a> struct r {};\n"
-      "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
-      "    y;",
-      Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
-  verifyFormat(
-      "template <typename... a> struct s {};\n"
-      "extern s<\n"
-      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
-      "    y;",
-      Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  verifyFormat(
-      "template <typename... a> struct t {};\n"
-      "extern t<\n"
-      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
-      "    y;",
-      Style);
-}
-
-TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
-
-  // FIXME: Should we have the extra indent after the second break?
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
-      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-
-  verifyFormat(
-      "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
-      "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
-
-  // Breaking at nested name specifiers is generally not desirable.
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
-      "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                   aaaaaaaaaaaaaaaaaaaaa);",
-      getLLVMStyleWithColumns(74));
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
-}
-
-TEST_F(FormatTest, UnderstandsTemplateParameters) {
-  verifyFormat("A<int> a;");
-  verifyFormat("A<A<A<int>>> a;");
-  verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
-  verifyFormat("bool x = a < 1 || 2 > a;");
-  verifyFormat("bool x = 5 < f<int>();");
-  verifyFormat("bool x = f<int>() > 5;");
-  verifyFormat("bool x = 5 < a<int>::x;");
-  verifyFormat("bool x = a < 4 ? a > 2 : false;");
-  verifyFormat("bool x = f() ? a < 2 : a > 2;");
-
-  verifyGoogleFormat("A<A<int>> a;");
-  verifyGoogleFormat("A<A<A<int>>> a;");
-  verifyGoogleFormat("A<A<A<A<int>>>> a;");
-  verifyGoogleFormat("A<A<int> > a;");
-  verifyGoogleFormat("A<A<A<int> > > a;");
-  verifyGoogleFormat("A<A<A<A<int> > > > a;");
-  verifyGoogleFormat("A<::A<int>> a;");
-  verifyGoogleFormat("A<::A> a;");
-  verifyGoogleFormat("A< ::A> a;");
-  verifyGoogleFormat("A< ::A<int> > a;");
-  EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
-  EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
-  EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
-  EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
-  EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
-            format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
-
-  verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
-
-  verifyFormat("test >> a >> b;");
-  verifyFormat("test << a >> b;");
-
-  verifyFormat("f<int>();");
-  verifyFormat("template <typename T> void f() {}");
-  verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
-  verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
-               "sizeof(char)>::type>;");
-  verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
-  verifyFormat("f(a.operator()<A>());");
-  verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "      .template operator()<A>());",
-               getLLVMStyleWithColumns(35));
-
-  // Not template parameters.
-  verifyFormat("return a < b && c > d;");
-  verifyFormat("void f() {\n"
-               "  while (a < b && c > d) {\n"
-               "  }\n"
-               "}");
-  verifyFormat("template <typename... Types>\n"
-               "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
-  verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
-  verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
-}
-
-TEST_F(FormatTest, BitshiftOperatorWidth) {
-  EXPECT_EQ("int a = 1 << 2; /* foo\n"
-            "                   bar */",
-            format("int    a=1<<2;  /* foo\n"
-                   "                   bar */"));
-
-  EXPECT_EQ("int b = 256 >> 1; /* foo\n"
-            "                     bar */",
-            format("int  b  =256>>1 ;  /* foo\n"
-                   "                      bar */"));
-}
-
-TEST_F(FormatTest, UnderstandsBinaryOperators) {
-  verifyFormat("COMPARE(a, ==, b);");
-  verifyFormat("auto s = sizeof...(Ts) - 1;");
-}
-
-TEST_F(FormatTest, UnderstandsPointersToMembers) {
-  verifyFormat("int A::*x;");
-  verifyFormat("int (S::*func)(void *);");
-  verifyFormat("void f() { int (S::*func)(void *); }");
-  verifyFormat("typedef bool *(Class::*Member)() const;");
-  verifyFormat("void f() {\n"
-               "  (a->*f)();\n"
-               "  a->*x;\n"
-               "  (a.*f)();\n"
-               "  ((*a).*f)();\n"
-               "  a.*x;\n"
-               "}");
-  verifyFormat("void f() {\n"
-               "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
-               "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
-               "}");
-  verifyFormat(
-      "(aaaaaaaaaa->*bbbbbbb)(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
-  FormatStyle Style = getLLVMStyle();
-  Style.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("typedef bool* (Class::*Member)() const;", Style);
-}
-
-TEST_F(FormatTest, UnderstandsUnaryOperators) {
-  verifyFormat("int a = -2;");
-  verifyFormat("f(-1, -2, -3);");
-  verifyFormat("a[-1] = 5;");
-  verifyFormat("int a = 5 + -2;");
-  verifyFormat("if (i == -1) {\n}");
-  verifyFormat("if (i != -1) {\n}");
-  verifyFormat("if (i > -1) {\n}");
-  verifyFormat("if (i < -1) {\n}");
-  verifyFormat("++(a->f());");
-  verifyFormat("--(a->f());");
-  verifyFormat("(a->f())++;");
-  verifyFormat("a[42]++;");
-  verifyFormat("if (!(a->f())) {\n}");
-
-  verifyFormat("a-- > b;");
-  verifyFormat("b ? -a : c;");
-  verifyFormat("n * sizeof char16;");
-  verifyFormat("n * alignof char16;", getGoogleStyle());
-  verifyFormat("sizeof(char);");
-  verifyFormat("alignof(char);", getGoogleStyle());
-
-  verifyFormat("return -1;");
-  verifyFormat("switch (a) {\n"
-               "case -1:\n"
-               "  break;\n"
-               "}");
-  verifyFormat("#define X -1");
-  verifyFormat("#define X -kConstant");
-
-  verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
-  verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
-
-  verifyFormat("int a = /* confusing comment */ -1;");
-  // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
-  verifyFormat("int a = i /* confusing comment */++;");
-}
-
-TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
-  verifyFormat("if (!aaaaaaaaaa( // break\n"
-               "        aaaaa)) {\n"
-               "}");
-  verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
-               "    aaaaa));");
-  verifyFormat("*aaa = aaaaaaa( // break\n"
-               "    bbbbbb);");
-}
-
-TEST_F(FormatTest, UnderstandsOverloadedOperators) {
-  verifyFormat("bool operator<();");
-  verifyFormat("bool operator>();");
-  verifyFormat("bool operator=();");
-  verifyFormat("bool operator==();");
-  verifyFormat("bool operator!=();");
-  verifyFormat("int operator+();");
-  verifyFormat("int operator++();");
-  verifyFormat("bool operator,();");
-  verifyFormat("bool operator();");
-  verifyFormat("bool operator()();");
-  verifyFormat("bool operator[]();");
-  verifyFormat("operator bool();");
-  verifyFormat("operator int();");
-  verifyFormat("operator void *();");
-  verifyFormat("operator SomeType<int>();");
-  verifyFormat("operator SomeType<int, int>();");
-  verifyFormat("operator SomeType<SomeType<int>>();");
-  verifyFormat("void *operator new(std::size_t size);");
-  verifyFormat("void *operator new[](std::size_t size);");
-  verifyFormat("void operator delete(void *ptr);");
-  verifyFormat("void operator delete[](void *ptr);");
-  verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
-               "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
-               "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
-
-  verifyFormat(
-      "ostream &operator<<(ostream &OutputStream,\n"
-      "                    SomeReallyLongType WithSomeReallyLongValue);");
-  verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
-               "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
-               "  return left.group < right.group;\n"
-               "}");
-  verifyFormat("SomeType &operator=(const SomeType &S);");
-  verifyFormat("f.template operator()<int>();");
-
-  verifyGoogleFormat("operator void*();");
-  verifyGoogleFormat("operator SomeType<SomeType<int>>();");
-  verifyGoogleFormat("operator ::A();");
-
-  verifyFormat("using A::operator+;");
-  verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
-               "int i;");
-}
-
-TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
-  verifyFormat("Deleted &operator=(const Deleted &) & = default;");
-  verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
-  verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
-  verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
-  verifyFormat("Deleted &operator=(const Deleted &) &;");
-  verifyFormat("Deleted &operator=(const Deleted &) &&;");
-  verifyFormat("SomeType MemberFunction(const Deleted &) &;");
-  verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
-  verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
-  verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
-  verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
-  verifyFormat("SomeType MemberFunction(const Deleted &) const &;");
-  verifyFormat("template <typename T>\n"
-               "void F(T) && = delete;",
-               getGoogleStyle());
-
-  FormatStyle AlignLeft = getLLVMStyle();
-  AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("void A::b() && {}", AlignLeft);
-  verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
-  verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
-               AlignLeft);
-  verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
-  verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
-  verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
-  verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
-  verifyFormat("auto Function(T) & -> void {}", AlignLeft);
-  verifyFormat("auto Function(T) & -> void;", AlignLeft);
-  verifyFormat("SomeType MemberFunction(const Deleted&) const &;", AlignLeft);
-
-  FormatStyle Spaces = getLLVMStyle();
-  Spaces.SpacesInCStyleCastParentheses = true;
-  verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
-  verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
-  verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
-  verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
-
-  Spaces.SpacesInCStyleCastParentheses = false;
-  Spaces.SpacesInParentheses = true;
-  verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
-  verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
-  verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
-  verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
-}
-
-TEST_F(FormatTest, UnderstandsNewAndDelete) {
-  verifyFormat("void f() {\n"
-               "  A *a = new A;\n"
-               "  A *a = new (placement) A;\n"
-               "  delete a;\n"
-               "  delete (A *)a;\n"
-               "}");
-  verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
-               "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-               "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
-               "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat("delete[] h->p;");
-}
-
-TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
-  verifyFormat("int *f(int *a) {}");
-  verifyFormat("int main(int argc, char **argv) {}");
-  verifyFormat("Test::Test(int b) : a(b * b) {}");
-  verifyIndependentOfContext("f(a, *a);");
-  verifyFormat("void g() { f(*a); }");
-  verifyIndependentOfContext("int a = b * 10;");
-  verifyIndependentOfContext("int a = 10 * b;");
-  verifyIndependentOfContext("int a = b * c;");
-  verifyIndependentOfContext("int a += b * c;");
-  verifyIndependentOfContext("int a -= b * c;");
-  verifyIndependentOfContext("int a *= b * c;");
-  verifyIndependentOfContext("int a /= b * c;");
-  verifyIndependentOfContext("int a = *b;");
-  verifyIndependentOfContext("int a = *b * c;");
-  verifyIndependentOfContext("int a = b * *c;");
-  verifyIndependentOfContext("int a = b * (10);");
-  verifyIndependentOfContext("S << b * (10);");
-  verifyIndependentOfContext("return 10 * b;");
-  verifyIndependentOfContext("return *b * *c;");
-  verifyIndependentOfContext("return a & ~b;");
-  verifyIndependentOfContext("f(b ? *c : *d);");
-  verifyIndependentOfContext("int a = b ? *c : *d;");
-  verifyIndependentOfContext("*b = a;");
-  verifyIndependentOfContext("a * ~b;");
-  verifyIndependentOfContext("a * !b;");
-  verifyIndependentOfContext("a * +b;");
-  verifyIndependentOfContext("a * -b;");
-  verifyIndependentOfContext("a * ++b;");
-  verifyIndependentOfContext("a * --b;");
-  verifyIndependentOfContext("a[4] * b;");
-  verifyIndependentOfContext("a[a * a] = 1;");
-  verifyIndependentOfContext("f() * b;");
-  verifyIndependentOfContext("a * [self dostuff];");
-  verifyIndependentOfContext("int x = a * (a + b);");
-  verifyIndependentOfContext("(a *)(a + b);");
-  verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
-  verifyIndependentOfContext("int *pa = (int *)&a;");
-  verifyIndependentOfContext("return sizeof(int **);");
-  verifyIndependentOfContext("return sizeof(int ******);");
-  verifyIndependentOfContext("return (int **&)a;");
-  verifyIndependentOfContext("f((*PointerToArray)[10]);");
-  verifyFormat("void f(Type (*parameter)[10]) {}");
-  verifyFormat("void f(Type (&parameter)[10]) {}");
-  verifyGoogleFormat("return sizeof(int**);");
-  verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
-  verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
-  verifyFormat("auto a = [](int **&, int ***) {};");
-  verifyFormat("auto PointerBinding = [](const char *S) {};");
-  verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
-  verifyFormat("[](const decltype(*a) &value) {}");
-  verifyFormat("decltype(a * b) F();");
-  verifyFormat("#define MACRO() [](A *a) { return 1; }");
-  verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
-  verifyIndependentOfContext("typedef void (*f)(int *a);");
-  verifyIndependentOfContext("int i{a * b};");
-  verifyIndependentOfContext("aaa && aaa->f();");
-  verifyIndependentOfContext("int x = ~*p;");
-  verifyFormat("Constructor() : a(a), area(width * height) {}");
-  verifyFormat("Constructor() : a(a), area(a, width * height) {}");
-  verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
-  verifyFormat("void f() { f(a, c * d); }");
-  verifyFormat("void f() { f(new a(), c * d); }");
-  verifyFormat("void f(const MyOverride &override);");
-  verifyFormat("void f(const MyFinal &final);");
-  verifyIndependentOfContext("bool a = f() && override.f();");
-  verifyIndependentOfContext("bool a = f() && final.f();");
-
-  verifyIndependentOfContext("InvalidRegions[*R] = 0;");
-
-  verifyIndependentOfContext("A<int *> a;");
-  verifyIndependentOfContext("A<int **> a;");
-  verifyIndependentOfContext("A<int *, int *> a;");
-  verifyIndependentOfContext("A<int *[]> a;");
-  verifyIndependentOfContext(
-      "const char *const p = reinterpret_cast<const char *const>(q);");
-  verifyIndependentOfContext("A<int **, int **> a;");
-  verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
-  verifyFormat("for (char **a = b; *a; ++a) {\n}");
-  verifyFormat("for (; a && b;) {\n}");
-  verifyFormat("bool foo = true && [] { return false; }();");
-
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyGoogleFormat("int const* a = &b;");
-  verifyGoogleFormat("**outparam = 1;");
-  verifyGoogleFormat("*outparam = a * b;");
-  verifyGoogleFormat("int main(int argc, char** argv) {}");
-  verifyGoogleFormat("A<int*> a;");
-  verifyGoogleFormat("A<int**> a;");
-  verifyGoogleFormat("A<int*, int*> a;");
-  verifyGoogleFormat("A<int**, int**> a;");
-  verifyGoogleFormat("f(b ? *c : *d);");
-  verifyGoogleFormat("int a = b ? *c : *d;");
-  verifyGoogleFormat("Type* t = **x;");
-  verifyGoogleFormat("Type* t = *++*x;");
-  verifyGoogleFormat("*++*x;");
-  verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
-  verifyGoogleFormat("Type* t = x++ * y;");
-  verifyGoogleFormat(
-      "const char* const p = reinterpret_cast<const char* const>(q);");
-  verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
-  verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
-  verifyGoogleFormat("template <typename T>\n"
-                     "void f(int i = 0, SomeType** temps = NULL);");
-
-  FormatStyle Left = getLLVMStyle();
-  Left.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("x = *a(x) = *a(y);", Left);
-  verifyFormat("for (;; *a = b) {\n}", Left);
-  verifyFormat("return *this += 1;", Left);
-
-  verifyIndependentOfContext("a = *(x + y);");
-  verifyIndependentOfContext("a = &(x + y);");
-  verifyIndependentOfContext("*(x + y).call();");
-  verifyIndependentOfContext("&(x + y)->call();");
-  verifyFormat("void f() { &(*I).first; }");
-
-  verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
-  verifyFormat(
-      "int *MyValues = {\n"
-      "    *A, // Operator detection might be confused by the '{'\n"
-      "    *BB // Operator detection might be confused by previous comment\n"
-      "};");
-
-  verifyIndependentOfContext("if (int *a = &b)");
-  verifyIndependentOfContext("if (int &a = *b)");
-  verifyIndependentOfContext("if (a & b[i])");
-  verifyIndependentOfContext("if (a::b::c::d & b[i])");
-  verifyIndependentOfContext("if (*b[i])");
-  verifyIndependentOfContext("if (int *a = (&b))");
-  verifyIndependentOfContext("while (int *a = &b)");
-  verifyIndependentOfContext("size = sizeof *a;");
-  verifyIndependentOfContext("if (a && (b = c))");
-  verifyFormat("void f() {\n"
-               "  for (const int &v : Values) {\n"
-               "  }\n"
-               "}");
-  verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
-  verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
-  verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
-
-  verifyFormat("#define A (!a * b)");
-  verifyFormat("#define MACRO     \\\n"
-               "  int *i = a * b; \\\n"
-               "  void f(a *b);",
-               getLLVMStyleWithColumns(19));
-
-  verifyIndependentOfContext("A = new SomeType *[Length];");
-  verifyIndependentOfContext("A = new SomeType *[Length]();");
-  verifyIndependentOfContext("T **t = new T *;");
-  verifyIndependentOfContext("T **t = new T *();");
-  verifyGoogleFormat("A = new SomeType*[Length]();");
-  verifyGoogleFormat("A = new SomeType*[Length];");
-  verifyGoogleFormat("T** t = new T*;");
-  verifyGoogleFormat("T** t = new T*();");
-
-  FormatStyle PointerLeft = getLLVMStyle();
-  PointerLeft.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("delete *x;", PointerLeft);
-  verifyFormat("STATIC_ASSERT((a & b) == 0);");
-  verifyFormat("STATIC_ASSERT(0 == (a & b));");
-  verifyFormat("template <bool a, bool b> "
-               "typename t::if<x && y>::type f() {}");
-  verifyFormat("template <int *y> f() {}");
-  verifyFormat("vector<int *> v;");
-  verifyFormat("vector<int *const> v;");
-  verifyFormat("vector<int *const **const *> v;");
-  verifyFormat("vector<int *volatile> v;");
-  verifyFormat("vector<a * b> v;");
-  verifyFormat("foo<b && false>();");
-  verifyFormat("foo<b & 1>();");
-  verifyFormat("decltype(*::std::declval<const T &>()) void F();");
-  verifyFormat(
-      "template <class T, class = typename std::enable_if<\n"
-      "                       std::is_integral<T>::value &&\n"
-      "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
-      "void F();",
-      getLLVMStyleWithColumns(70));
-  verifyFormat(
-      "template <class T,\n"
-      "          class = typename std::enable_if<\n"
-      "              std::is_integral<T>::value &&\n"
-      "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
-      "          class U>\n"
-      "void F();",
-      getLLVMStyleWithColumns(70));
-  verifyFormat(
-      "template <class T,\n"
-      "          class = typename ::std::enable_if<\n"
-      "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
-      "void F();",
-      getGoogleStyleWithColumns(68));
-
-  verifyIndependentOfContext("MACRO(int *i);");
-  verifyIndependentOfContext("MACRO(auto *a);");
-  verifyIndependentOfContext("MACRO(const A *a);");
-  verifyIndependentOfContext("MACRO(A *const a);");
-  verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
-  verifyFormat("void f() { f(float{1}, a * a); }");
-  // FIXME: Is there a way to make this work?
-  // verifyIndependentOfContext("MACRO(A *a);");
-
-  verifyFormat("DatumHandle const *operator->() const { return input_; }");
-  verifyFormat("return options != nullptr && operator==(*options);");
-
-  EXPECT_EQ("#define OP(x)                                    \\\n"
-            "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
-            "    return s << a.DebugString();                 \\\n"
-            "  }",
-            format("#define OP(x) \\\n"
-                   "  ostream &operator<<(ostream &s, const A &a) { \\\n"
-                   "    return s << a.DebugString(); \\\n"
-                   "  }",
-                   getLLVMStyleWithColumns(50)));
-
-  // FIXME: We cannot handle this case yet; we might be able to figure out that
-  // foo<x> d > v; doesn't make sense.
-  verifyFormat("foo<a<b && c> d> v;");
-
-  FormatStyle PointerMiddle = getLLVMStyle();
-  PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
-  verifyFormat("delete *x;", PointerMiddle);
-  verifyFormat("int * x;", PointerMiddle);
-  verifyFormat("template <int * y> f() {}", PointerMiddle);
-  verifyFormat("int * f(int * a) {}", PointerMiddle);
-  verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
-  verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
-  verifyFormat("A<int *> a;", PointerMiddle);
-  verifyFormat("A<int **> a;", PointerMiddle);
-  verifyFormat("A<int *, int *> a;", PointerMiddle);
-  verifyFormat("A<int * []> a;", PointerMiddle);
-  verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
-  verifyFormat("A = new SomeType *[Length];", PointerMiddle);
-  verifyFormat("T ** t = new T *;", PointerMiddle);
-
-  // Member function reference qualifiers aren't binary operators.
-  verifyFormat("string // break\n"
-               "operator()() & {}");
-  verifyFormat("string // break\n"
-               "operator()() && {}");
-  verifyGoogleFormat("template <typename T>\n"
-                     "auto x() & -> int {}");
-}
-
-TEST_F(FormatTest, UnderstandsAttributes) {
-  verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
-               "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
-  FormatStyle AfterType = getLLVMStyle();
-  AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
-  verifyFormat("__attribute__((nodebug)) void\n"
-               "foo() {}\n",
-               AfterType);
-}
-
-TEST_F(FormatTest, UnderstandsEllipsis) {
-  verifyFormat("int printf(const char *fmt, ...);");
-  verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
-  verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
-
-  FormatStyle PointersLeft = getLLVMStyle();
-  PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
-  verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
-}
-
-TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
-  EXPECT_EQ("int *a;\n"
-            "int *a;\n"
-            "int *a;",
-            format("int *a;\n"
-                   "int* a;\n"
-                   "int *a;",
-                   getGoogleStyle()));
-  EXPECT_EQ("int* a;\n"
-            "int* a;\n"
-            "int* a;",
-            format("int* a;\n"
-                   "int* a;\n"
-                   "int *a;",
-                   getGoogleStyle()));
-  EXPECT_EQ("int *a;\n"
-            "int *a;\n"
-            "int *a;",
-            format("int *a;\n"
-                   "int * a;\n"
-                   "int *  a;",
-                   getGoogleStyle()));
-  EXPECT_EQ("auto x = [] {\n"
-            "  int *a;\n"
-            "  int *a;\n"
-            "  int *a;\n"
-            "};",
-            format("auto x=[]{int *a;\n"
-                   "int * a;\n"
-                   "int *  a;};",
-                   getGoogleStyle()));
-}
-
-TEST_F(FormatTest, UnderstandsRvalueReferences) {
-  verifyFormat("int f(int &&a) {}");
-  verifyFormat("int f(int a, char &&b) {}");
-  verifyFormat("void f() { int &&a = b; }");
-  verifyGoogleFormat("int f(int a, char&& b) {}");
-  verifyGoogleFormat("void f() { int&& a = b; }");
-
-  verifyIndependentOfContext("A<int &&> a;");
-  verifyIndependentOfContext("A<int &&, int &&> a;");
-  verifyGoogleFormat("A<int&&> a;");
-  verifyGoogleFormat("A<int&&, int&&> a;");
-
-  // Not rvalue references:
-  verifyFormat("template <bool B, bool C> class A {\n"
-               "  static_assert(B && C, \"Something is wrong\");\n"
-               "};");
-  verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
-  verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
-  verifyFormat("#define A(a, b) (a && b)");
-}
-
-TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
-  verifyFormat("void f() {\n"
-               "  x[aaaaaaaaa -\n"
-               "    b] = 23;\n"
-               "}",
-               getLLVMStyleWithColumns(15));
-}
-
-TEST_F(FormatTest, FormatsCasts) {
-  verifyFormat("Type *A = static_cast<Type *>(P);");
-  verifyFormat("Type *A = (Type *)P;");
-  verifyFormat("Type *A = (vector<Type *, int *>)P;");
-  verifyFormat("int a = (int)(2.0f);");
-  verifyFormat("int a = (int)2.0f;");
-  verifyFormat("x[(int32)y];");
-  verifyFormat("x = (int32)y;");
-  verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
-  verifyFormat("int a = (int)*b;");
-  verifyFormat("int a = (int)2.0f;");
-  verifyFormat("int a = (int)~0;");
-  verifyFormat("int a = (int)++a;");
-  verifyFormat("int a = (int)sizeof(int);");
-  verifyFormat("int a = (int)+2;");
-  verifyFormat("my_int a = (my_int)2.0f;");
-  verifyFormat("my_int a = (my_int)sizeof(int);");
-  verifyFormat("return (my_int)aaa;");
-  verifyFormat("#define x ((int)-1)");
-  verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
-  verifyFormat("#define p(q) ((int *)&q)");
-  verifyFormat("fn(a)(b) + 1;");
-
-  verifyFormat("void f() { my_int a = (my_int)*b; }");
-  verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
-  verifyFormat("my_int a = (my_int)~0;");
-  verifyFormat("my_int a = (my_int)++a;");
-  verifyFormat("my_int a = (my_int)-2;");
-  verifyFormat("my_int a = (my_int)1;");
-  verifyFormat("my_int a = (my_int *)1;");
-  verifyFormat("my_int a = (const my_int)-1;");
-  verifyFormat("my_int a = (const my_int *)-1;");
-  verifyFormat("my_int a = (my_int)(my_int)-1;");
-  verifyFormat("my_int a = (ns::my_int)-2;");
-  verifyFormat("case (my_int)ONE:");
-  verifyFormat("auto x = (X)this;");
-
-  // FIXME: single value wrapped with paren will be treated as cast.
-  verifyFormat("void f(int i = (kValue)*kMask) {}");
-
-  verifyFormat("{ (void)F; }");
-
-  // Don't break after a cast's
-  verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
-               "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
-               "                                   bbbbbbbbbbbbbbbbbbbbbb);");
-
-  // These are not casts.
-  verifyFormat("void f(int *) {}");
-  verifyFormat("f(foo)->b;");
-  verifyFormat("f(foo).b;");
-  verifyFormat("f(foo)(b);");
-  verifyFormat("f(foo)[b];");
-  verifyFormat("[](foo) { return 4; }(bar);");
-  verifyFormat("(*funptr)(foo)[4];");
-  verifyFormat("funptrs[4](foo)[4];");
-  verifyFormat("void f(int *);");
-  verifyFormat("void f(int *) = 0;");
-  verifyFormat("void f(SmallVector<int>) {}");
-  verifyFormat("void f(SmallVector<int>);");
-  verifyFormat("void f(SmallVector<int>) = 0;");
-  verifyFormat("void f(int i = (kA * kB) & kMask) {}");
-  verifyFormat("int a = sizeof(int) * b;");
-  verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
-  verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
-  verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
-  verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
-
-  // These are not casts, but at some point were confused with casts.
-  verifyFormat("virtual void foo(int *) override;");
-  verifyFormat("virtual void foo(char &) const;");
-  verifyFormat("virtual void foo(int *a, char *) const;");
-  verifyFormat("int a = sizeof(int *) + b;");
-  verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
-  verifyFormat("bool b = f(g<int>) && c;");
-  verifyFormat("typedef void (*f)(int i) func;");
-
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
-               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
-  // FIXME: The indentation here is not ideal.
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-      "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
-      "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
-}
-
-TEST_F(FormatTest, FormatsFunctionTypes) {
-  verifyFormat("A<bool()> a;");
-  verifyFormat("A<SomeType()> a;");
-  verifyFormat("A<void (*)(int, std::string)> a;");
-  verifyFormat("A<void *(int)>;");
-  verifyFormat("void *(*a)(int *, SomeType *);");
-  verifyFormat("int (*func)(void *);");
-  verifyFormat("void f() { int (*func)(void *); }");
-  verifyFormat("template <class CallbackClass>\n"
-               "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
-
-  verifyGoogleFormat("A<void*(int*, SomeType*)>;");
-  verifyGoogleFormat("void* (*a)(int);");
-  verifyGoogleFormat(
-      "template <class CallbackClass>\n"
-      "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
-
-  // Other constructs can look somewhat like function types:
-  verifyFormat("A<sizeof(*x)> a;");
-  verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
-  verifyFormat("some_var = function(*some_pointer_var)[0];");
-  verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
-  verifyFormat("int x = f(&h)();");
-  verifyFormat("returnsFunction(&param1, &param2)(param);");
-}
-
-TEST_F(FormatTest, FormatsPointersToArrayTypes) {
-  verifyFormat("A (*foo_)[6];");
-  verifyFormat("vector<int> (*foo_)[6];");
-}
-
-TEST_F(FormatTest, BreaksLongVariableDeclarations) {
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
-               "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
-
-  // Different ways of ()-initializiation.
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
-
-  // Lambdas should not confuse the variable declaration heuristic.
-  verifyFormat("LooooooooooooooooongType\n"
-               "    variable(nullptr, [](A *a) {});",
-               getLLVMStyleWithColumns(40));
-}
-
-TEST_F(FormatTest, BreaksLongDeclarations) {
-  verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
-               "    AnotherNameForTheLongType;");
-  verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
-               "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
-               "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
-               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
-               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
-               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
-  verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
-               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
-               "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
-               "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
-  FormatStyle Indented = getLLVMStyle();
-  Indented.IndentWrappedFunctionNames = true;
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
-               "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
-               Indented);
-  verifyFormat(
-      "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
-      "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
-      Indented);
-  verifyFormat(
-      "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
-      "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
-      Indented);
-  verifyFormat(
-      "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
-      "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
-      Indented);
-
-  // FIXME: Without the comment, this breaks after "(".
-  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
-               "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
-               getGoogleStyle());
-
-  verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
-               "                  int LoooooooooooooooooooongParam2) {}");
-  verifyFormat(
-      "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
-      "                                   SourceLocation L, IdentifierIn *II,\n"
-      "                                   Type *T) {}");
-  verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
-               "ReallyReaaallyLongFunctionName(\n"
-               "    const std::string &SomeParameter,\n"
-               "    const SomeType<string, SomeOtherTemplateParameter>\n"
-               "        &ReallyReallyLongParameterName,\n"
-               "    const SomeType<string, SomeOtherTemplateParameter>\n"
-               "        &AnotherLongParameterName) {}");
-  verifyFormat("template <typename A>\n"
-               "SomeLoooooooooooooooooooooongType<\n"
-               "    typename some_namespace::SomeOtherType<A>::Type>\n"
-               "Function() {}");
-
-  verifyGoogleFormat(
-      "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaa;");
-  verifyGoogleFormat(
-      "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
-      "                                   SourceLocation L) {}");
-  verifyGoogleFormat(
-      "some_namespace::LongReturnType\n"
-      "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
-      "    int first_long_parameter, int second_parameter) {}");
-
-  verifyGoogleFormat("template <typename T>\n"
-                     "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
-                     "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
-  verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-                     "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
-               "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
-               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-
-  verifyFormat("template <typename T> // Templates on own line.\n"
-               "static int            // Some comment.\n"
-               "MyFunction(int a);",
-               getLLVMStyle());
-}
-
-TEST_F(FormatTest, FormatsArrays) {
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
-               "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
-               "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
-  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
-               "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
-               "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
-  verifyFormat(
-      "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
-      "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
-      "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
-               "    .aaaaaaaaaaaaaaaaaaaaaa();");
-
-  verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
-                     "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
-  verifyFormat(
-      "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
-      "                                  .aaaaaaa[0]\n"
-      "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
-  verifyFormat("a[::b::c];");
-
-  verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
-
-  FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
-  verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
-}
-
-TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
-  verifyFormat("(a)->b();");
-  verifyFormat("--a;");
-}
-
-TEST_F(FormatTest, HandlesIncludeDirectives) {
-  verifyFormat("#include <string>\n"
-               "#include <a/b/c.h>\n"
-               "#include \"a/b/string\"\n"
-               "#include \"string.h\"\n"
-               "#include \"string.h\"\n"
-               "#include <a-a>\n"
-               "#include < path with space >\n"
-               "#include_next <test.h>"
-               "#include \"abc.h\" // this is included for ABC\n"
-               "#include \"some long include\" // with a comment\n"
-               "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
-               getLLVMStyleWithColumns(35));
-  EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
-  EXPECT_EQ("#include <a>", format("#include<a>"));
-
-  verifyFormat("#import <string>");
-  verifyFormat("#import <a/b/c.h>");
-  verifyFormat("#import \"a/b/string\"");
-  verifyFormat("#import \"string.h\"");
-  verifyFormat("#import \"string.h\"");
-  verifyFormat("#if __has_include(<strstream>)\n"
-               "#include <strstream>\n"
-               "#endif");
-
-  verifyFormat("#define MY_IMPORT <a/b>");
-
-  verifyFormat("#if __has_include(<a/b>)");
-  verifyFormat("#if __has_include_next(<a/b>)");
-  verifyFormat("#define F __has_include(<a/b>)");
-  verifyFormat("#define F __has_include_next(<a/b>)");
-
-  // Protocol buffer definition or missing "#".
-  verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
-               getLLVMStyleWithColumns(30));
-
-  FormatStyle Style = getLLVMStyle();
-  Style.AlwaysBreakBeforeMultilineStrings = true;
-  Style.ColumnLimit = 0;
-  verifyFormat("#import \"abc.h\"", Style);
-
-  // But 'import' might also be a regular C++ namespace.
-  verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-}
-
-//===----------------------------------------------------------------------===//
-// Error recovery tests.
-//===----------------------------------------------------------------------===//
-
-TEST_F(FormatTest, IncompleteParameterLists) {
-  FormatStyle NoBinPacking = getLLVMStyle();
-  NoBinPacking.BinPackParameters = false;
-  verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
-               "                        double *min_x,\n"
-               "                        double *max_x,\n"
-               "                        double *min_y,\n"
-               "                        double *max_y,\n"
-               "                        double *min_z,\n"
-               "                        double *max_z, ) {}",
-               NoBinPacking);
-}
-
-TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
-  verifyFormat("void f() { return; }\n42");
-  verifyFormat("void f() {\n"
-               "  if (0)\n"
-               "    return;\n"
-               "}\n"
-               "42");
-  verifyFormat("void f() { return }\n42");
-  verifyFormat("void f() {\n"
-               "  if (0)\n"
-               "    return\n"
-               "}\n"
-               "42");
-}
-
-TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
-  EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
-  EXPECT_EQ("void f() {\n"
-            "  if (a)\n"
-            "    return\n"
-            "}",
-            format("void  f  (  )  {  if  ( a )  return  }"));
-  EXPECT_EQ("namespace N {\n"
-            "void f()\n"
-            "}",
-            format("namespace  N  {  void f()  }"));
-  EXPECT_EQ("namespace N {\n"
-            "void f() {}\n"
-            "void g()\n"
-            "} // namespace N",
-            format("namespace N  { void f( ) { } void g( ) }"));
-}
-
-TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
-  verifyFormat("int aaaaaaaa =\n"
-               "    // Overlylongcomment\n"
-               "    b;",
-               getLLVMStyleWithColumns(20));
-  verifyFormat("function(\n"
-               "    ShortArgument,\n"
-               "    LoooooooooooongArgument);\n",
-               getLLVMStyleWithColumns(20));
-}
-
-TEST_F(FormatTest, IncorrectAccessSpecifier) {
-  verifyFormat("public:");
-  verifyFormat("class A {\n"
-               "public\n"
-               "  void f() {}\n"
-               "};");
-  verifyFormat("public\n"
-               "int qwerty;");
-  verifyFormat("public\n"
-               "B {}");
-  verifyFormat("public\n"
-               "{}");
-  verifyFormat("public\n"
-               "B { int x; }");
-}
-
-TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
-  verifyFormat("{");
-  verifyFormat("#})");
-  verifyNoCrash("(/**/[:!] ?[).");
-}
-
-TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
-  verifyFormat("do {\n}");
-  verifyFormat("do {\n}\n"
-               "f();");
-  verifyFormat("do {\n}\n"
-               "wheeee(fun);");
-  verifyFormat("do {\n"
-               "  f();\n"
-               "}");
-}
-
-TEST_F(FormatTest, IncorrectCodeMissingParens) {
-  verifyFormat("if {\n  foo;\n  foo();\n}");
-  verifyFormat("switch {\n  foo;\n  foo();\n}");
-  verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
-  verifyFormat("while {\n  foo;\n  foo();\n}");
-  verifyFormat("do {\n  foo;\n  foo();\n} while;");
-}
-
-TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
-  verifyIncompleteFormat("namespace {\n"
-                         "class Foo { Foo (\n"
-                         "};\n"
-                         "} // namespace");
-}
-
-TEST_F(FormatTest, IncorrectCodeErrorDetection) {
-  EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
-  EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
-  EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
-  EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
-
-  EXPECT_EQ("{\n"
-            "  {\n"
-            "    breakme(\n"
-            "        qwe);\n"
-            "  }\n",
-            format("{\n"
-                   "    {\n"
-                   " breakme(qwe);\n"
-                   "}\n",
-                   getLLVMStyleWithColumns(10)));
-}
-
-TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
-  verifyFormat("int x = {\n"
-               "    avariable,\n"
-               "    b(alongervariable)};",
-               getLLVMStyleWithColumns(25));
-}
-
-TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
-  verifyFormat("return (a)(b){1, 2, 3};");
-}
-
-TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
-  verifyFormat("vector<int> x{1, 2, 3, 4};");
-  verifyFormat("vector<int> x{\n"
-               "    1, 2, 3, 4,\n"
-               "};");
-  verifyFormat("vector<T> x{{}, {}, {}, {}};");
-  verifyFormat("f({1, 2});");
-  verifyFormat("auto v = Foo{-1};");
-  verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
-  verifyFormat("Class::Class : member{1, 2, 3} {}");
-  verifyFormat("new vector<int>{1, 2, 3};");
-  verifyFormat("new int[3]{1, 2, 3};");
-  verifyFormat("new int{1};");
-  verifyFormat("return {arg1, arg2};");
-  verifyFormat("return {arg1, SomeType{parameter}};");
-  verifyFormat("int count = set<int>{f(), g(), h()}.size();");
-  verifyFormat("new T{arg1, arg2};");
-  verifyFormat("f(MyMap[{composite, key}]);");
-  verifyFormat("class Class {\n"
-               "  T member = {arg1, arg2};\n"
-               "};");
-  verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
-  verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
-  verifyFormat("int a = std::is_integral<int>{} + 0;");
-
-  verifyFormat("int foo(int i) { return fo1{}(i); }");
-  verifyFormat("int foo(int i) { return fo1{}(i); }");
-  verifyFormat("auto i = decltype(x){};");
-  verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
-  verifyFormat("Node n{1, Node{1000}, //\n"
-               "       2};");
-  verifyFormat("Aaaa aaaaaaa{\n"
-               "    {\n"
-               "        aaaa,\n"
-               "    },\n"
-               "};");
-  verifyFormat("class C : public D {\n"
-               "  SomeClass SC{2};\n"
-               "};");
-  verifyFormat("class C : public A {\n"
-               "  class D : public B {\n"
-               "    void f() { int i{2}; }\n"
-               "  };\n"
-               "};");
-  verifyFormat("#define A {a, a},");
-
-  // Cases where distinguising braced lists and blocks is hard.
-  verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
-  verifyFormat("void f() {\n"
-               "  return; // comment\n"
-               "}\n"
-               "SomeType t;");
-  verifyFormat("void f() {\n"
-               "  if (a) {\n"
-               "    f();\n"
-               "  }\n"
-               "}\n"
-               "SomeType t;");
-
-  // In combination with BinPackArguments = false.
-  FormatStyle NoBinPacking = getLLVMStyle();
-  NoBinPacking.BinPackArguments = false;
-  verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
-               "                      bbbbb,\n"
-               "                      ccccc,\n"
-               "                      ddddd,\n"
-               "                      eeeee,\n"
-               "                      ffffff,\n"
-               "                      ggggg,\n"
-               "                      hhhhhh,\n"
-               "                      iiiiii,\n"
-               "                      jjjjjj,\n"
-               "                      kkkkkk};",
-               NoBinPacking);
-  verifyFormat("const Aaaaaa aaaaa = {\n"
-               "    aaaaa,\n"
-               "    bbbbb,\n"
-               "    ccccc,\n"
-               "    ddddd,\n"
-               "    eeeee,\n"
-               "    ffffff,\n"
-               "    ggggg,\n"
-               "    hhhhhh,\n"
-               "    iiiiii,\n"
-               "    jjjjjj,\n"
-               "    kkkkkk,\n"
-               "};",
-               NoBinPacking);
-  verifyFormat(
-      "const Aaaaaa aaaaa = {\n"
-      "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
-      "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
-      "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
-      "};",
-      NoBinPacking);
-
-  // FIXME: The alignment of these trailing comments might be bad. Then again,
-  // this might be utterly useless in real code.
-  verifyFormat("Constructor::Constructor()\n"
-               "    : some_value{         //\n"
-               "                 aaaaaaa, //\n"
-               "                 bbbbbbb} {}");
-
-  // In braced lists, the first comment is always assumed to belong to the
-  // first element. Thus, it can be moved to the next or previous line as
-  // appropriate.
-  EXPECT_EQ("function({// First element:\n"
-            "          1,\n"
-            "          // Second element:\n"
-            "          2});",
-            format("function({\n"
-                   "    // First element:\n"
-                   "    1,\n"
-                   "    // Second element:\n"
-                   "    2});"));
-  EXPECT_EQ("std::vector<int> MyNumbers{\n"
-            "    // First element:\n"
-            "    1,\n"
-            "    // Second element:\n"
-            "    2};",
-            format("std::vector<int> MyNumbers{// First element:\n"
-                   "                           1,\n"
-                   "                           // Second element:\n"
-                   "                           2};",
-                   getLLVMStyleWithColumns(30)));
-  // A trailing comma should still lead to an enforced line break.
-  EXPECT_EQ("vector<int> SomeVector = {\n"
-            "    // aaa\n"
-            "    1, 2,\n"
-            "};",
-            format("vector<int> SomeVector = { // aaa\n"
-                   "    1, 2, };"));
-
-  FormatStyle ExtraSpaces = getLLVMStyle();
-  ExtraSpaces.Cpp11BracedListStyle = false;
-  ExtraSpaces.ColumnLimit = 75;
-  verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
-  verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
-  verifyFormat("f({ 1, 2 });", ExtraSpaces);
-  verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
-  verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
-  verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
-  verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
-  verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
-  verifyFormat("return { arg1, arg2 };", ExtraSpaces);
-  verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
-  verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
-  verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
-  verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
-  verifyFormat("class Class {\n"
-               "  T member = { arg1, arg2 };\n"
-               "};",
-               ExtraSpaces);
-  verifyFormat(
-      "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
-      "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
-      "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
-      ExtraSpaces);
-  verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
-  verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
-               ExtraSpaces);
-  verifyFormat(
-      "someFunction(OtherParam,\n"
-      "             BracedList{ // comment 1 (Forcing interesting break)\n"
-      "                         param1, param2,\n"
-      "                         // comment 2\n"
-      "                         param3, param4 });",
-      ExtraSpaces);
-  verifyFormat(
-      "std::this_thread::sleep_for(\n"
-      "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
-      ExtraSpaces);
-  verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
-               "    aaaaaaa,\n"
-               "    aaaaaaaaaa,\n"
-               "    aaaaa,\n"
-               "    aaaaaaaaaaaaaaa,\n"
-               "    aaa,\n"
-               "    aaaaaaaaaa,\n"
-               "    a,\n"
-               "    aaaaaaaaaaaaaaaaaaaaa,\n"
-               "    aaaaaaaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
-               "    aaaaaaa,\n"
-               "    a};");
-  verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
-}
-
-TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
-  verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
-  verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, //\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-               "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
-  verifyFormat(
-      "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
-      "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
-      "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
-      "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
-      "                 7777777};");
-  verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
-               "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
-               "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
-  verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
-               "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
-               "    // Separating comment.\n"
-               "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
-  verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
-               "    // Leading comment\n"
-               "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
-               "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
-  verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
-               "                 1, 1, 1, 1};",
-               getLLVMStyleWithColumns(39));
-  verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
-               "                 1, 1, 1, 1};",
-               getLLVMStyleWithColumns(38));
-  verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
-               "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
-               getLLVMStyleWithColumns(43));
-  verifyFormat(
-      "static unsigned SomeValues[10][3] = {\n"
-      "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
-      "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
-  verifyFormat("static auto fields = new vector<string>{\n"
-               "    \"aaaaaaaaaaaaa\",\n"
-               "    \"aaaaaaaaaaaaa\",\n"
-               "    \"aaaaaaaaaaaa\",\n"
-               "    \"aaaaaaaaaaaaaa\",\n"
-               "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
-               "    \"aaaaaaaaaaaa\",\n"
-               "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
-               "};");
-  verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
-  verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
-               "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
-               "                 3, cccccccccccccccccccccc};",
-               getLLVMStyleWithColumns(60));
-
-  // Trailing commas.
-  verifyFormat("vector<int> x = {\n"
-               "    1, 1, 1, 1, 1, 1, 1, 1,\n"
-               "};",
-               getLLVMStyleWithColumns(39));
-  verifyFormat("vector<int> x = {\n"
-               "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
-               "};",
-               getLLVMStyleWithColumns(39));
-  verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
-               "                 1, 1, 1, 1,\n"
-               "                 /**/ /**/};",
-               getLLVMStyleWithColumns(39));
-
-  // Trailing comment in the first line.
-  verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
-               "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
-               "    111111111,  222222222,  3333333333,  444444444,  //\n"
-               "    11111111,   22222222,   333333333,   44444444};");
-  // Trailing comment in the last line.
-  verifyFormat("int aaaaa[] = {\n"
-               "    1, 2, 3, // comment\n"
-               "    4, 5, 6  // comment\n"
-               "};");
-
-  // With nested lists, we should either format one item per line or all nested
-  // lists one on line.
-  // FIXME: For some nested lists, we can do better.
-  verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
-               "        {aaaaaaaaaaaaaaaaaaa},\n"
-               "        {aaaaaaaaaaaaaaaaaaaaa},\n"
-               "        {aaaaaaaaaaaaaaaaa}};",
-               getLLVMStyleWithColumns(60));
-  verifyFormat(
-      "SomeStruct my_struct_array = {\n"
-      "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
-      "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
-      "    {aaa, aaa},\n"
-      "    {aaa, aaa},\n"
-      "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
-      "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
-
-  // No column layout should be used here.
-  verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
-               "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
-
-  verifyNoCrash("a<,");
-
-  // No braced initializer here.
-  verifyFormat("void f() {\n"
-               "  struct Dummy {};\n"
-               "  f(v);\n"
-               "}");
-
-  // Long lists should be formatted in columns even if they are nested.
-  verifyFormat(
-      "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
-      "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
-
-  // Allow "single-column" layout even if that violates the column limit. There
-  // isn't going to be a better way.
-  verifyFormat("std::vector<int> a = {\n"
-               "    aaaaaaaa,\n"
-               "    aaaaaaaa,\n"
-               "    aaaaaaaa,\n"
-               "    aaaaaaaa,\n"
-               "    aaaaaaaaaa,\n"
-               "    aaaaaaaa,\n"
-               "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
-               getLLVMStyleWithColumns(30));
-  verifyFormat("vector<int> aaaa = {\n"
-               "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-               "    aaaaaa.aaaaaaa,\n"
-               "    aaaaaa.aaaaaaa,\n"
-               "    aaaaaa.aaaaaaa,\n"
-               "    aaaaaa.aaaaaaa,\n"
-               "};");
-
-  // Don't create hanging lists.
-  verifyFormat("someFunction(Param, {List1, List2,\n"
-               "                     List3});",
-               getLLVMStyleWithColumns(35));
-  verifyFormat("someFunction(Param, Param,\n"
-               "             {List1, List2,\n"
-               "              List3});",
-               getLLVMStyleWithColumns(35));
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
-               "                               aaaaaaaaaaaaaaaaaaaaaaa);");
-}
-
-TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
-  FormatStyle DoNotMerge = getLLVMStyle();
-  DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
-
-  verifyFormat("void f() { return 42; }");
-  verifyFormat("void f() {\n"
-               "  return 42;\n"
-               "}",
-               DoNotMerge);
-  verifyFormat("void f() {\n"
-               "  // Comment\n"
-               "}");
-  verifyFormat("{\n"
-               "#error {\n"
-               "  int a;\n"
-               "}");
-  verifyFormat("{\n"
-               "  int a;\n"
-               "#error {\n"
-               "}");
-  verifyFormat("void f() {} // comment");
-  verifyFormat("void f() { int a; } // comment");
-  verifyFormat("void f() {\n"
-               "} // comment",
-               DoNotMerge);
-  verifyFormat("void f() {\n"
-               "  int a;\n"
-               "} // comment",
-               DoNotMerge);
-  verifyFormat("void f() {\n"
-               "} // comment",
-               getLLVMStyleWithColumns(15));
-
-  verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
-  verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
-
-  verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
-  verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
-  verifyFormat("class C {\n"
-               "  C()\n"
-               "      : iiiiiiii(nullptr),\n"
-               "        kkkkkkk(nullptr),\n"
-               "        mmmmmmm(nullptr),\n"
-               "        nnnnnnn(nullptr) {}\n"
-               "};",
-               getGoogleStyle());
-
-  FormatStyle NoColumnLimit = getLLVMStyle();
-  NoColumnLimit.ColumnLimit = 0;
-  EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
-  EXPECT_EQ("class C {\n"
-            "  A() : b(0) {}\n"
-            "};",
-            format("class C{A():b(0){}};", NoColumnLimit));
-  EXPECT_EQ("A()\n"
-            "    : b(0) {\n"
-            "}",
-            format("A()\n:b(0)\n{\n}", NoColumnLimit));
-
-  FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
-  DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
-      FormatStyle::SFS_None;
-  EXPECT_EQ("A()\n"
-            "    : b(0) {\n"
-            "}",
-            format("A():b(0){}", DoNotMergeNoColumnLimit));
-  EXPECT_EQ("A()\n"
-            "    : b(0) {\n"
-            "}",
-            format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
-
-  verifyFormat("#define A          \\\n"
-               "  void f() {       \\\n"
-               "    int i;         \\\n"
-               "  }",
-               getLLVMStyleWithColumns(20));
-  verifyFormat("#define A           \\\n"
-               "  void f() { int i; }",
-               getLLVMStyleWithColumns(21));
-  verifyFormat("#define A            \\\n"
-               "  void f() {         \\\n"
-               "    int i;           \\\n"
-               "  }                  \\\n"
-               "  int j;",
-               getLLVMStyleWithColumns(22));
-  verifyFormat("#define A             \\\n"
-               "  void f() { int i; } \\\n"
-               "  int j;",
-               getLLVMStyleWithColumns(23));
-}
-
-TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
-  FormatStyle MergeInlineOnly = getLLVMStyle();
-  MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
-  verifyFormat("class C {\n"
-               "  int f() { return 42; }\n"
-               "};",
-               MergeInlineOnly);
-  verifyFormat("int f() {\n"
-               "  return 42;\n"
-               "}",
-               MergeInlineOnly);
-}
-
-TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
-  // Elaborate type variable declarations.
-  verifyFormat("struct foo a = {bar};\nint n;");
-  verifyFormat("class foo a = {bar};\nint n;");
-  verifyFormat("union foo a = {bar};\nint n;");
-
-  // Elaborate types inside function definitions.
-  verifyFormat("struct foo f() {}\nint n;");
-  verifyFormat("class foo f() {}\nint n;");
-  verifyFormat("union foo f() {}\nint n;");
-
-  // Templates.
-  verifyFormat("template <class X> void f() {}\nint n;");
-  verifyFormat("template <struct X> void f() {}\nint n;");
-  verifyFormat("template <union X> void f() {}\nint n;");
-
-  // Actual definitions...
-  verifyFormat("struct {\n} n;");
-  verifyFormat(
-      "template <template <class T, class Y>, class Z> class X {\n} n;");
-  verifyFormat("union Z {\n  int n;\n} x;");
-  verifyFormat("class MACRO Z {\n} n;");
-  verifyFormat("class MACRO(X) Z {\n} n;");
-  verifyFormat("class __attribute__(X) Z {\n} n;");
-  verifyFormat("class __declspec(X) Z {\n} n;");
-  verifyFormat("class A##B##C {\n} n;");
-  verifyFormat("class alignas(16) Z {\n} n;");
-  verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
-  verifyFormat("class MACROA MACRO(X) Z {\n} n;");
-
-  // Redefinition from nested context:
-  verifyFormat("class A::B::C {\n} n;");
-
-  // Template definitions.
-  verifyFormat(
-      "template <typename F>\n"
-      "Matcher(const Matcher<F> &Other,\n"
-      "        typename enable_if_c<is_base_of<F, T>::value &&\n"
-      "                             !is_same<F, T>::value>::type * = 0)\n"
-      "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
-
-  // FIXME: This is still incorrectly handled at the formatter side.
-  verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
-  verifyFormat("int i = SomeFunction(a<b, a> b);");
-
-  // FIXME:
-  // This now gets parsed incorrectly as class definition.
-  // verifyFormat("class A<int> f() {\n}\nint n;");
-
-  // Elaborate types where incorrectly parsing the structural element would
-  // break the indent.
-  verifyFormat("if (true)\n"
-               "  class X x;\n"
-               "else\n"
-               "  f();\n");
-
-  // This is simply incomplete. Formatting is not important, but must not crash.
-  verifyFormat("class A:");
-}
-
-TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
-  EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
-            format("#error Leave     all         white!!!!! space* alone!\n"));
-  EXPECT_EQ(
-      "#warning Leave     all         white!!!!! space* alone!\n",
-      format("#warning Leave     all         white!!!!! space* alone!\n"));
-  EXPECT_EQ("#error 1", format("  #  error   1"));
-  EXPECT_EQ("#warning 1", format("  #  warning 1"));
-}
-
-TEST_F(FormatTest, FormatHashIfExpressions) {
-  verifyFormat("#if AAAA && BBBB");
-  verifyFormat("#if (AAAA && BBBB)");
-  verifyFormat("#elif (AAAA && BBBB)");
-  // FIXME: Come up with a better indentation for #elif.
-  verifyFormat(
-      "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
-      "    defined(BBBBBBBB)\n"
-      "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
-      "    defined(BBBBBBBB)\n"
-      "#endif",
-      getLLVMStyleWithColumns(65));
-}
-
-TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
-  FormatStyle AllowsMergedIf = getGoogleStyle();
-  AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
-  verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
-  verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
-  verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
-  EXPECT_EQ("if (true) return 42;",
-            format("if (true)\nreturn 42;", AllowsMergedIf));
-  FormatStyle ShortMergedIf = AllowsMergedIf;
-  ShortMergedIf.ColumnLimit = 25;
-  verifyFormat("#define A \\\n"
-               "  if (true) return 42;",
-               ShortMergedIf);
-  verifyFormat("#define A \\\n"
-               "  f();    \\\n"
-               "  if (true)\n"
-               "#define B",
-               ShortMergedIf);
-  verifyFormat("#define A \\\n"
-               "  f();    \\\n"
-               "  if (true)\n"
-               "g();",
-               ShortMergedIf);
-  verifyFormat("{\n"
-               "#ifdef A\n"
-               "  // Comment\n"
-               "  if (true) continue;\n"
-               "#endif\n"
-               "  // Comment\n"
-               "  if (true) continue;\n"
-               "}",
-               ShortMergedIf);
-  ShortMergedIf.ColumnLimit = 29;
-  verifyFormat("#define A                   \\\n"
-               "  if (aaaaaaaaaa) return 1; \\\n"
-               "  return 2;",
-               ShortMergedIf);
-  ShortMergedIf.ColumnLimit = 28;
-  verifyFormat("#define A         \\\n"
-               "  if (aaaaaaaaaa) \\\n"
-               "    return 1;     \\\n"
-               "  return 2;",
-               ShortMergedIf);
-}
-
-TEST_F(FormatTest, FormatStarDependingOnContext) {
-  verifyFormat("void f(int *a);");
-  verifyFormat("void f() { f(fint * b); }");
-  verifyFormat("class A {\n  void f(int *a);\n};");
-  verifyFormat("class A {\n  int *a;\n};");
-  verifyFormat("namespace a {\n"
-               "namespace b {\n"
-               "class A {\n"
-               "  void f() {}\n"
-               "  int *a;\n"
-               "};\n"
-               "} // namespace b\n"
-               "} // namespace a");
-}
-
-TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
-  verifyFormat("while");
-  verifyFormat("operator");
-}
-
-TEST_F(FormatTest, SkipsDeeplyNestedLines) {
-  // This code would be painfully slow to format if we didn't skip it.
-  std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
-                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
-                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
-                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
-                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
-                   "A(1, 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
-                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
-  // Deeply nested part is untouched, rest is formatted.
-  EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
-            format(std::string("int    i;\n") + Code + "int    j;\n",
-                   getLLVMStyle(), IC_ExpectIncomplete));
-}
-
-//===----------------------------------------------------------------------===//
-// Objective-C tests.
-//===----------------------------------------------------------------------===//
-
-TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
-  verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
-  EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
-            format("-(NSUInteger)indexOfObject:(id)anObject;"));
-  EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
-  EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
-  EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
-            format("-(NSInteger)Method3:(id)anObject;"));
-  EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
-            format("-(NSInteger)Method4:(id)anObject;"));
-  EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
-            format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
-  EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
-            format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
-  EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
-            "forAllCells:(BOOL)flag;",
-            format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
-                   "forAllCells:(BOOL)flag;"));
-
-  // Very long objectiveC method declaration.
-  verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
-               "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
-  verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
-               "                    inRange:(NSRange)range\n"
-               "                   outRange:(NSRange)out_range\n"
-               "                  outRange1:(NSRange)out_range1\n"
-               "                  outRange2:(NSRange)out_range2\n"
-               "                  outRange3:(NSRange)out_range3\n"
-               "                  outRange4:(NSRange)out_range4\n"
-               "                  outRange5:(NSRange)out_range5\n"
-               "                  outRange6:(NSRange)out_range6\n"
-               "                  outRange7:(NSRange)out_range7\n"
-               "                  outRange8:(NSRange)out_range8\n"
-               "                  outRange9:(NSRange)out_range9;");
-
-  // When the function name has to be wrapped.
-  FormatStyle Style = getLLVMStyle();
-  Style.IndentWrappedFunctionNames = false;
-  verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
-               "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
-               "           anotherName:(NSString)bbbbbbbbbbbbbb {\n"
-               "}",
-               Style);
-  Style.IndentWrappedFunctionNames = true;
-  verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
-               "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
-               "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
-               "}",
-               Style);
-
-  verifyFormat("- (int)sum:(vector<int>)numbers;");
-  verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
-  // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
-  // protocol lists (but not for template classes):
-  // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
-
-  verifyFormat("- (int (*)())foo:(int (*)())f;");
-  verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
-
-  // If there's no return type (very rare in practice!), LLVM and Google style
-  // agree.
-  verifyFormat("- foo;");
-  verifyFormat("- foo:(int)f;");
-  verifyGoogleFormat("- foo:(int)foo;");
-}
-
-
-TEST_F(FormatTest, BreaksStringLiterals) {
-  EXPECT_EQ("\"some text \"\n"
-            "\"other\";",
-            format("\"some text other\";", getLLVMStyleWithColumns(12)));
-  EXPECT_EQ("\"some text \"\n"
-            "\"other\";",
-            format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
-  EXPECT_EQ(
-      "#define A  \\\n"
-      "  \"some \"  \\\n"
-      "  \"text \"  \\\n"
-      "  \"other\";",
-      format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
-  EXPECT_EQ(
-      "#define A  \\\n"
-      "  \"so \"    \\\n"
-      "  \"text \"  \\\n"
-      "  \"other\";",
-      format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
-
-  EXPECT_EQ("\"some text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(1)));
-  EXPECT_EQ("\"some text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("\"some \"\n"
-            "\"text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"some \"\n"
-            "\"text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"some\"\n"
-            "\" tex\"\n"
-            "\"t\"",
-            format("\"some text\"", getLLVMStyleWithColumns(6)));
-  EXPECT_EQ("\"some\"\n"
-            "\" tex\"\n"
-            "\" and\"",
-            format("\"some tex and\"", getLLVMStyleWithColumns(6)));
-  EXPECT_EQ("\"some\"\n"
-            "\"/tex\"\n"
-            "\"/and\"",
-            format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
-
-  EXPECT_EQ("variable =\n"
-            "    \"long string \"\n"
-            "    \"literal\";",
-            format("variable = \"long string literal\";",
-                   getLLVMStyleWithColumns(20)));
-
-  EXPECT_EQ("variable = f(\n"
-            "    \"long string \"\n"
-            "    \"literal\",\n"
-            "    short,\n"
-            "    loooooooooooooooooooong);",
-            format("variable = f(\"long string literal\", short, "
-                   "loooooooooooooooooooong);",
-                   getLLVMStyleWithColumns(20)));
-
-  EXPECT_EQ(
-      "f(g(\"long string \"\n"
-      "    \"literal\"),\n"
-      "  b);",
-      format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
-  EXPECT_EQ("f(g(\"long string \"\n"
-            "    \"literal\",\n"
-            "    a),\n"
-            "  b);",
-            format("f(g(\"long string literal\", a), b);",
-                   getLLVMStyleWithColumns(20)));
-  EXPECT_EQ(
-      "f(\"one two\".split(\n"
-      "    variable));",
-      format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
-  EXPECT_EQ("f(\"one two three four five six \"\n"
-            "  \"seven\".split(\n"
-            "      really_looooong_variable));",
-            format("f(\"one two three four five six seven\"."
-                   "split(really_looooong_variable));",
-                   getLLVMStyleWithColumns(33)));
-
-  EXPECT_EQ("f(\"some \"\n"
-            "  \"text\",\n"
-            "  other);",
-            format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
-
-  // Only break as a last resort.
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaa(\n"
-      "    aaaaaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
-
-  EXPECT_EQ("\"splitmea\"\n"
-            "\"trandomp\"\n"
-            "\"oint\"",
-            format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
-
-  EXPECT_EQ("\"split/\"\n"
-            "\"pathat/\"\n"
-            "\"slashes\"",
-            format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
-
-  EXPECT_EQ("\"split/\"\n"
-            "\"pathat/\"\n"
-            "\"slashes\"",
-            format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"split at \"\n"
-            "\"spaces/at/\"\n"
-            "\"slashes.at.any$\"\n"
-            "\"non-alphanumeric%\"\n"
-            "\"1111111111characte\"\n"
-            "\"rs\"",
-            format("\"split at "
-                   "spaces/at/"
-                   "slashes.at."
-                   "any$non-"
-                   "alphanumeric%"
-                   "1111111111characte"
-                   "rs\"",
-                   getLLVMStyleWithColumns(20)));
-
-  // Verify that splitting the strings understands
-  // Style::AlwaysBreakBeforeMultilineStrings.
-  EXPECT_EQ(
-      "aaaaaaaaaaaa(\n"
-      "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
-      "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
-      format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
-             "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
-             "aaaaaaaaaaaaaaaaaaaaaa\");",
-             getGoogleStyle()));
-  EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
-            "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
-            format("return \"aaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaa\";",
-                   getGoogleStyle()));
-  EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
-            "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
-            format("llvm::outs() << "
-                   "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
-                   "aaaaaaaaaaaaaaaaaaa\";"));
-  EXPECT_EQ("ffff(\n"
-            "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
-            "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
-            format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
-                   getGoogleStyle()));
-
-  FormatStyle Style = getLLVMStyleWithColumns(12);
-  Style.BreakStringLiterals = false;
-  EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
-
-  FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
-  AlignLeft.AlignEscapedNewlinesLeft = true;
-  EXPECT_EQ("#define A \\\n"
-            "  \"some \" \\\n"
-            "  \"text \" \\\n"
-            "  \"other\";",
-            format("#define A \"some text other\";", AlignLeft));
-}
-
-TEST_F(FormatTest, FullyRemoveEmptyLines) {
-  FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
-  NoEmptyLines.MaxEmptyLinesToKeep = 0;
-  EXPECT_EQ("int i = a(b());",
-            format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
-}
-
-TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
-  EXPECT_EQ(
-      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-      "(\n"
-      "    \"x\t\");",
-      format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-             "aaaaaaa("
-             "\"x\t\");"));
-}
-
-TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
-  EXPECT_EQ(
-      "u8\"utf8 string \"\n"
-      "u8\"literal\";",
-      format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ(
-      "u\"utf16 string \"\n"
-      "u\"literal\";",
-      format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ(
-      "U\"utf32 string \"\n"
-      "U\"literal\";",
-      format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ("L\"wide string \"\n"
-            "L\"literal\";",
-            format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ("@\"NSString \"\n"
-            "@\"literal\";",
-            format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
-
-  // This input makes clang-format try to split the incomplete unicode escape
-  // sequence, which used to lead to a crasher.
-  verifyNoCrash(
-      "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-      getLLVMStyleWithColumns(60));
-}
-
-TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
-  FormatStyle Style = getGoogleStyleWithColumns(15);
-  EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
-  EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
-  EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
-  EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
-  EXPECT_EQ("u8R\"x(raw literal)x\";",
-            format("u8R\"x(raw literal)x\";", Style));
-}
-
-TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
-  FormatStyle Style = getLLVMStyleWithColumns(20);
-  EXPECT_EQ(
-      "_T(\"aaaaaaaaaaaaaa\")\n"
-      "_T(\"aaaaaaaaaaaaaa\")\n"
-      "_T(\"aaaaaaaaaaaa\")",
-      format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
-  EXPECT_EQ("f(x,\n"
-            "  _T(\"aaaaaaaaaaaa\")\n"
-            "  _T(\"aaa\"),\n"
-            "  z);",
-            format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
-
-  // FIXME: Handle embedded spaces in one iteration.
-  //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
-  //            "_T(\"aaaaaaaaaaaaa\")\n"
-  //            "_T(\"aaaaaaaaaaaaa\")\n"
-  //            "_T(\"a\")",
-  //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
-  //                   getLLVMStyleWithColumns(20)));
-  EXPECT_EQ(
-      "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
-      format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
-  EXPECT_EQ("f(\n"
-            "#if !TEST\n"
-            "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
-            "#endif\n"
-            "    );",
-            format("f(\n"
-                   "#if !TEST\n"
-                   "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
-                   "#endif\n"
-                   ");"));
-  EXPECT_EQ("f(\n"
-            "\n"
-            "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
-            format("f(\n"
-                   "\n"
-                   "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
-}
-
-TEST_F(FormatTest, BreaksStringLiteralOperands) {
-  // In a function call with two operands, the second can be broken with no line
-  // break before it.
-  EXPECT_EQ("func(a, \"long long \"\n"
-            "        \"long long\");",
-            format("func(a, \"long long long long\");",
-                   getLLVMStyleWithColumns(24)));
-  // In a function call with three operands, the second must be broken with a
-  // line break before it.
-  EXPECT_EQ("func(a,\n"
-            "     \"long long long \"\n"
-            "     \"long\",\n"
-            "     c);",
-            format("func(a, \"long long long long\", c);",
-                   getLLVMStyleWithColumns(24)));
-  // In a function call with three operands, the third must be broken with a
-  // line break before it.
-  EXPECT_EQ("func(a, b,\n"
-            "     \"long long long \"\n"
-            "     \"long\");",
-            format("func(a, b, \"long long long long\");",
-                   getLLVMStyleWithColumns(24)));
-  // In a function call with three operands, both the second and the third must
-  // be broken with a line break before them.
-  EXPECT_EQ("func(a,\n"
-            "     \"long long long \"\n"
-            "     \"long\",\n"
-            "     \"long long long \"\n"
-            "     \"long\");",
-            format("func(a, \"long long long long\", \"long long long long\");",
-                   getLLVMStyleWithColumns(24)));
-  // In a chain of << with two operands, the second can be broken with no line
-  // break before it.
-  EXPECT_EQ("a << \"line line \"\n"
-            "     \"line\";",
-            format("a << \"line line line\";",
-                   getLLVMStyleWithColumns(20)));
-  // In a chain of << with three operands, the second can be broken with no line
-  // break before it.
-  EXPECT_EQ("abcde << \"line \"\n"
-            "         \"line line\"\n"
-            "      << c;",
-            format("abcde << \"line line line\" << c;",
-                   getLLVMStyleWithColumns(20)));
-  // In a chain of << with three operands, the third must be broken with a line
-  // break before it.
-  EXPECT_EQ("a << b\n"
-            "  << \"line line \"\n"
-            "     \"line\";",
-            format("a << b << \"line line line\";",
-                   getLLVMStyleWithColumns(20)));
-  // In a chain of << with three operands, the second can be broken with no line
-  // break before it and the third must be broken with a line break before it.
-  EXPECT_EQ("abcd << \"line line \"\n"
-            "        \"line\"\n"
-            "     << \"line line \"\n"
-            "        \"line\";",
-            format("abcd << \"line line line\" << \"line line line\";",
-                   getLLVMStyleWithColumns(20)));
-  // In a chain of binary operators with two operands, the second can be broken
-  // with no line break before it.
-  EXPECT_EQ("abcd + \"line line \"\n"
-            "       \"line line\";",
-            format("abcd + \"line line line line\";",
-                   getLLVMStyleWithColumns(20)));
-  // In a chain of binary operators with three operands, the second must be
-  // broken with a line break before it.
-  EXPECT_EQ("abcd +\n"
-            "    \"line line \"\n"
-            "    \"line line\" +\n"
-            "    e;",
-            format("abcd + \"line line line line\" + e;",
-                   getLLVMStyleWithColumns(20)));
-  // In a function call with two operands, with AlignAfterOpenBracket enabled,
-  // the first must be broken with a line break before it.
-  FormatStyle Style = getLLVMStyleWithColumns(25);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  EXPECT_EQ("someFunction(\n"
-            "    \"long long long \"\n"
-            "    \"long\",\n"
-            "    a);",
-            format("someFunction(\"long long long long\", a);", Style));
-}
-
-TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
-  EXPECT_EQ(
-      "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
-      "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
-      "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
-      format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
-             "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
-             "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
-}
-
-TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
-  EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
-            format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
-  EXPECT_EQ("fffffffffff(g(R\"x(\n"
-            "multiline raw string literal xxxxxxxxxxxxxx\n"
-            ")x\",\n"
-            "              a),\n"
-            "            b);",
-            format("fffffffffff(g(R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\", a), b);",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(\n"
-            "    g(R\"x(qqq\n"
-            "multiline raw string literal xxxxxxxxxxxxxx\n"
-            ")x\",\n"
-            "      a),\n"
-            "    b);",
-            format("fffffffffff(g(R\"x(qqq\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\", a), b);",
-                   getGoogleStyleWithColumns(20)));
-
-  EXPECT_EQ("fffffffffff(R\"x(\n"
-            "multiline raw string literal xxxxxxxxxxxxxx\n"
-            ")x\");",
-            format("fffffffffff(R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\");",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(R\"x(\n"
-            "multiline raw string literal xxxxxxxxxxxxxx\n"
-            ")x\" + bbbbbb);",
-            format("fffffffffff(R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\" +   bbbbbb);",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(\n"
-            "    R\"x(\n"
-            "multiline raw string literal xxxxxxxxxxxxxx\n"
-            ")x\" +\n"
-            "    bbbbbb);",
-            format("fffffffffff(\n"
-                   " R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\" + bbbbbb);",
-                   getGoogleStyleWithColumns(20)));
-}
-
-TEST_F(FormatTest, SkipsUnknownStringLiterals) {
-  verifyFormat("string a = \"unterminated;");
-  EXPECT_EQ("function(\"unterminated,\n"
-            "         OtherParameter);",
-            format("function(  \"unterminated,\n"
-                   "    OtherParameter);"));
-}
-
-TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
-  FormatStyle Style = getLLVMStyle();
-  Style.Standard = FormatStyle::LS_Cpp03;
-  EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
-            format("#define x(_a) printf(\"foo\"_a);", Style));
-}
-
-TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
-
-TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
-  EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
-            "             \"ddeeefff\");",
-            format("someFunction(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction1234567890(\n"
-            "    \"aaabbbcccdddeeefff\");",
-            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(26)));
-  EXPECT_EQ("someFunction1234567890(\n"
-            "    \"aaabbbcccdddeeeff\"\n"
-            "    \"f\");",
-            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction1234567890(\n"
-            "    \"aaabbbcccdddeeeff\"\n"
-            "    \"f\");",
-            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(24)));
-  EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
-            "             \"ddde \"\n"
-            "             \"efff\");",
-            format("someFunction(\"aaabbbcc ddde efff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
-            "             \"ddeeefff\");",
-            format("someFunction(\"aaabbbccc ddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction1234567890(\n"
-            "    \"aaabb \"\n"
-            "    \"cccdddeeefff\");",
-            format("someFunction1234567890(\"aaabb cccdddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("#define A          \\\n"
-            "  string s =       \\\n"
-            "      \"123456789\"  \\\n"
-            "      \"0\";         \\\n"
-            "  int i;",
-            format("#define A string s = \"1234567890\"; int i;",
-                   getLLVMStyleWithColumns(20)));
-  // FIXME: Put additional penalties on breaking at non-whitespace locations.
-  EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
-            "             \"dddeeeff\"\n"
-            "             \"f\");",
-            format("someFunction(\"aaabbbcc dddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-}
-
-TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
-  EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
-  EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
-  EXPECT_EQ("\"test\"\n"
-            "\"\\n\"",
-            format("\"test\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"tes\\\\\"\n"
-            "\"n\"",
-            format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\\\\\\\\"\n"
-            "\"\\n\"",
-            format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\uff01\"\n"
-            "\"test\"",
-            format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
-  EXPECT_EQ("\"\\Uff01ff02\"",
-            format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("\"\\x000000000001\"\n"
-            "\"next\"",
-            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
-  EXPECT_EQ("\"\\x000000000001next\"",
-            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
-  EXPECT_EQ("\"\\x000000000001\"",
-            format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"test\"\n"
-            "\"\\000000\"\n"
-            "\"000001\"",
-            format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
-  EXPECT_EQ("\"test\\000\"\n"
-            "\"00000000\"\n"
-            "\"1\"",
-            format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
-}
-
-TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
-  verifyFormat("void f() {\n"
-               "  return g() {}\n"
-               "  void h() {}");
-  verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
-               "g();\n"
-               "}");
-}
-
-TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
-  verifyFormat(
-      "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
-}
-
-TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
-  verifyFormat("class X {\n"
-               "  void f() {\n"
-               "  }\n"
-               "};",
-               getLLVMStyleWithColumns(12));
-}
-
-TEST_F(FormatTest, ConfigurableIndentWidth) {
-  FormatStyle EightIndent = getLLVMStyleWithColumns(18);
-  EightIndent.IndentWidth = 8;
-  EightIndent.ContinuationIndentWidth = 8;
-  verifyFormat("void f() {\n"
-               "        someFunction();\n"
-               "        if (true) {\n"
-               "                f();\n"
-               "        }\n"
-               "}",
-               EightIndent);
-  verifyFormat("class X {\n"
-               "        void f() {\n"
-               "        }\n"
-               "};",
-               EightIndent);
-  verifyFormat("int x[] = {\n"
-               "        call(),\n"
-               "        call()};",
-               EightIndent);
-}
-
-TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
-  verifyFormat("double\n"
-               "f();",
-               getLLVMStyleWithColumns(8));
-}
-
-TEST_F(FormatTest, ConfigurableUseOfTab) {
-  FormatStyle Tab = getLLVMStyleWithColumns(42);
-  Tab.IndentWidth = 8;
-  Tab.UseTab = FormatStyle::UT_Always;
-  Tab.AlignEscapedNewlinesLeft = true;
-
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
-            "    bb)\t\t// w\n"
-            "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  EXPECT_EQ("if (aaa && bbb) // w\n"
-            "\t;",
-            format("if(aaa&&bbb)// w\n"
-                   ";",
-                   Tab));
-
-  verifyFormat("class X {\n"
-               "\tvoid f() {\n"
-               "\t\tsomeFunction(parameter1,\n"
-               "\t\t\t     parameter2);\n"
-               "\t}\n"
-               "};",
-               Tab);
-  verifyFormat("#define A                        \\\n"
-               "\tvoid f() {               \\\n"
-               "\t\tsomeFunction(    \\\n"
-               "\t\t    parameter1,  \\\n"
-               "\t\t    parameter2); \\\n"
-               "\t}",
-               Tab);
-
-  Tab.TabWidth = 4;
-  Tab.IndentWidth = 8;
-  verifyFormat("class TabWidth4Indent8 {\n"
-               "\t\tvoid f() {\n"
-               "\t\t\t\tsomeFunction(parameter1,\n"
-               "\t\t\t\t\t\t\t parameter2);\n"
-               "\t\t}\n"
-               "};",
-               Tab);
-
-  Tab.TabWidth = 4;
-  Tab.IndentWidth = 4;
-  verifyFormat("class TabWidth4Indent4 {\n"
-               "\tvoid f() {\n"
-               "\t\tsomeFunction(parameter1,\n"
-               "\t\t\t\t\t parameter2);\n"
-               "\t}\n"
-               "};",
-               Tab);
-
-  Tab.TabWidth = 8;
-  Tab.IndentWidth = 4;
-  verifyFormat("class TabWidth8Indent4 {\n"
-               "    void f() {\n"
-               "\tsomeFunction(parameter1,\n"
-               "\t\t     parameter2);\n"
-               "    }\n"
-               "};",
-               Tab);
-
-  Tab.TabWidth = 8;
-  Tab.IndentWidth = 8;
-  EXPECT_EQ("/*\n"
-            "\t      a\t\tcomment\n"
-            "\t      in multiple lines\n"
-            "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
-
-  Tab.UseTab = FormatStyle::UT_ForIndentation;
-  verifyFormat("{\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "};",
-               Tab);
-  verifyFormat("enum AA {\n"
-               "\ta1, // Force multiple lines\n"
-               "\ta2,\n"
-               "\ta3\n"
-               "};",
-               Tab);
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
-            "    bb)         // w\n"
-            "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  verifyFormat("class X {\n"
-               "\tvoid f() {\n"
-               "\t\tsomeFunction(parameter1,\n"
-               "\t\t             parameter2);\n"
-               "\t}\n"
-               "};",
-               Tab);
-  verifyFormat("{\n"
-               "\tQ(\n"
-               "\t    {\n"
-               "\t\t    int a;\n"
-               "\t\t    someFunction(aaaaaaaa,\n"
-               "\t\t                 bbbbbbb);\n"
-               "\t    },\n"
-               "\t    p);\n"
-               "}",
-               Tab);
-  EXPECT_EQ("{\n"
-            "\t/* aaaa\n"
-            "\t   bbbb */\n"
-            "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "   bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-            "\t  bbbbbbbbbbbbb\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "/*\n"
-                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-            "\t// bbbbbbbbbbbbb\n"
-            "}",
-            format("{\n"
-                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-            "\t  bbbbbbbbbbbbb\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            "\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            " asdf\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   " asdf\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-
-  Tab.UseTab = FormatStyle::UT_Never;
-  EXPECT_EQ("/*\n"
-            "              a\t\tcomment\n"
-            "              in multiple lines\n"
-            "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
-  EXPECT_EQ("/* some\n"
-            "   comment */",
-            format(" \t \t /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
-            "   comment */",
-            format(" \t \t int a; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-
-  EXPECT_EQ("int a; /* some\n"
-            "comment */",
-            format(" \t \t int\ta; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("f(\"\t\t\"); /* some\n"
-            "    comment */",
-            format(" \t \t f(\"\t\t\"); /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "  /*\n"
-            "   * Comment\n"
-            "   */\n"
-            "  int i;\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t * Comment\n"
-                   "\t */\n"
-                   "\t int i;\n"
-                   "}"));
-
-  Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
-  Tab.TabWidth = 8;
-  Tab.IndentWidth = 8;
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
-            "    bb)         // w\n"
-            "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  EXPECT_EQ("if (aaa && bbb) // w\n"
-            "\t;",
-            format("if(aaa&&bbb)// w\n"
-                   ";",
-                   Tab));
-  verifyFormat("class X {\n"
-               "\tvoid f() {\n"
-               "\t\tsomeFunction(parameter1,\n"
-               "\t\t\t     parameter2);\n"
-               "\t}\n"
-               "};",
-               Tab);
-  verifyFormat("#define A                        \\\n"
-               "\tvoid f() {               \\\n"
-               "\t\tsomeFunction(    \\\n"
-               "\t\t    parameter1,  \\\n"
-               "\t\t    parameter2); \\\n"
-               "\t}",
-               Tab);
-  Tab.TabWidth = 4;
-  Tab.IndentWidth = 8;
-  verifyFormat("class TabWidth4Indent8 {\n"
-               "\t\tvoid f() {\n"
-               "\t\t\t\tsomeFunction(parameter1,\n"
-               "\t\t\t\t\t\t\t parameter2);\n"
-               "\t\t}\n"
-               "};",
-               Tab);
-  Tab.TabWidth = 4;
-  Tab.IndentWidth = 4;
-  verifyFormat("class TabWidth4Indent4 {\n"
-               "\tvoid f() {\n"
-               "\t\tsomeFunction(parameter1,\n"
-               "\t\t\t\t\t parameter2);\n"
-               "\t}\n"
-               "};",
-               Tab);
-  Tab.TabWidth = 8;
-  Tab.IndentWidth = 4;
-  verifyFormat("class TabWidth8Indent4 {\n"
-               "    void f() {\n"
-               "\tsomeFunction(parameter1,\n"
-               "\t\t     parameter2);\n"
-               "    }\n"
-               "};",
-               Tab);
-  Tab.TabWidth = 8;
-  Tab.IndentWidth = 8;
-  EXPECT_EQ("/*\n"
-            "\t      a\t\tcomment\n"
-            "\t      in multiple lines\n"
-            "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
-  verifyFormat("{\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
-               "};",
-               Tab);
-  verifyFormat("enum AA {\n"
-               "\ta1, // Force multiple lines\n"
-               "\ta2,\n"
-               "\ta3\n"
-               "};",
-               Tab);
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
-            "    bb)         // w\n"
-            "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  verifyFormat("class X {\n"
-               "\tvoid f() {\n"
-               "\t\tsomeFunction(parameter1,\n"
-               "\t\t\t     parameter2);\n"
-               "\t}\n"
-               "};",
-               Tab);
-  verifyFormat("{\n"
-               "\tQ(\n"
-               "\t    {\n"
-               "\t\t    int a;\n"
-               "\t\t    someFunction(aaaaaaaa,\n"
-               "\t\t\t\t bbbbbbb);\n"
-               "\t    },\n"
-               "\t    p);\n"
-               "}",
-               Tab);
-  EXPECT_EQ("{\n"
-            "\t/* aaaa\n"
-            "\t   bbbb */\n"
-            "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "   bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-            "\t  bbbbbbbbbbbbb\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "/*\n"
-                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-            "\t// bbbbbbbbbbbbb\n"
-            "}",
-            format("{\n"
-                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-            "\t  bbbbbbbbbbbbb\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            "\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "\t/*\n"
-            " asdf\n"
-            "\t*/\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   " asdf\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("/*\n"
-            "\t      a\t\tcomment\n"
-            "\t      in multiple lines\n"
-            "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
-  EXPECT_EQ("/* some\n"
-            "   comment */",
-            format(" \t \t /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
-            "   comment */",
-            format(" \t \t int a; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
-            "comment */",
-            format(" \t \t int\ta; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("f(\"\t\t\"); /* some\n"
-            "    comment */",
-            format(" \t \t f(\"\t\t\"); /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("{\n"
-            "  /*\n"
-            "   * Comment\n"
-            "   */\n"
-            "  int i;\n"
-            "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t * Comment\n"
-                   "\t */\n"
-                   "\t int i;\n"
-                   "}"));
-  Tab.AlignConsecutiveAssignments = true;
-  Tab.AlignConsecutiveDeclarations = true;
-  Tab.TabWidth = 4;
-  Tab.IndentWidth = 4;
-  verifyFormat("class Assign {\n"
-               "\tvoid f() {\n"
-               "\t\tint         x      = 123;\n"
-               "\t\tint         random = 4;\n"
-               "\t\tstd::string alphabet =\n"
-               "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
-               "\t}\n"
-               "};",
-               Tab);
-}
-
-TEST_F(FormatTest, CalculatesOriginalColumn) {
-  EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-            "q\"; /* some\n"
-            "       comment */",
-            format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-                   "q\"; /* some\n"
-                   "       comment */",
-                   getLLVMStyle()));
-  EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
-            "/* some\n"
-            "   comment */",
-            format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
-                   " /* some\n"
-                   "    comment */",
-                   getLLVMStyle()));
-  EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-            "qqq\n"
-            "/* some\n"
-            "   comment */",
-            format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-                   "qqq\n"
-                   " /* some\n"
-                   "    comment */",
-                   getLLVMStyle()));
-  EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-            "wwww; /* some\n"
-            "         comment */",
-            format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-                   "wwww; /* some\n"
-                   "         comment */",
-                   getLLVMStyle()));
-}
-
-TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
-  FormatStyle NoSpace = getLLVMStyle();
-  NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
-
-  verifyFormat("while(true)\n"
-               "  continue;",
-               NoSpace);
-  verifyFormat("for(;;)\n"
-               "  continue;",
-               NoSpace);
-  verifyFormat("if(true)\n"
-               "  f();\n"
-               "else if(true)\n"
-               "  f();",
-               NoSpace);
-  verifyFormat("do {\n"
-               "  do_something();\n"
-               "} while(something());",
-               NoSpace);
-  verifyFormat("switch(x) {\n"
-               "default:\n"
-               "  break;\n"
-               "}",
-               NoSpace);
-  verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
-  verifyFormat("size_t x = sizeof(x);", NoSpace);
-  verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
-  verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
-  verifyFormat("alignas(128) char a[128];", NoSpace);
-  verifyFormat("size_t x = alignof(MyType);", NoSpace);
-  verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
-  verifyFormat("int f() throw(Deprecated);", NoSpace);
-  verifyFormat("typedef void (*cb)(int);", NoSpace);
-  verifyFormat("T A::operator()();", NoSpace);
-  verifyFormat("X A::operator++(T);", NoSpace);
-
-  FormatStyle Space = getLLVMStyle();
-  Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
-
-  verifyFormat("int f ();", Space);
-  verifyFormat("void f (int a, T b) {\n"
-               "  while (true)\n"
-               "    continue;\n"
-               "}",
-               Space);
-  verifyFormat("if (true)\n"
-               "  f ();\n"
-               "else if (true)\n"
-               "  f ();",
-               Space);
-  verifyFormat("do {\n"
-               "  do_something ();\n"
-               "} while (something ());",
-               Space);
-  verifyFormat("switch (x) {\n"
-               "default:\n"
-               "  break;\n"
-               "}",
-               Space);
-  verifyFormat("A::A () : a (1) {}", Space);
-  verifyFormat("void f () __attribute__ ((asdf));", Space);
-  verifyFormat("*(&a + 1);\n"
-               "&((&a)[1]);\n"
-               "a[(b + c) * d];\n"
-               "(((a + 1) * 2) + 3) * 4;",
-               Space);
-  verifyFormat("#define A(x) x", Space);
-  verifyFormat("#define A (x) x", Space);
-  verifyFormat("#if defined(x)\n"
-               "#endif",
-               Space);
-  verifyFormat("auto i = std::make_unique<int> (5);", Space);
-  verifyFormat("size_t x = sizeof (x);", Space);
-  verifyFormat("auto f (int x) -> decltype (x);", Space);
-  verifyFormat("int f (T x) noexcept (x.create ());", Space);
-  verifyFormat("alignas (128) char a[128];", Space);
-  verifyFormat("size_t x = alignof (MyType);", Space);
-  verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
-  verifyFormat("int f () throw (Deprecated);", Space);
-  verifyFormat("typedef void (*cb) (int);", Space);
-  verifyFormat("T A::operator() ();", Space);
-  verifyFormat("X A::operator++ (T);", Space);
-}
-
-TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
-  FormatStyle Spaces = getLLVMStyle();
-
-  Spaces.SpacesInParentheses = true;
-  verifyFormat("call( x, y, z );", Spaces);
-  verifyFormat("call();", Spaces);
-  verifyFormat("std::function<void( int, int )> callback;", Spaces);
-  verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
-               Spaces);
-  verifyFormat("while ( (bool)1 )\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("for ( ;; )\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("if ( true )\n"
-               "  f();\n"
-               "else if ( true )\n"
-               "  f();",
-               Spaces);
-  verifyFormat("do {\n"
-               "  do_something( (int)i );\n"
-               "} while ( something() );",
-               Spaces);
-  verifyFormat("switch ( x ) {\n"
-               "default:\n"
-               "  break;\n"
-               "}",
-               Spaces);
-
-  Spaces.SpacesInParentheses = false;
-  Spaces.SpacesInCStyleCastParentheses = true;
-  verifyFormat("Type *A = ( Type * )P;", Spaces);
-  verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
-  verifyFormat("x = ( int32 )y;", Spaces);
-  verifyFormat("int a = ( int )(2.0f);", Spaces);
-  verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
-  verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
-  verifyFormat("#define x (( int )-1)", Spaces);
-
-  // Run the first set of tests again with:
-  Spaces.SpacesInParentheses = false;
-  Spaces.SpaceInEmptyParentheses = true;
-  Spaces.SpacesInCStyleCastParentheses = true;
-  verifyFormat("call(x, y, z);", Spaces);
-  verifyFormat("call( );", Spaces);
-  verifyFormat("std::function<void(int, int)> callback;", Spaces);
-  verifyFormat("while (( bool )1)\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("for (;;)\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("if (true)\n"
-               "  f( );\n"
-               "else if (true)\n"
-               "  f( );",
-               Spaces);
-  verifyFormat("do {\n"
-               "  do_something(( int )i);\n"
-               "} while (something( ));",
-               Spaces);
-  verifyFormat("switch (x) {\n"
-               "default:\n"
-               "  break;\n"
-               "}",
-               Spaces);
-
-  // Run the first set of tests again with:
-  Spaces.SpaceAfterCStyleCast = true;
-  verifyFormat("call(x, y, z);", Spaces);
-  verifyFormat("call( );", Spaces);
-  verifyFormat("std::function<void(int, int)> callback;", Spaces);
-  verifyFormat("while (( bool ) 1)\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("for (;;)\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("if (true)\n"
-               "  f( );\n"
-               "else if (true)\n"
-               "  f( );",
-               Spaces);
-  verifyFormat("do {\n"
-               "  do_something(( int ) i);\n"
-               "} while (something( ));",
-               Spaces);
-  verifyFormat("switch (x) {\n"
-               "default:\n"
-               "  break;\n"
-               "}",
-               Spaces);
-
-  // Run subset of tests again with:
-  Spaces.SpacesInCStyleCastParentheses = false;
-  Spaces.SpaceAfterCStyleCast = true;
-  verifyFormat("while ((bool) 1)\n"
-               "  continue;",
-               Spaces);
-  verifyFormat("do {\n"
-               "  do_something((int) i);\n"
-               "} while (something( ));",
-               Spaces);
-}
-
-TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
-  verifyFormat("int a[5];");
-  verifyFormat("a[3] += 42;");
-
-  FormatStyle Spaces = getLLVMStyle();
-  Spaces.SpacesInSquareBrackets = true;
-  // Lambdas unchanged.
-  verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
-  verifyFormat("return [i, args...] {};", Spaces);
-
-  // Not lambdas.
-  verifyFormat("int a[ 5 ];", Spaces);
-  verifyFormat("a[ 3 ] += 42;", Spaces);
-  verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
-  verifyFormat("double &operator[](int i) { return 0; }\n"
-               "int i;",
-               Spaces);
-  verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
-  verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
-  verifyFormat("int i = (*b)[ a ]->f();", Spaces);
-}
-
-TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
-  verifyFormat("int a = 5;");
-  verifyFormat("a += 42;");
-  verifyFormat("a or_eq 8;");
-
-  FormatStyle Spaces = getLLVMStyle();
-  Spaces.SpaceBeforeAssignmentOperators = false;
-  verifyFormat("int a= 5;", Spaces);
-  verifyFormat("a+= 42;", Spaces);
-  verifyFormat("a or_eq 8;", Spaces);
-}
-
-TEST_F(FormatTest, AlignConsecutiveAssignments) {
-  FormatStyle Alignment = getLLVMStyle();
-  Alignment.AlignConsecutiveAssignments = false;
-  verifyFormat("int a = 5;\n"
-               "int oneTwoThree = 123;",
-               Alignment);
-  verifyFormat("int a = 5;\n"
-               "int oneTwoThree = 123;",
-               Alignment);
-
-  Alignment.AlignConsecutiveAssignments = true;
-  verifyFormat("int a           = 5;\n"
-               "int oneTwoThree = 123;",
-               Alignment);
-  verifyFormat("int a           = method();\n"
-               "int oneTwoThree = 133;",
-               Alignment);
-  verifyFormat("a &= 5;\n"
-               "bcd *= 5;\n"
-               "ghtyf += 5;\n"
-               "dvfvdb -= 5;\n"
-               "a /= 5;\n"
-               "vdsvsv %= 5;\n"
-               "sfdbddfbdfbb ^= 5;\n"
-               "dvsdsv |= 5;\n"
-               "int dsvvdvsdvvv = 123;",
-               Alignment);
-  verifyFormat("int i = 1, j = 10;\n"
-               "something = 2000;",
-               Alignment);
-  verifyFormat("something = 2000;\n"
-               "int i = 1, j = 10;\n",
-               Alignment);
-  verifyFormat("something = 2000;\n"
-               "another   = 911;\n"
-               "int i = 1, j = 10;\n"
-               "oneMore = 1;\n"
-               "i       = 2;",
-               Alignment);
-  verifyFormat("int a   = 5;\n"
-               "int one = 1;\n"
-               "method();\n"
-               "int oneTwoThree = 123;\n"
-               "int oneTwo      = 12;",
-               Alignment);
-  verifyFormat("int oneTwoThree = 123;\n"
-               "int oneTwo      = 12;\n"
-               "method();\n",
-               Alignment);
-  verifyFormat("int oneTwoThree = 123; // comment\n"
-               "int oneTwo      = 12;  // comment",
-               Alignment);
-  EXPECT_EQ("int a = 5;\n"
-            "\n"
-            "int oneTwoThree = 123;",
-            format("int a       = 5;\n"
-                   "\n"
-                   "int oneTwoThree= 123;",
-                   Alignment));
-  EXPECT_EQ("int a   = 5;\n"
-            "int one = 1;\n"
-            "\n"
-            "int oneTwoThree = 123;",
-            format("int a = 5;\n"
-                   "int one = 1;\n"
-                   "\n"
-                   "int oneTwoThree = 123;",
-                   Alignment));
-  EXPECT_EQ("int a   = 5;\n"
-            "int one = 1;\n"
-            "\n"
-            "int oneTwoThree = 123;\n"
-            "int oneTwo      = 12;",
-            format("int a = 5;\n"
-                   "int one = 1;\n"
-                   "\n"
-                   "int oneTwoThree = 123;\n"
-                   "int oneTwo = 12;",
-                   Alignment));
-  Alignment.AlignEscapedNewlinesLeft = true;
-  verifyFormat("#define A               \\\n"
-               "  int aaaa       = 12;  \\\n"
-               "  int b          = 23;  \\\n"
-               "  int ccc        = 234; \\\n"
-               "  int dddddddddd = 2345;",
-               Alignment);
-  Alignment.AlignEscapedNewlinesLeft = false;
-  verifyFormat("#define A                                                      "
-               "                \\\n"
-               "  int aaaa       = 12;                                         "
-               "                \\\n"
-               "  int b          = 23;                                         "
-               "                \\\n"
-               "  int ccc        = 234;                                        "
-               "                \\\n"
-               "  int dddddddddd = 2345;",
-               Alignment);
-  verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
-               "k = 4, int l = 5,\n"
-               "                  int m = 6) {\n"
-               "  int j      = 10;\n"
-               "  otherThing = 1;\n"
-               "}",
-               Alignment);
-  verifyFormat("void SomeFunction(int parameter = 0) {\n"
-               "  int i   = 1;\n"
-               "  int j   = 2;\n"
-               "  int big = 10000;\n"
-               "}",
-               Alignment);
-  verifyFormat("class C {\n"
-               "public:\n"
-               "  int i            = 1;\n"
-               "  virtual void f() = 0;\n"
-               "};",
-               Alignment);
-  verifyFormat("int i = 1;\n"
-               "if (SomeType t = getSomething()) {\n"
-               "}\n"
-               "int j   = 2;\n"
-               "int big = 10000;",
-               Alignment);
-  verifyFormat("int j = 7;\n"
-               "for (int k = 0; k < N; ++k) {\n"
-               "}\n"
-               "int j   = 2;\n"
-               "int big = 10000;\n"
-               "}",
-               Alignment);
-  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  verifyFormat("int i = 1;\n"
-               "LooooooooooongType loooooooooooooooooooooongVariable\n"
-               "    = someLooooooooooooooooongFunction();\n"
-               "int j = 2;",
-               Alignment);
-  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
-  verifyFormat("int i = 1;\n"
-               "LooooooooooongType loooooooooooooooooooooongVariable =\n"
-               "    someLooooooooooooooooongFunction();\n"
-               "int j = 2;",
-               Alignment);
-
-  verifyFormat("auto lambda = []() {\n"
-               "  auto i = 0;\n"
-               "  return 0;\n"
-               "};\n"
-               "int i  = 0;\n"
-               "auto v = type{\n"
-               "    i = 1,   //\n"
-               "    (i = 2), //\n"
-               "    i = 3    //\n"
-               "};",
-               Alignment);
-
-  verifyFormat(
-      "int i      = 1;\n"
-      "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
-      "                          loooooooooooooooooooooongParameterB);\n"
-      "int j      = 2;",
-      Alignment);
-
-  verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
-               "          typename B   = very_long_type_name_1,\n"
-               "          typename T_2 = very_long_type_name_2>\n"
-               "auto foo() {}\n",
-               Alignment);
-  verifyFormat("int a, b = 1;\n"
-               "int c  = 2;\n"
-               "int dd = 3;\n",
-               Alignment);
-  verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
-               Alignment);
-  verifyFormat("for (int i = 0; i < 1; i++)\n"
-               "  int x = 1;\n",
-               Alignment);
-  verifyFormat("for (i = 0; i < 1; i++)\n"
-               "  x = 1;\n"
-               "y = 1;\n",
-               Alignment);
-}
-
-TEST_F(FormatTest, AlignConsecutiveDeclarations) {
-  FormatStyle Alignment = getLLVMStyle();
-  Alignment.AlignConsecutiveDeclarations = false;
-  verifyFormat("float const a = 5;\n"
-               "int oneTwoThree = 123;",
-               Alignment);
-  verifyFormat("int a = 5;\n"
-               "float const oneTwoThree = 123;",
-               Alignment);
-
-  Alignment.AlignConsecutiveDeclarations = true;
-  verifyFormat("float const a = 5;\n"
-               "int         oneTwoThree = 123;",
-               Alignment);
-  verifyFormat("int         a = method();\n"
-               "float const oneTwoThree = 133;",
-               Alignment);
-  verifyFormat("int i = 1, j = 10;\n"
-               "something = 2000;",
-               Alignment);
-  verifyFormat("something = 2000;\n"
-               "int i = 1, j = 10;\n",
-               Alignment);
-  verifyFormat("float      something = 2000;\n"
-               "double     another = 911;\n"
-               "int        i = 1, j = 10;\n"
-               "const int *oneMore = 1;\n"
-               "unsigned   i = 2;",
-               Alignment);
-  verifyFormat("float a = 5;\n"
-               "int   one = 1;\n"
-               "method();\n"
-               "const double       oneTwoThree = 123;\n"
-               "const unsigned int oneTwo = 12;",
-               Alignment);
-  verifyFormat("int      oneTwoThree{0}; // comment\n"
-               "unsigned oneTwo;         // comment",
-               Alignment);
-  EXPECT_EQ("float const a = 5;\n"
-            "\n"
-            "int oneTwoThree = 123;",
-            format("float const   a = 5;\n"
-                   "\n"
-                   "int           oneTwoThree= 123;",
-                   Alignment));
-  EXPECT_EQ("float a = 5;\n"
-            "int   one = 1;\n"
-            "\n"
-            "unsigned oneTwoThree = 123;",
-            format("float    a = 5;\n"
-                   "int      one = 1;\n"
-                   "\n"
-                   "unsigned oneTwoThree = 123;",
-                   Alignment));
-  EXPECT_EQ("float a = 5;\n"
-            "int   one = 1;\n"
-            "\n"
-            "unsigned oneTwoThree = 123;\n"
-            "int      oneTwo = 12;",
-            format("float    a = 5;\n"
-                   "int one = 1;\n"
-                   "\n"
-                   "unsigned oneTwoThree = 123;\n"
-                   "int oneTwo = 12;",
-                   Alignment));
-  // Function prototype alignment
-  verifyFormat("int    a();\n"
-               "double b();",
-               Alignment);
-  verifyFormat("int    a(int x);\n"
-               "double b();",
-               Alignment);
-  unsigned OldColumnLimit = Alignment.ColumnLimit;
-  // We need to set ColumnLimit to zero, in order to stress nested alignments,
-  // otherwise the function parameters will be re-flowed onto a single line.
-  Alignment.ColumnLimit = 0;
-  EXPECT_EQ("int    a(int   x,\n"
-            "         float y);\n"
-            "double b(int    x,\n"
-            "         double y);",
-            format("int a(int x,\n"
-                   " float y);\n"
-                   "double b(int x,\n"
-                   " double y);",
-                   Alignment));
-  // This ensures that function parameters of function declarations are
-  // correctly indented when their owning functions are indented.
-  // The failure case here is for 'double y' to not be indented enough.
-  EXPECT_EQ("double a(int x);\n"
-            "int    b(int    y,\n"
-            "         double z);",
-            format("double a(int x);\n"
-                   "int b(int y,\n"
-                   " double z);",
-                   Alignment));
-  // Set ColumnLimit low so that we induce wrapping immediately after
-  // the function name and opening paren.
-  Alignment.ColumnLimit = 13;
-  verifyFormat("int function(\n"
-               "    int  x,\n"
-               "    bool y);",
-               Alignment);
-  Alignment.ColumnLimit = OldColumnLimit;
-  // Ensure function pointers don't screw up recursive alignment
-  verifyFormat("int    a(int x, void (*fp)(int y));\n"
-               "double b();",
-               Alignment);
-  Alignment.AlignConsecutiveAssignments = true;
-  // Ensure recursive alignment is broken by function braces, so that the
-  // "a = 1" does not align with subsequent assignments inside the function
-  // body.
-  verifyFormat("int func(int a = 1) {\n"
-               "  int b  = 2;\n"
-               "  int cc = 3;\n"
-               "}",
-               Alignment);
-  verifyFormat("float      something = 2000;\n"
-               "double     another   = 911;\n"
-               "int        i = 1, j = 10;\n"
-               "const int *oneMore = 1;\n"
-               "unsigned   i       = 2;",
-               Alignment);
-  verifyFormat("int      oneTwoThree = {0}; // comment\n"
-               "unsigned oneTwo      = 0;   // comment",
-               Alignment);
-  // Make sure that scope is correctly tracked, in the absence of braces
-  verifyFormat("for (int i = 0; i < n; i++)\n"
-               "  j = i;\n"
-               "double x = 1;\n",
-               Alignment);
-  verifyFormat("if (int i = 0)\n"
-               "  j = i;\n"
-               "double x = 1;\n",
-               Alignment);
-  // Ensure operator[] and operator() are comprehended
-  verifyFormat("struct test {\n"
-               "  long long int foo();\n"
-               "  int           operator[](int a);\n"
-               "  double        bar();\n"
-               "};\n",
-               Alignment);
-  verifyFormat("struct test {\n"
-               "  long long int foo();\n"
-               "  int           operator()(int a);\n"
-               "  double        bar();\n"
-               "};\n",
-               Alignment);
-  EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
-            "  int const i   = 1;\n"
-            "  int *     j   = 2;\n"
-            "  int       big = 10000;\n"
-            "\n"
-            "  unsigned oneTwoThree = 123;\n"
-            "  int      oneTwo      = 12;\n"
-            "  method();\n"
-            "  float k  = 2;\n"
-            "  int   ll = 10000;\n"
-            "}",
-            format("void SomeFunction(int parameter= 0) {\n"
-                   " int const  i= 1;\n"
-                   "  int *j=2;\n"
-                   " int big  =  10000;\n"
-                   "\n"
-                   "unsigned oneTwoThree  =123;\n"
-                   "int oneTwo = 12;\n"
-                   "  method();\n"
-                   "float k= 2;\n"
-                   "int ll=10000;\n"
-                   "}",
-                   Alignment));
-  Alignment.AlignConsecutiveAssignments = false;
-  Alignment.AlignEscapedNewlinesLeft = true;
-  verifyFormat("#define A              \\\n"
-               "  int       aaaa = 12; \\\n"
-               "  float     b = 23;    \\\n"
-               "  const int ccc = 234; \\\n"
-               "  unsigned  dddddddddd = 2345;",
-               Alignment);
-  Alignment.AlignEscapedNewlinesLeft = false;
-  Alignment.ColumnLimit = 30;
-  verifyFormat("#define A                    \\\n"
-               "  int       aaaa = 12;       \\\n"
-               "  float     b = 23;          \\\n"
-               "  const int ccc = 234;       \\\n"
-               "  int       dddddddddd = 2345;",
-               Alignment);
-  Alignment.ColumnLimit = 80;
-  verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
-               "k = 4, int l = 5,\n"
-               "                  int m = 6) {\n"
-               "  const int j = 10;\n"
-               "  otherThing = 1;\n"
-               "}",
-               Alignment);
-  verifyFormat("void SomeFunction(int parameter = 0) {\n"
-               "  int const i = 1;\n"
-               "  int *     j = 2;\n"
-               "  int       big = 10000;\n"
-               "}",
-               Alignment);
-  verifyFormat("class C {\n"
-               "public:\n"
-               "  int          i = 1;\n"
-               "  virtual void f() = 0;\n"
-               "};",
-               Alignment);
-  verifyFormat("float i = 1;\n"
-               "if (SomeType t = getSomething()) {\n"
-               "}\n"
-               "const unsigned j = 2;\n"
-               "int            big = 10000;",
-               Alignment);
-  verifyFormat("float j = 7;\n"
-               "for (int k = 0; k < N; ++k) {\n"
-               "}\n"
-               "unsigned j = 2;\n"
-               "int      big = 10000;\n"
-               "}",
-               Alignment);
-  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  verifyFormat("float              i = 1;\n"
-               "LooooooooooongType loooooooooooooooooooooongVariable\n"
-               "    = someLooooooooooooooooongFunction();\n"
-               "int j = 2;",
-               Alignment);
-  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
-  verifyFormat("int                i = 1;\n"
-               "LooooooooooongType loooooooooooooooooooooongVariable =\n"
-               "    someLooooooooooooooooongFunction();\n"
-               "int j = 2;",
-               Alignment);
-
-  Alignment.AlignConsecutiveAssignments = true;
-  verifyFormat("auto lambda = []() {\n"
-               "  auto  ii = 0;\n"
-               "  float j  = 0;\n"
-               "  return 0;\n"
-               "};\n"
-               "int   i  = 0;\n"
-               "float i2 = 0;\n"
-               "auto  v  = type{\n"
-               "    i = 1,   //\n"
-               "    (i = 2), //\n"
-               "    i = 3    //\n"
-               "};",
-               Alignment);
-  Alignment.AlignConsecutiveAssignments = false;
-
-  verifyFormat(
-      "int      i = 1;\n"
-      "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
-      "                          loooooooooooooooooooooongParameterB);\n"
-      "int      j = 2;",
-      Alignment);
-
-  // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
-  // We expect declarations and assignments to align, as long as it doesn't
-  // exceed the column limit, starting a new alignment sequence whenever it
-  // happens.
-  Alignment.AlignConsecutiveAssignments = true;
-  Alignment.ColumnLimit = 30;
-  verifyFormat("float    ii              = 1;\n"
-               "unsigned j               = 2;\n"
-               "int someVerylongVariable = 1;\n"
-               "AnotherLongType  ll = 123456;\n"
-               "VeryVeryLongType k  = 2;\n"
-               "int              myvar = 1;",
-               Alignment);
-  Alignment.ColumnLimit = 80;
-  Alignment.AlignConsecutiveAssignments = false;
-
-  verifyFormat(
-      "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
-      "          typename LongType, typename B>\n"
-      "auto foo() {}\n",
-      Alignment);
-  verifyFormat("float a, b = 1;\n"
-               "int   c = 2;\n"
-               "int   dd = 3;\n",
-               Alignment);
-  verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
-               Alignment);
-  Alignment.AlignConsecutiveAssignments = true;
-  verifyFormat("float a, b = 1;\n"
-               "int   c  = 2;\n"
-               "int   dd = 3;\n",
-               Alignment);
-  verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
-               Alignment);
-  Alignment.AlignConsecutiveAssignments = false;
-
-  Alignment.ColumnLimit = 30;
-  Alignment.BinPackParameters = false;
-  verifyFormat("void foo(float     a,\n"
-               "         float     b,\n"
-               "         int       c,\n"
-               "         uint32_t *d) {\n"
-               "  int *  e = 0;\n"
-               "  float  f = 0;\n"
-               "  double g = 0;\n"
-               "}\n"
-               "void bar(ino_t     a,\n"
-               "         int       b,\n"
-               "         uint32_t *c,\n"
-               "         bool      d) {}\n",
-               Alignment);
-  Alignment.BinPackParameters = true;
-  Alignment.ColumnLimit = 80;
-}
-
-TEST_F(FormatTest, LinuxBraceBreaking) {
-  FormatStyle LinuxBraceStyle = getLLVMStyle();
-  LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
-  verifyFormat("namespace a\n"
-               "{\n"
-               "class A\n"
-               "{\n"
-               "  void f()\n"
-               "  {\n"
-               "    if (true) {\n"
-               "      a();\n"
-               "      b();\n"
-               "    } else {\n"
-               "      a();\n"
-               "    }\n"
-               "  }\n"
-               "  void g() { return; }\n"
-               "};\n"
-               "struct B {\n"
-               "  int x;\n"
-               "};\n"
-               "}\n",
-               LinuxBraceStyle);
-  verifyFormat("enum X {\n"
-               "  Y = 0,\n"
-               "}\n",
-               LinuxBraceStyle);
-  verifyFormat("struct S {\n"
-               "  int Type;\n"
-               "  union {\n"
-               "    int x;\n"
-               "    double y;\n"
-               "  } Value;\n"
-               "  class C\n"
-               "  {\n"
-               "    MyFavoriteType Value;\n"
-               "  } Class;\n"
-               "}\n",
-               LinuxBraceStyle);
-}
-
-TEST_F(FormatTest, MozillaBraceBreaking) {
-  FormatStyle MozillaBraceStyle = getLLVMStyle();
-  MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
-  MozillaBraceStyle.FixNamespaceComments = false;
-  verifyFormat("namespace a {\n"
-               "class A\n"
-               "{\n"
-               "  void f()\n"
-               "  {\n"
-               "    if (true) {\n"
-               "      a();\n"
-               "      b();\n"
-               "    }\n"
-               "  }\n"
-               "  void g() { return; }\n"
-               "};\n"
-               "enum E\n"
-               "{\n"
-               "  A,\n"
-               "  // foo\n"
-               "  B,\n"
-               "  C\n"
-               "};\n"
-               "struct B\n"
-               "{\n"
-               "  int x;\n"
-               "};\n"
-               "}\n",
-               MozillaBraceStyle);
-  verifyFormat("struct S\n"
-               "{\n"
-               "  int Type;\n"
-               "  union\n"
-               "  {\n"
-               "    int x;\n"
-               "    double y;\n"
-               "  } Value;\n"
-               "  class C\n"
-               "  {\n"
-               "    MyFavoriteType Value;\n"
-               "  } Class;\n"
-               "}\n",
-               MozillaBraceStyle);
-}
-
-TEST_F(FormatTest, StroustrupBraceBreaking) {
-  FormatStyle StroustrupBraceStyle = getLLVMStyle();
-  StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
-  verifyFormat("namespace a {\n"
-               "class A {\n"
-               "  void f()\n"
-               "  {\n"
-               "    if (true) {\n"
-               "      a();\n"
-               "      b();\n"
-               "    }\n"
-               "  }\n"
-               "  void g() { return; }\n"
-               "};\n"
-               "struct B {\n"
-               "  int x;\n"
-               "};\n"
-               "} // namespace a\n",
-               StroustrupBraceStyle);
-
-  verifyFormat("void foo()\n"
-               "{\n"
-               "  if (a) {\n"
-               "    a();\n"
-               "  }\n"
-               "  else {\n"
-               "    b();\n"
-               "  }\n"
-               "}\n",
-               StroustrupBraceStyle);
-
-  verifyFormat("#ifdef _DEBUG\n"
-               "int foo(int i = 0)\n"
-               "#else\n"
-               "int foo(int i = 5)\n"
-               "#endif\n"
-               "{\n"
-               "  return i;\n"
-               "}",
-               StroustrupBraceStyle);
-
-  verifyFormat("void foo() {}\n"
-               "void bar()\n"
-               "#ifdef _DEBUG\n"
-               "{\n"
-               "  foo();\n"
-               "}\n"
-               "#else\n"
-               "{\n"
-               "}\n"
-               "#endif",
-               StroustrupBraceStyle);
-
-  verifyFormat("void foobar() { int i = 5; }\n"
-               "#ifdef _DEBUG\n"
-               "void bar() {}\n"
-               "#else\n"
-               "void bar() { foobar(); }\n"
-               "#endif",
-               StroustrupBraceStyle);
-}
-
-TEST_F(FormatTest, AllmanBraceBreaking) {
-  FormatStyle AllmanBraceStyle = getLLVMStyle();
-  AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
-  verifyFormat("namespace a\n"
-               "{\n"
-               "class A\n"
-               "{\n"
-               "  void f()\n"
-               "  {\n"
-               "    if (true)\n"
-               "    {\n"
-               "      a();\n"
-               "      b();\n"
-               "    }\n"
-               "  }\n"
-               "  void g() { return; }\n"
-               "};\n"
-               "struct B\n"
-               "{\n"
-               "  int x;\n"
-               "};\n"
-               "}",
-               AllmanBraceStyle);
-
-  verifyFormat("void f()\n"
-               "{\n"
-               "  if (true)\n"
-               "  {\n"
-               "    a();\n"
-               "  }\n"
-               "  else if (false)\n"
-               "  {\n"
-               "    b();\n"
-               "  }\n"
-               "  else\n"
-               "  {\n"
-               "    c();\n"
-               "  }\n"
-               "}\n",
-               AllmanBraceStyle);
-
-  verifyFormat("void f()\n"
-               "{\n"
-               "  for (int i = 0; i < 10; ++i)\n"
-               "  {\n"
-               "    a();\n"
-               "  }\n"
-               "  while (false)\n"
-               "  {\n"
-               "    b();\n"
-               "  }\n"
-               "  do\n"
-               "  {\n"
-               "    c();\n"
-               "  } while (false)\n"
-               "}\n",
-               AllmanBraceStyle);
-
-  verifyFormat("void f(int a)\n"
-               "{\n"
-               "  switch (a)\n"
-               "  {\n"
-               "  case 0:\n"
-               "    break;\n"
-               "  case 1:\n"
-               "  {\n"
-               "    break;\n"
-               "  }\n"
-               "  case 2:\n"
-               "  {\n"
-               "  }\n"
-               "  break;\n"
-               "  default:\n"
-               "    break;\n"
-               "  }\n"
-               "}\n",
-               AllmanBraceStyle);
-
-  verifyFormat("enum X\n"
-               "{\n"
-               "  Y = 0,\n"
-               "}\n",
-               AllmanBraceStyle);
-  verifyFormat("enum X\n"
-               "{\n"
-               "  Y = 0\n"
-               "}\n",
-               AllmanBraceStyle);
-
-  verifyFormat("@interface BSApplicationController ()\n"
-               "{\n"
-               "@private\n"
-               "  id _extraIvar;\n"
-               "}\n"
-               "@end\n",
-               AllmanBraceStyle);
-
-  verifyFormat("#ifdef _DEBUG\n"
-               "int foo(int i = 0)\n"
-               "#else\n"
-               "int foo(int i = 5)\n"
-               "#endif\n"
-               "{\n"
-               "  return i;\n"
-               "}",
-               AllmanBraceStyle);
-
-  verifyFormat("void foo() {}\n"
-               "void bar()\n"
-               "#ifdef _DEBUG\n"
-               "{\n"
-               "  foo();\n"
-               "}\n"
-               "#else\n"
-               "{\n"
-               "}\n"
-               "#endif",
-               AllmanBraceStyle);
-
-  verifyFormat("void foobar() { int i = 5; }\n"
-               "#ifdef _DEBUG\n"
-               "void bar() {}\n"
-               "#else\n"
-               "void bar() { foobar(); }\n"
-               "#endif",
-               AllmanBraceStyle);
-
-  // This shouldn't affect ObjC blocks..
-  verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
-               "  // ...\n"
-               "  int i;\n"
-               "}];",
-               AllmanBraceStyle);
-  verifyFormat("void (^block)(void) = ^{\n"
-               "  // ...\n"
-               "  int i;\n"
-               "};",
-               AllmanBraceStyle);
-  // .. or dict literals.
-  verifyFormat("void f()\n"
-               "{\n"
-               "  [object someMethod:@{ @\"a\" : @\"b\" }];\n"
-               "}",
-               AllmanBraceStyle);
-  verifyFormat("int f()\n"
-               "{ // comment\n"
-               "  return 42;\n"
-               "}",
-               AllmanBraceStyle);
-
-  AllmanBraceStyle.ColumnLimit = 19;
-  verifyFormat("void f() { int i; }", AllmanBraceStyle);
-  AllmanBraceStyle.ColumnLimit = 18;
-  verifyFormat("void f()\n"
-               "{\n"
-               "  int i;\n"
-               "}",
-               AllmanBraceStyle);
-  AllmanBraceStyle.ColumnLimit = 80;
-
-  FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
-  BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
-  BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
-  verifyFormat("void f(bool b)\n"
-               "{\n"
-               "  if (b)\n"
-               "  {\n"
-               "    return;\n"
-               "  }\n"
-               "}\n",
-               BreakBeforeBraceShortIfs);
-  verifyFormat("void f(bool b)\n"
-               "{\n"
-               "  if (b) return;\n"
-               "}\n",
-               BreakBeforeBraceShortIfs);
-  verifyFormat("void f(bool b)\n"
-               "{\n"
-               "  while (b)\n"
-               "  {\n"
-               "    return;\n"
-               "  }\n"
-               "}\n",
-               BreakBeforeBraceShortIfs);
-}
-
-TEST_F(FormatTest, GNUBraceBreaking) {
-  FormatStyle GNUBraceStyle = getLLVMStyle();
-  GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
-  verifyFormat("namespace a\n"
-               "{\n"
-               "class A\n"
-               "{\n"
-               "  void f()\n"
-               "  {\n"
-               "    int a;\n"
-               "    {\n"
-               "      int b;\n"
-               "    }\n"
-               "    if (true)\n"
-               "      {\n"
-               "        a();\n"
-               "        b();\n"
-               "      }\n"
-               "  }\n"
-               "  void g() { return; }\n"
-               "}\n"
-               "}",
-               GNUBraceStyle);
-
-  verifyFormat("void f()\n"
-               "{\n"
-               "  if (true)\n"
-               "    {\n"
-               "      a();\n"
-               "    }\n"
-               "  else if (false)\n"
-               "    {\n"
-               "      b();\n"
-               "    }\n"
-               "  else\n"
-               "    {\n"
-               "      c();\n"
-               "    }\n"
-               "}\n",
-               GNUBraceStyle);
-
-  verifyFormat("void f()\n"
-               "{\n"
-               "  for (int i = 0; i < 10; ++i)\n"
-               "    {\n"
-               "      a();\n"
-               "    }\n"
-               "  while (false)\n"
-               "    {\n"
-               "      b();\n"
-               "    }\n"
-               "  do\n"
-               "    {\n"
-               "      c();\n"
-               "    }\n"
-               "  while (false);\n"
-               "}\n",
-               GNUBraceStyle);
-
-  verifyFormat("void f(int a)\n"
-               "{\n"
-               "  switch (a)\n"
-               "    {\n"
-               "    case 0:\n"
-               "      break;\n"
-               "    case 1:\n"
-               "      {\n"
-               "        break;\n"
-               "      }\n"
-               "    case 2:\n"
-               "      {\n"
-               "      }\n"
-               "      break;\n"
-               "    default:\n"
-               "      break;\n"
-               "    }\n"
-               "}\n",
-               GNUBraceStyle);
-
-  verifyFormat("enum X\n"
-               "{\n"
-               "  Y = 0,\n"
-               "}\n",
-               GNUBraceStyle);
-
-  verifyFormat("@interface BSApplicationController ()\n"
-               "{\n"
-               "@private\n"
-               "  id _extraIvar;\n"
-               "}\n"
-               "@end\n",
-               GNUBraceStyle);
-
-  verifyFormat("#ifdef _DEBUG\n"
-               "int foo(int i = 0)\n"
-               "#else\n"
-               "int foo(int i = 5)\n"
-               "#endif\n"
-               "{\n"
-               "  return i;\n"
-               "}",
-               GNUBraceStyle);
-
-  verifyFormat("void foo() {}\n"
-               "void bar()\n"
-               "#ifdef _DEBUG\n"
-               "{\n"
-               "  foo();\n"
-               "}\n"
-               "#else\n"
-               "{\n"
-               "}\n"
-               "#endif",
-               GNUBraceStyle);
-
-  verifyFormat("void foobar() { int i = 5; }\n"
-               "#ifdef _DEBUG\n"
-               "void bar() {}\n"
-               "#else\n"
-               "void bar() { foobar(); }\n"
-               "#endif",
-               GNUBraceStyle);
-}
-
-TEST_F(FormatTest, WebKitBraceBreaking) {
-  FormatStyle WebKitBraceStyle = getLLVMStyle();
-  WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
-  WebKitBraceStyle.FixNamespaceComments = false;
-  verifyFormat("namespace a {\n"
-               "class A {\n"
-               "  void f()\n"
-               "  {\n"
-               "    if (true) {\n"
-               "      a();\n"
-               "      b();\n"
-               "    }\n"
-               "  }\n"
-               "  void g() { return; }\n"
-               "};\n"
-               "enum E {\n"
-               "  A,\n"
-               "  // foo\n"
-               "  B,\n"
-               "  C\n"
-               "};\n"
-               "struct B {\n"
-               "  int x;\n"
-               "};\n"
-               "}\n",
-               WebKitBraceStyle);
-  verifyFormat("struct S {\n"
-               "  int Type;\n"
-               "  union {\n"
-               "    int x;\n"
-               "    double y;\n"
-               "  } Value;\n"
-               "  class C {\n"
-               "    MyFavoriteType Value;\n"
-               "  } Class;\n"
-               "};\n",
-               WebKitBraceStyle);
-}
-
-TEST_F(FormatTest, CatchExceptionReferenceBinding) {
-  verifyFormat("void f() {\n"
-               "  try {\n"
-               "  } catch (const Exception &e) {\n"
-               "  }\n"
-               "}\n",
-               getLLVMStyle());
-}
-
-TEST_F(FormatTest, UnderstandsPragmas) {
-  verifyFormat("#pragma omp reduction(| : var)");
-  verifyFormat("#pragma omp reduction(+ : var)");
-
-  EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
-            "(including parentheses).",
-            format("#pragma    mark   Any non-hyphenated or hyphenated string "
-                   "(including parentheses)."));
-}
-
-TEST_F(FormatTest, UnderstandPragmaOption) {
-  verifyFormat("#pragma option -C -A");
-
-  EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
-}
-
-#define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
-  for (size_t i = 1; i < Styles.size(); ++i)                                   \
-  EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
-                                  << " differs from Style #0"
-
-TEST_F(FormatTest, GetsPredefinedStyleByName) {
-  SmallVector<FormatStyle, 3> Styles;
-  Styles.resize(3);
-
-  Styles[0] = getLLVMStyle();
-  EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
-  EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles[0] = getGoogleStyle();
-  EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
-  EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
-  EXPECT_TRUE(
-      getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
-  EXPECT_TRUE(
-      getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
-  EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
-  EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles[0] = getMozillaStyle();
-  EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
-  EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles[0] = getWebKitStyle();
-  EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
-  EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles[0] = getGNUStyle();
-  EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
-  EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
-}
-
-TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
-  SmallVector<FormatStyle, 8> Styles;
-  Styles.resize(2);
-
-  Styles[0] = getGoogleStyle();
-  Styles[1] = getLLVMStyle();
-  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-
-  Styles.resize(5);
-  Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
-  Styles[1] = getLLVMStyle();
-  Styles[1].Language = FormatStyle::LK_JavaScript;
-  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
-
-  Styles[2] = getLLVMStyle();
-  Styles[2].Language = FormatStyle::LK_JavaScript;
-  EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
-                                  "BasedOnStyle: Google",
-                                  &Styles[2])
-                   .value());
-
-  Styles[3] = getLLVMStyle();
-  Styles[3].Language = FormatStyle::LK_JavaScript;
-  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
-                                  "Language: JavaScript",
-                                  &Styles[3])
-                   .value());
-
-  Styles[4] = getLLVMStyle();
-  Styles[4].Language = FormatStyle::LK_JavaScript;
-  EXPECT_EQ(0, parseConfiguration("---\n"
-                                  "BasedOnStyle: LLVM\n"
-                                  "IndentWidth: 123\n"
-                                  "---\n"
-                                  "BasedOnStyle: Google\n"
-                                  "Language: JavaScript",
-                                  &Styles[4])
-                   .value());
-  EXPECT_ALL_STYLES_EQUAL(Styles);
-}
-
-#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
-  Style.FIELD = false;                                                         \
-  EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
-  EXPECT_TRUE(Style.FIELD);                                                    \
-  EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
-  EXPECT_FALSE(Style.FIELD);
-
-#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
-
-#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
-  Style.STRUCT.FIELD = false;                                                  \
-  EXPECT_EQ(0,                                                                 \
-            parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
-                .value());                                                     \
-  EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
-  EXPECT_EQ(0,                                                                 \
-            parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
-                .value());                                                     \
-  EXPECT_FALSE(Style.STRUCT.FIELD);
-
-#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
-  CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
-
-#define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
-  EXPECT_NE(VALUE, Style.FIELD);                                               \
-  EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
-  EXPECT_EQ(VALUE, Style.FIELD)
-
-TEST_F(FormatTest, ParsesConfigurationBools) {
-  FormatStyle Style = {};
-  Style.Language = FormatStyle::LK_Cpp;
-  CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
-  CHECK_PARSE_BOOL(AlignOperands);
-  CHECK_PARSE_BOOL(AlignTrailingComments);
-  CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
-  CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
-  CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
-  CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
-  CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
-  CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
-  CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
-  CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
-  CHECK_PARSE_BOOL(BinPackArguments);
-  CHECK_PARSE_BOOL(BinPackParameters);
-  CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
-  CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
-  CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
-  CHECK_PARSE_BOOL(BreakStringLiterals);
-  CHECK_PARSE_BOOL(BreakBeforeInheritanceComma)
-  CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
-  CHECK_PARSE_BOOL(DerivePointerAlignment);
-  CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
-  CHECK_PARSE_BOOL(DisableFormat);
-  CHECK_PARSE_BOOL(IndentCaseLabels);
-  CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
-  CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
-  CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
-  CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
-  CHECK_PARSE_BOOL(Cpp11BracedListStyle);
-  CHECK_PARSE_BOOL(ReflowComments);
-  CHECK_PARSE_BOOL(SortIncludes);
-  CHECK_PARSE_BOOL(SpacesInParentheses);
-  CHECK_PARSE_BOOL(SpacesInSquareBrackets);
-  CHECK_PARSE_BOOL(SpacesInAngles);
-  CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
-  CHECK_PARSE_BOOL(SpacesInContainerLiterals);
-  CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
-  CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
-  CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
-  CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
-
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
-  CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
-}
-
-#undef CHECK_PARSE_BOOL
-
-TEST_F(FormatTest, ParsesConfiguration) {
-  FormatStyle Style = {};
-  Style.Language = FormatStyle::LK_Cpp;
-  CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
-  CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
-              ConstructorInitializerIndentWidth, 1234u);
-  CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
-  CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
-  CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
-  CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
-              PenaltyBreakBeforeFirstCallParameter, 1234u);
-  CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
-  CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
-              PenaltyReturnTypeOnItsOwnLine, 1234u);
-  CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
-              SpacesBeforeTrailingComments, 1234u);
-  CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
-  CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
-  CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
-
-  Style.PointerAlignment = FormatStyle::PAS_Middle;
-  CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
-              FormatStyle::PAS_Left);
-  CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
-              FormatStyle::PAS_Right);
-  CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
-              FormatStyle::PAS_Middle);
-  // For backward compatibility:
-  CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
-              FormatStyle::PAS_Left);
-  CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
-              FormatStyle::PAS_Right);
-  CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
-              FormatStyle::PAS_Middle);
-
-  Style.Standard = FormatStyle::LS_Auto;
-  CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
-  CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
-  CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
-  CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
-  CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
-
-  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
-  CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
-              BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
-  CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
-              FormatStyle::BOS_None);
-  CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
-              FormatStyle::BOS_All);
-  // For backward compatibility:
-  CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
-              FormatStyle::BOS_None);
-  CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
-              FormatStyle::BOS_All);
-
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
-              FormatStyle::BAS_Align);
-  CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
-              FormatStyle::BAS_DontAlign);
-  CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
-              FormatStyle::BAS_AlwaysBreak);
-  // For backward compatibility:
-  CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
-              FormatStyle::BAS_DontAlign);
-  CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
-              FormatStyle::BAS_Align);
-
-  Style.UseTab = FormatStyle::UT_ForIndentation;
-  CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
-  CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
-  CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
-  CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
-              FormatStyle::UT_ForContinuationAndIndentation);
-  // For backward compatibility:
-  CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
-  CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
-
-  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
-  CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
-              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
-  CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
-              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
-  CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
-              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
-  CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
-              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
-  // For backward compatibility:
-  CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
-              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
-  CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
-              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
-
-  Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
-  CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
-              FormatStyle::SBPO_Never);
-  CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
-              FormatStyle::SBPO_Always);
-  CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
-              FormatStyle::SBPO_ControlStatements);
-  // For backward compatibility:
-  CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
-              FormatStyle::SBPO_Never);
-  CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
-              FormatStyle::SBPO_ControlStatements);
-
-  Style.ColumnLimit = 123;
-  FormatStyle BaseStyle = getLLVMStyle();
-  CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
-  CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
-
-  Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
-  CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
-              FormatStyle::BS_Attach);
-  CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
-              FormatStyle::BS_Linux);
-  CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
-              FormatStyle::BS_Mozilla);
-  CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
-              FormatStyle::BS_Stroustrup);
-  CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
-              FormatStyle::BS_Allman);
-  CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
-  CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
-              FormatStyle::BS_WebKit);
-  CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
-              FormatStyle::BS_Custom);
-
-  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
-  CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
-              FormatStyle::RTBS_None);
-  CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
-              FormatStyle::RTBS_All);
-  CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
-              AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
-  CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
-              AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
-  CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
-              AlwaysBreakAfterReturnType,
-              FormatStyle::RTBS_TopLevelDefinitions);
-
-  Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
-  CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
-              AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
-  CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
-              AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
-  CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
-              AlwaysBreakAfterDefinitionReturnType,
-              FormatStyle::DRTBS_TopLevel);
-
-  Style.NamespaceIndentation = FormatStyle::NI_All;
-  CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
-              FormatStyle::NI_None);
-  CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
-              FormatStyle::NI_Inner);
-  CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
-              FormatStyle::NI_All);
-
-  // FIXME: This is required because parsing a configuration simply overwrites
-  // the first N elements of the list instead of resetting it.
-  Style.ForEachMacros.clear();
-  std::vector<std::string> BoostForeach;
-  BoostForeach.push_back("BOOST_FOREACH");
-  CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
-  std::vector<std::string> BoostAndQForeach;
-  BoostAndQForeach.push_back("BOOST_FOREACH");
-  BoostAndQForeach.push_back("Q_FOREACH");
-  CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
-              BoostAndQForeach);
-
-  Style.IncludeCategories.clear();
-  std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2},
-                                                                  {".*", 1}};
-  CHECK_PARSE("IncludeCategories:\n"
-              "  - Regex: abc/.*\n"
-              "    Priority: 2\n"
-              "  - Regex: .*\n"
-              "    Priority: 1",
-              IncludeCategories, ExpectedCategories);
-  CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$");
-}
-
-TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
-  FormatStyle Style = {};
-  Style.Language = FormatStyle::LK_Cpp;
-  CHECK_PARSE("Language: Cpp\n"
-              "IndentWidth: 12",
-              IndentWidth, 12u);
-  EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
-                               "IndentWidth: 34",
-                               &Style),
-            ParseError::Unsuitable);
-  EXPECT_EQ(12u, Style.IndentWidth);
-  CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
-  EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
-
-  Style.Language = FormatStyle::LK_JavaScript;
-  CHECK_PARSE("Language: JavaScript\n"
-              "IndentWidth: 12",
-              IndentWidth, 12u);
-  CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
-  EXPECT_EQ(parseConfiguration("Language: Cpp\n"
-                               "IndentWidth: 34",
-                               &Style),
-            ParseError::Unsuitable);
-  EXPECT_EQ(23u, Style.IndentWidth);
-  CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
-  EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
-
-  CHECK_PARSE("BasedOnStyle: LLVM\n"
-              "IndentWidth: 67",
-              IndentWidth, 67u);
-
-  CHECK_PARSE("---\n"
-              "Language: JavaScript\n"
-              "IndentWidth: 12\n"
-              "---\n"
-              "Language: Cpp\n"
-              "IndentWidth: 34\n"
-              "...\n",
-              IndentWidth, 12u);
-
-  Style.Language = FormatStyle::LK_Cpp;
-  CHECK_PARSE("---\n"
-              "Language: JavaScript\n"
-              "IndentWidth: 12\n"
-              "---\n"
-              "Language: Cpp\n"
-              "IndentWidth: 34\n"
-              "...\n",
-              IndentWidth, 34u);
-  CHECK_PARSE("---\n"
-              "IndentWidth: 78\n"
-              "---\n"
-              "Language: JavaScript\n"
-              "IndentWidth: 56\n"
-              "...\n",
-              IndentWidth, 78u);
-
-  Style.ColumnLimit = 123;
-  Style.IndentWidth = 234;
-  Style.BreakBeforeBraces = FormatStyle::BS_Linux;
-  Style.TabWidth = 345;
-  EXPECT_FALSE(parseConfiguration("---\n"
-                                  "IndentWidth: 456\n"
-                                  "BreakBeforeBraces: Allman\n"
-                                  "---\n"
-                                  "Language: JavaScript\n"
-                                  "IndentWidth: 111\n"
-                                  "TabWidth: 111\n"
-                                  "---\n"
-                                  "Language: Cpp\n"
-                                  "BreakBeforeBraces: Stroustrup\n"
-                                  "TabWidth: 789\n"
-                                  "...\n",
-                                  &Style));
-  EXPECT_EQ(123u, Style.ColumnLimit);
-  EXPECT_EQ(456u, Style.IndentWidth);
-  EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
-  EXPECT_EQ(789u, Style.TabWidth);
-
-  EXPECT_EQ(parseConfiguration("---\n"
-                               "Language: JavaScript\n"
-                               "IndentWidth: 56\n"
-                               "---\n"
-                               "IndentWidth: 78\n"
-                               "...\n",
-                               &Style),
-            ParseError::Error);
-  EXPECT_EQ(parseConfiguration("---\n"
-                               "Language: JavaScript\n"
-                               "IndentWidth: 56\n"
-                               "---\n"
-                               "Language: JavaScript\n"
-                               "IndentWidth: 78\n"
-                               "...\n",
-                               &Style),
-            ParseError::Error);
-
-  EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
-}
-
-#undef CHECK_PARSE
-
-TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
-  FormatStyle Style = {};
-  Style.Language = FormatStyle::LK_JavaScript;
-  Style.BreakBeforeTernaryOperators = true;
-  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
-  EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
-
-  Style.BreakBeforeTernaryOperators = true;
-  EXPECT_EQ(0, parseConfiguration("---\n"
-                                  "BasedOnStyle: Google\n"
-                                  "---\n"
-                                  "Language: JavaScript\n"
-                                  "IndentWidth: 76\n"
-                                  "...\n",
-                                  &Style)
-                   .value());
-  EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
-  EXPECT_EQ(76u, Style.IndentWidth);
-  EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
-}
-
-TEST_F(FormatTest, ConfigurationRoundTripTest) {
-  FormatStyle Style = getLLVMStyle();
-  std::string YAML = configurationAsText(Style);
-  FormatStyle ParsedStyle = {};
-  ParsedStyle.Language = FormatStyle::LK_Cpp;
-  EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
-  EXPECT_EQ(Style, ParsedStyle);
-}
-
-TEST_F(FormatTest, WorksFor8bitEncodings) {
-  EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
-            "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
-            "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
-            "\"\xef\xee\xf0\xf3...\"",
-            format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
-                   "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
-                   "\xef\xee\xf0\xf3...\"",
-                   getLLVMStyleWithColumns(12)));
-}
-
-TEST_F(FormatTest, HandlesUTF8BOM) {
-  EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
-  EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
-            format("\xef\xbb\xbf#include <iostream>"));
-  EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
-            format("\xef\xbb\xbf\n#include <iostream>"));
-}
-
-// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
-#if !defined(_MSC_VER)
-
-TEST_F(FormatTest, CountsUTF8CharactersProperly) {
-  verifyFormat("\"Однажды в студёную зимнюю пору...\"",
-               getLLVMStyleWithColumns(35));
-  verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
-               getLLVMStyleWithColumns(31));
-  verifyFormat("// Однажды в студёную зимнюю пору...",
-               getLLVMStyleWithColumns(36));
-  verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
-  verifyFormat("/* Однажды в студёную зимнюю пору... */",
-               getLLVMStyleWithColumns(39));
-  verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
-               getLLVMStyleWithColumns(35));
-}
-
-TEST_F(FormatTest, SplitsUTF8Strings) {
-  // Non-printable characters' width is currently considered to be the length in
-  // bytes in UTF8. The characters can be displayed in very different manner
-  // (zero-width, single width with a substitution glyph, expanded to their code
-  // (e.g. "<8d>"), so there's no single correct way to handle them.
-  EXPECT_EQ("\"aaaaÄ\"\n"
-            "\"\xc2\x8d\";",
-            format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"aaaaaaaÄ\"\n"
-            "\"\xc2\x8d\";",
-            format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"Однажды, в \"\n"
-            "\"студёную \"\n"
-            "\"зимнюю \"\n"
-            "\"пору,\"",
-            format("\"Однажды, в студёную зимнюю пору,\"",
-                   getLLVMStyleWithColumns(13)));
-  EXPECT_EQ(
-      "\"一 二 三 \"\n"
-      "\"四 五六 \"\n"
-      "\"七 八 九 \"\n"
-      "\"十\"",
-      format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("\"一\t二 \"\n"
-            "\"\t三 \"\n"
-            "\"四 五\t六 \"\n"
-            "\"\t七 \"\n"
-            "\"八九十\tqq\"",
-            format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
-                   getLLVMStyleWithColumns(11)));
-
-  // UTF8 character in an escape sequence.
-  EXPECT_EQ("\"aaaaaa\"\n"
-            "\"\\\xC2\x8D\"",
-            format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
-}
-
-TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
-  EXPECT_EQ("const char *sssss =\n"
-            "    \"一二三四五六七八\\\n"
-            " 九 十\";",
-            format("const char *sssss = \"一二三四五六七八\\\n"
-                   " 九 十\";",
-                   getLLVMStyleWithColumns(30)));
-}
-
-TEST_F(FormatTest, SplitsUTF8LineComments) {
-  EXPECT_EQ("// aaaaÄ\xc2\x8d",
-            format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("// Я из лесу\n"
-            "// вышел; был\n"
-            "// сильный\n"
-            "// мороз.",
-            format("// Я из лесу вышел; был сильный мороз.",
-                   getLLVMStyleWithColumns(13)));
-  EXPECT_EQ("// 一二三\n"
-            "// 四五六七\n"
-            "// 八  九\n"
-            "// 十",
-            format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
-}
-
-TEST_F(FormatTest, SplitsUTF8BlockComments) {
-  EXPECT_EQ("/* Гляжу,\n"
-            " * поднимается\n"
-            " * медленно в\n"
-            " * гору\n"
-            " * Лошадка,\n"
-            " * везущая\n"
-            " * хворосту\n"
-            " * воз. */",
-            format("/* Гляжу, поднимается медленно в гору\n"
-                   " * Лошадка, везущая хворосту воз. */",
-                   getLLVMStyleWithColumns(13)));
-  EXPECT_EQ(
-      "/* 一二三\n"
-      " * 四五六七\n"
-      " * 八  九\n"
-      " * 十  */",
-      format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
-  EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
-            " * 𝕓𝕪𝕥𝕖\n"
-            " * 𝖀𝕿𝕱-𝟠 */",
-            format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
-}
-
-#endif // _MSC_VER
-
-TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
-  FormatStyle Style = getLLVMStyle();
-
-  Style.ConstructorInitializerIndentWidth = 4;
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-      "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
-      Style);
-
-  Style.ConstructorInitializerIndentWidth = 2;
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-      "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
-      Style);
-
-  Style.ConstructorInitializerIndentWidth = 0;
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
-      "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
-      Style);
-  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  verifyFormat(
-      "SomeLongTemplateVariableName<\n"
-      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
-      Style);
-  verifyFormat(
-      "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
-      "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
-      Style);
-}
-
-TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
-  FormatStyle Style = getLLVMStyle();
-  Style.BreakConstructorInitializersBeforeComma = true;
-  Style.ConstructorInitializerIndentWidth = 4;
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a)\n"
-               "    , b(b)\n"
-               "    , c(c) {}",
-               Style);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a) {}",
-               Style);
-
-  Style.ColumnLimit = 0;
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a) {}",
-               Style);
-  verifyFormat("SomeClass::Constructor() noexcept\n"
-               "    : a(a) {}",
-               Style);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a)\n"
-               "    , b(b)\n"
-               "    , c(c) {}",
-               Style);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a) {\n"
-               "  foo();\n"
-               "  bar();\n"
-               "}",
-               Style);
-
-  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a)\n"
-               "    , b(b)\n"
-               "    , c(c) {\n}",
-               Style);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a) {\n}",
-               Style);
-
-  Style.ColumnLimit = 80;
-  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
-  Style.ConstructorInitializerIndentWidth = 2;
-  verifyFormat("SomeClass::Constructor()\n"
-               "  : a(a)\n"
-               "  , b(b)\n"
-               "  , c(c) {}",
-               Style);
-
-  Style.ConstructorInitializerIndentWidth = 0;
-  verifyFormat("SomeClass::Constructor()\n"
-               ": a(a)\n"
-               ", b(b)\n"
-               ", c(c) {}",
-               Style);
-
-  Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
-  Style.ConstructorInitializerIndentWidth = 4;
-  verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
-  verifyFormat(
-      "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
-      Style);
-  verifyFormat(
-      "SomeClass::Constructor()\n"
-      "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
-      Style);
-  Style.ConstructorInitializerIndentWidth = 4;
-  Style.ColumnLimit = 60;
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : aaaaaaaa(aaaaaaaa)\n"
-               "    , aaaaaaaa(aaaaaaaa)\n"
-               "    , aaaaaaaa(aaaaaaaa) {}",
-               Style);
-}
-
-TEST_F(FormatTest, Destructors) {
-  verifyFormat("void F(int &i) { i.~int(); }");
-  verifyFormat("void F(int &i) { i->~int(); }");
-}
-
-TEST_F(FormatTest, FormatsWithWebKitStyle) {
-  FormatStyle Style = getWebKitStyle();
-
-  // Don't indent in outer namespaces.
-  verifyFormat("namespace outer {\n"
-               "int i;\n"
-               "namespace inner {\n"
-               "    int i;\n"
-               "} // namespace inner\n"
-               "} // namespace outer\n"
-               "namespace other_outer {\n"
-               "int i;\n"
-               "}",
-               Style);
-
-  // Don't indent case labels.
-  verifyFormat("switch (variable) {\n"
-               "case 1:\n"
-               "case 2:\n"
-               "    doSomething();\n"
-               "    break;\n"
-               "default:\n"
-               "    ++variable;\n"
-               "}",
-               Style);
-
-  // Wrap before binary operators.
-  EXPECT_EQ("void f()\n"
-            "{\n"
-            "    if (aaaaaaaaaaaaaaaa\n"
-            "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
-            "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
-            "        return;\n"
-            "}",
-            format("void f() {\n"
-                   "if (aaaaaaaaaaaaaaaa\n"
-                   "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
-                   "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
-                   "return;\n"
-                   "}",
-                   Style));
-
-  // Allow functions on a single line.
-  verifyFormat("void f() { return; }", Style);
-
-  // Constructor initializers are formatted one per line with the "," on the
-  // new line.
-  verifyFormat("Constructor()\n"
-               "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
-               "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
-               "          aaaaaaaaaaaaaa)\n"
-               "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
-               "{\n"
-               "}",
-               Style);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a)\n"
-               "{\n"
-               "}",
-               Style);
-  EXPECT_EQ("SomeClass::Constructor()\n"
-            "    : a(a)\n"
-            "{\n"
-            "}",
-            format("SomeClass::Constructor():a(a){}", Style));
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a)\n"
-               "    , b(b)\n"
-               "    , c(c)\n"
-               "{\n"
-               "}",
-               Style);
-  verifyFormat("SomeClass::Constructor()\n"
-               "    : a(a)\n"
-               "{\n"
-               "    foo();\n"
-               "    bar();\n"
-               "}",
-               Style);
-
-  // Access specifiers should be aligned left.
-  verifyFormat("class C {\n"
-               "public:\n"
-               "    int i;\n"
-               "};",
-               Style);
-
-  // Do not align comments.
-  verifyFormat("int a; // Do not\n"
-               "double b; // align comments.",
-               Style);
-
-  // Do not align operands.
-  EXPECT_EQ("ASSERT(aaaa\n"
-            "    || bbbb);",
-            format("ASSERT ( aaaa\n||bbbb);", Style));
-
-  // Accept input's line breaks.
-  EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
-            "    || bbbbbbbbbbbbbbb) {\n"
-            "    i++;\n"
-            "}",
-            format("if (aaaaaaaaaaaaaaa\n"
-                   "|| bbbbbbbbbbbbbbb) { i++; }",
-                   Style));
-  EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
-            "    i++;\n"
-            "}",
-            format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
-
-  // Don't automatically break all macro definitions (llvm.org/PR17842).
-  verifyFormat("#define aNumber 10", Style);
-  // However, generally keep the line breaks that the user authored.
-  EXPECT_EQ("#define aNumber \\\n"
-            "    10",
-            format("#define aNumber \\\n"
-                   " 10",
-                   Style));
-
-  // Keep empty and one-element array literals on a single line.
-  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
-            "                                  copyItems:YES];",
-            format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
-                   "copyItems:YES];",
-                   Style));
-  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
-            "                                  copyItems:YES];",
-            format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
-                   "             copyItems:YES];",
-                   Style));
-  // FIXME: This does not seem right, there should be more indentation before
-  // the array literal's entries. Nested blocks have the same problem.
-  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
-            "    @\"a\",\n"
-            "    @\"a\"\n"
-            "]\n"
-            "                                  copyItems:YES];",
-            format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
-                   "     @\"a\",\n"
-                   "     @\"a\"\n"
-                   "     ]\n"
-                   "       copyItems:YES];",
-                   Style));
-  EXPECT_EQ(
-      "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
-      "                                  copyItems:YES];",
-      format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
-             "   copyItems:YES];",
-             Style));
-
-  verifyFormat("[self.a b:c c:d];", Style);
-  EXPECT_EQ("[self.a b:c\n"
-            "        c:d];",
-            format("[self.a b:c\n"
-                   "c:d];",
-                   Style));
-}
-
-TEST_F(FormatTest, FormatsLambdas) {
-  verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
-  verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
-  verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
-  verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
-  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
-  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
-  verifyFormat("int x = f(*+[] {});");
-  verifyFormat("void f() {\n"
-               "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
-               "}\n");
-  verifyFormat("void f() {\n"
-               "  other(x.begin(), //\n"
-               "        x.end(),   //\n"
-               "        [&](int, int) { return 1; });\n"
-               "}\n");
-  verifyFormat("SomeFunction([]() { // A cool function...\n"
-               "  return 43;\n"
-               "});");
-  EXPECT_EQ("SomeFunction([]() {\n"
-            "#define A a\n"
-            "  return 43;\n"
-            "});",
-            format("SomeFunction([](){\n"
-                   "#define A a\n"
-                   "return 43;\n"
-                   "});"));
-  verifyFormat("void f() {\n"
-               "  SomeFunction([](decltype(x), A *a) {});\n"
-               "}");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    [](const aaaaaaaaaa &a) { return a; });");
-  verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
-               "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
-               "});");
-  verifyFormat("Constructor()\n"
-               "    : Field([] { // comment\n"
-               "        int i;\n"
-               "      }) {}");
-  verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
-               "  return some_parameter.size();\n"
-               "};");
-  verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
-               "    [](const string &s) { return s; };");
-  verifyFormat("int i = aaaaaa ? 1 //\n"
-               "               : [] {\n"
-               "                   return 2; //\n"
-               "                 }();");
-  verifyFormat("llvm::errs() << \"number of twos is \"\n"
-               "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
-               "                  return x == 2; // force break\n"
-               "                });");
-  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-               "    [=](int iiiiiiiiiiii) {\n"
-               "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
-               "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
-               "    });",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("SomeFunction({[&] {\n"
-               "                // comment\n"
-               "              },\n"
-               "              [&] {\n"
-               "                // comment\n"
-               "              }});");
-  verifyFormat("SomeFunction({[&] {\n"
-               "  // comment\n"
-               "}});");
-  verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
-               "                             [&]() { return true; },\n"
-               "                         aaaaa aaaaaaaaa);");
-
-  // Lambdas with return types.
-  verifyFormat("int c = []() -> int { return 2; }();\n");
-  verifyFormat("int c = []() -> int * { return 2; }();\n");
-  verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
-  verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
-  verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
-  verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
-  verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
-  verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
-  verifyFormat("[a, a]() -> a<1> {};");
-  verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
-               "                   int j) -> int {\n"
-               "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
-               "};");
-  verifyFormat(
-      "aaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
-      "      return aaaaaaaaaaaaaaaaa;\n"
-      "    });",
-      getLLVMStyleWithColumns(70));
-  verifyFormat("[]() //\n"
-               "    -> int {\n"
-               "  return 1; //\n"
-               "};");
-
-  // Multiple lambdas in the same parentheses change indentation rules.
-  verifyFormat("SomeFunction(\n"
-               "    []() {\n"
-               "      int i = 42;\n"
-               "      return i;\n"
-               "    },\n"
-               "    []() {\n"
-               "      int j = 43;\n"
-               "      return j;\n"
-               "    });");
-
-  // More complex introducers.
-  verifyFormat("return [i, args...] {};");
-
-  // Not lambdas.
-  verifyFormat("constexpr char hello[]{\"hello\"};");
-  verifyFormat("double &operator[](int i) { return 0; }\n"
-               "int i;");
-  verifyFormat("std::unique_ptr<int[]> foo() {}");
-  verifyFormat("int i = a[a][a]->f();");
-  verifyFormat("int i = (*b)[a]->f();");
-
-  // Other corner cases.
-  verifyFormat("void f() {\n"
-               "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
-               "      );\n"
-               "}");
-
-  // Lambdas created through weird macros.
-  verifyFormat("void f() {\n"
-               "  MACRO((const AA &a) { return 1; });\n"
-               "  MACRO((AA &a) { return 1; });\n"
-               "}");
-
-  verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
-               "      doo_dah();\n"
-               "      doo_dah();\n"
-               "    })) {\n"
-               "}");
-  verifyFormat("auto lambda = []() {\n"
-               "  int a = 2\n"
-               "#if A\n"
-               "          + 2\n"
-               "#endif\n"
-               "      ;\n"
-               "};");
-
-  // Lambdas with complex multiline introducers.
-  verifyFormat(
-      "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
-      "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
-      "        -> ::std::unordered_set<\n"
-      "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
-      "      //\n"
-      "    });");
-}
-
-TEST_F(FormatTest, FormatsBlocks) {
-  FormatStyle ShortBlocks = getLLVMStyle();
-  ShortBlocks.AllowShortBlocksOnASingleLine = true;
-  verifyFormat("int (^Block)(int, int);", ShortBlocks);
-  verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
-  verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
-  verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
-  verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
-  verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
-
-  verifyFormat("foo(^{ bar(); });", ShortBlocks);
-  verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
-  verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
-
-  verifyFormat("[operation setCompletionBlock:^{\n"
-               "  [self onOperationDone];\n"
-               "}];");
-  verifyFormat("int i = {[operation setCompletionBlock:^{\n"
-               "  [self onOperationDone];\n"
-               "}]};");
-  verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
-               "  f();\n"
-               "}];");
-  verifyFormat("int a = [operation block:^int(int *i) {\n"
-               "  return 1;\n"
-               "}];");
-  verifyFormat("[myObject doSomethingWith:arg1\n"
-               "                      aaa:^int(int *a) {\n"
-               "                        return 1;\n"
-               "                      }\n"
-               "                      bbb:f(a * bbbbbbbb)];");
-
-  verifyFormat("[operation setCompletionBlock:^{\n"
-               "  [self.delegate newDataAvailable];\n"
-               "}];",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
-               "  NSString *path = [self sessionFilePath];\n"
-               "  if (path) {\n"
-               "    // ...\n"
-               "  }\n"
-               "});");
-  verifyFormat("[[SessionService sharedService]\n"
-               "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
-               "      if (window) {\n"
-               "        [self windowDidLoad:window];\n"
-               "      } else {\n"
-               "        [self errorLoadingWindow];\n"
-               "      }\n"
-               "    }];");
-  verifyFormat("void (^largeBlock)(void) = ^{\n"
-               "  // ...\n"
-               "};\n",
-               getLLVMStyleWithColumns(40));
-  verifyFormat("[[SessionService sharedService]\n"
-               "    loadWindowWithCompletionBlock: //\n"
-               "        ^(SessionWindow *window) {\n"
-               "          if (window) {\n"
-               "            [self windowDidLoad:window];\n"
-               "          } else {\n"
-               "            [self errorLoadingWindow];\n"
-               "          }\n"
-               "        }];",
-               getLLVMStyleWithColumns(60));
-  verifyFormat("[myObject doSomethingWith:arg1\n"
-               "    firstBlock:^(Foo *a) {\n"
-               "      // ...\n"
-               "      int i;\n"
-               "    }\n"
-               "    secondBlock:^(Bar *b) {\n"
-               "      // ...\n"
-               "      int i;\n"
-               "    }\n"
-               "    thirdBlock:^Foo(Bar *b) {\n"
-               "      // ...\n"
-               "      int i;\n"
-               "    }];");
-  verifyFormat("[myObject doSomethingWith:arg1\n"
-               "               firstBlock:-1\n"
-               "              secondBlock:^(Bar *b) {\n"
-               "                // ...\n"
-               "                int i;\n"
-               "              }];");
-
-  verifyFormat("f(^{\n"
-               "  @autoreleasepool {\n"
-               "    if (a) {\n"
-               "      g();\n"
-               "    }\n"
-               "  }\n"
-               "});");
-  verifyFormat("Block b = ^int *(A *a, B *b) {}");
-  verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
-               "};");
-
-  FormatStyle FourIndent = getLLVMStyle();
-  FourIndent.ObjCBlockIndentWidth = 4;
-  verifyFormat("[operation setCompletionBlock:^{\n"
-               "    [self onOperationDone];\n"
-               "}];",
-               FourIndent);
-}
-
-TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
-  FormatStyle ZeroColumn = getLLVMStyle();
-  ZeroColumn.ColumnLimit = 0;
-
-  verifyFormat("[[SessionService sharedService] "
-               "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
-               "  if (window) {\n"
-               "    [self windowDidLoad:window];\n"
-               "  } else {\n"
-               "    [self errorLoadingWindow];\n"
-               "  }\n"
-               "}];",
-               ZeroColumn);
-  EXPECT_EQ("[[SessionService sharedService]\n"
-            "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
-            "      if (window) {\n"
-            "        [self windowDidLoad:window];\n"
-            "      } else {\n"
-            "        [self errorLoadingWindow];\n"
-            "      }\n"
-            "    }];",
-            format("[[SessionService sharedService]\n"
-                   "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
-                   "                if (window) {\n"
-                   "    [self windowDidLoad:window];\n"
-                   "  } else {\n"
-                   "    [self errorLoadingWindow];\n"
-                   "  }\n"
-                   "}];",
-                   ZeroColumn));
-  verifyFormat("[myObject doSomethingWith:arg1\n"
-               "    firstBlock:^(Foo *a) {\n"
-               "      // ...\n"
-               "      int i;\n"
-               "    }\n"
-               "    secondBlock:^(Bar *b) {\n"
-               "      // ...\n"
-               "      int i;\n"
-               "    }\n"
-               "    thirdBlock:^Foo(Bar *b) {\n"
-               "      // ...\n"
-               "      int i;\n"
-               "    }];",
-               ZeroColumn);
-  verifyFormat("f(^{\n"
-               "  @autoreleasepool {\n"
-               "    if (a) {\n"
-               "      g();\n"
-               "    }\n"
-               "  }\n"
-               "});",
-               ZeroColumn);
-  verifyFormat("void (^largeBlock)(void) = ^{\n"
-               "  // ...\n"
-               "};",
-               ZeroColumn);
-
-  ZeroColumn.AllowShortBlocksOnASingleLine = true;
-  EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
-            format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
-  ZeroColumn.AllowShortBlocksOnASingleLine = false;
-  EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
-            "  int i;\n"
-            "};",
-            format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
-}
-
-TEST_F(FormatTest, SupportsCRLF) {
-  EXPECT_EQ("int a;\r\n"
-            "int b;\r\n"
-            "int c;\r\n",
-            format("int a;\r\n"
-                   "  int b;\r\n"
-                   "    int c;\r\n",
-                   getLLVMStyle()));
-  EXPECT_EQ("int a;\r\n"
-            "int b;\r\n"
-            "int c;\r\n",
-            format("int a;\r\n"
-                   "  int b;\n"
-                   "    int c;\r\n",
-                   getLLVMStyle()));
-  EXPECT_EQ("int a;\n"
-            "int b;\n"
-            "int c;\n",
-            format("int a;\r\n"
-                   "  int b;\n"
-                   "    int c;\n",
-                   getLLVMStyle()));
-  EXPECT_EQ("\"aaaaaaa \"\r\n"
-            "\"bbbbbbb\";\r\n",
-            format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("#define A \\\r\n"
-            "  b;      \\\r\n"
-            "  c;      \\\r\n"
-            "  d;\r\n",
-            format("#define A \\\r\n"
-                   "  b; \\\r\n"
-                   "  c; d; \r\n",
-                   getGoogleStyle()));
-
-  EXPECT_EQ("/*\r\n"
-            "multi line block comments\r\n"
-            "should not introduce\r\n"
-            "an extra carriage return\r\n"
-            "*/\r\n",
-            format("/*\r\n"
-                   "multi line block comments\r\n"
-                   "should not introduce\r\n"
-                   "an extra carriage return\r\n"
-                   "*/\r\n"));
-}
-
-TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
-  verifyFormat("MY_CLASS(C) {\n"
-               "  int i;\n"
-               "  int j;\n"
-               "};");
-}
-
-TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
-  FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
-  TwoIndent.ContinuationIndentWidth = 2;
-
-  EXPECT_EQ("int i =\n"
-            "  longFunction(\n"
-            "    arg);",
-            format("int i = longFunction(arg);", TwoIndent));
-
-  FormatStyle SixIndent = getLLVMStyleWithColumns(20);
-  SixIndent.ContinuationIndentWidth = 6;
-
-  EXPECT_EQ("int i =\n"
-            "      longFunction(\n"
-            "            arg);",
-            format("int i = longFunction(arg);", SixIndent));
-}
-
-TEST_F(FormatTest, SpacesInAngles) {
-  FormatStyle Spaces = getLLVMStyle();
-  Spaces.SpacesInAngles = true;
-
-  verifyFormat("static_cast< int >(arg);", Spaces);
-  verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
-  verifyFormat("f< int, float >();", Spaces);
-  verifyFormat("template <> g() {}", Spaces);
-  verifyFormat("template < std::vector< int > > f() {}", Spaces);
-  verifyFormat("std::function< void(int, int) > fct;", Spaces);
-  verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
-               Spaces);
-
-  Spaces.Standard = FormatStyle::LS_Cpp03;
-  Spaces.SpacesInAngles = true;
-  verifyFormat("A< A< int > >();", Spaces);
-
-  Spaces.SpacesInAngles = false;
-  verifyFormat("A<A<int> >();", Spaces);
-
-  Spaces.Standard = FormatStyle::LS_Cpp11;
-  Spaces.SpacesInAngles = true;
-  verifyFormat("A< A< int > >();", Spaces);
-
-  Spaces.SpacesInAngles = false;
-  verifyFormat("A<A<int>>();", Spaces);
-}
-
-TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
-  FormatStyle Style = getLLVMStyle();
-  Style.SpaceAfterTemplateKeyword = false;
-  verifyFormat("template<int> void foo();", Style);
-}
-
-TEST_F(FormatTest, TripleAngleBrackets) {
-  verifyFormat("f<<<1, 1>>>();");
-  verifyFormat("f<<<1, 1, 1, s>>>();");
-  verifyFormat("f<<<a, b, c, d>>>();");
-  EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
-  verifyFormat("f<param><<<1, 1>>>();");
-  verifyFormat("f<1><<<1, 1>>>();");
-  EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-               "aaaaaaaaaaa<<<\n    1, 1>>>();");
-  verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
-               "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
-}
-
-TEST_F(FormatTest, MergeLessLessAtEnd) {
-  verifyFormat("<<");
-  EXPECT_EQ("< < <", format("\\\n<<<"));
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-               "aaallvm::outs() <<");
-  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-               "aaaallvm::outs()\n    <<");
-}
-
-TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
-  std::string code = "#if A\n"
-                     "#if B\n"
-                     "a.\n"
-                     "#endif\n"
-                     "    a = 1;\n"
-                     "#else\n"
-                     "#endif\n"
-                     "#if C\n"
-                     "#else\n"
-                     "#endif\n";
-  EXPECT_EQ(code, format(code));
-}
-
-TEST_F(FormatTest, HandleConflictMarkers) {
-  // Git/SVN conflict markers.
-  EXPECT_EQ("int a;\n"
-            "void f() {\n"
-            "  callme(some(parameter1,\n"
-            "<<<<<<< text by the vcs\n"
-            "              parameter2),\n"
-            "||||||| text by the vcs\n"
-            "              parameter2),\n"
-            "         parameter3,\n"
-            "======= text by the vcs\n"
-            "              parameter2, parameter3),\n"
-            ">>>>>>> text by the vcs\n"
-            "         otherparameter);\n",
-            format("int a;\n"
-                   "void f() {\n"
-                   "  callme(some(parameter1,\n"
-                   "<<<<<<< text by the vcs\n"
-                   "  parameter2),\n"
-                   "||||||| text by the vcs\n"
-                   "  parameter2),\n"
-                   "  parameter3,\n"
-                   "======= text by the vcs\n"
-                   "  parameter2,\n"
-                   "  parameter3),\n"
-                   ">>>>>>> text by the vcs\n"
-                   "  otherparameter);\n"));
-
-  // Perforce markers.
-  EXPECT_EQ("void f() {\n"
-            "  function(\n"
-            ">>>> text by the vcs\n"
-            "      parameter,\n"
-            "==== text by the vcs\n"
-            "      parameter,\n"
-            "==== text by the vcs\n"
-            "      parameter,\n"
-            "<<<< text by the vcs\n"
-            "      parameter);\n",
-            format("void f() {\n"
-                   "  function(\n"
-                   ">>>> text by the vcs\n"
-                   "  parameter,\n"
-                   "==== text by the vcs\n"
-                   "  parameter,\n"
-                   "==== text by the vcs\n"
-                   "  parameter,\n"
-                   "<<<< text by the vcs\n"
-                   "  parameter);\n"));
-
-  EXPECT_EQ("<<<<<<<\n"
-            "|||||||\n"
-            "=======\n"
-            ">>>>>>>",
-            format("<<<<<<<\n"
-                   "|||||||\n"
-                   "=======\n"
-                   ">>>>>>>"));
-
-  EXPECT_EQ("<<<<<<<\n"
-            "|||||||\n"
-            "int i;\n"
-            "=======\n"
-            ">>>>>>>",
-            format("<<<<<<<\n"
-                   "|||||||\n"
-                   "int i;\n"
-                   "=======\n"
-                   ">>>>>>>"));
-
-  // FIXME: Handle parsing of macros around conflict markers correctly:
-  EXPECT_EQ("#define Macro \\\n"
-            "<<<<<<<\n"
-            "Something \\\n"
-            "|||||||\n"
-            "Else \\\n"
-            "=======\n"
-            "Other \\\n"
-            ">>>>>>>\n"
-            "    End int i;\n",
-            format("#define Macro \\\n"
-                   "<<<<<<<\n"
-                   "  Something \\\n"
-                   "|||||||\n"
-                   "  Else \\\n"
-                   "=======\n"
-                   "  Other \\\n"
-                   ">>>>>>>\n"
-                   "  End\n"
-                   "int i;\n"));
-}
-
-TEST_F(FormatTest, DisableRegions) {
-  EXPECT_EQ("int i;\n"
-            "// clang-format off\n"
-            "  int j;\n"
-            "// clang-format on\n"
-            "int k;",
-            format(" int  i;\n"
-                   "   // clang-format off\n"
-                   "  int j;\n"
-                   " // clang-format on\n"
-                   "   int   k;"));
-  EXPECT_EQ("int i;\n"
-            "/* clang-format off */\n"
-            "  int j;\n"
-            "/* clang-format on */\n"
-            "int k;",
-            format(" int  i;\n"
-                   "   /* clang-format off */\n"
-                   "  int j;\n"
-                   " /* clang-format on */\n"
-                   "   int   k;"));
-
-  // Don't reflow comments within disabled regions.
-  EXPECT_EQ(
-      "// clang-format off\n"
-      "// long long long long long long line\n"
-      "/* clang-format on */\n"
-      "/* long long long\n"
-      " * long long long\n"
-      " * line */\n"
-      "int i;\n"
-      "/* clang-format off */\n"
-      "/* long long long long long long line */\n",
-      format("// clang-format off\n"
-             "// long long long long long long line\n"
-             "/* clang-format on */\n"
-             "/* long long long long long long line */\n"
-             "int i;\n"
-             "/* clang-format off */\n"
-             "/* long long long long long long line */\n",
-             getLLVMStyleWithColumns(20)));
-}
-
-TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
-  format("? ) =");
-  verifyNoCrash("#define a\\\n /**/}");
-}
-
-TEST_F(FormatTest, FormatsTableGenCode) {
-  FormatStyle Style = getLLVMStyle();
-  Style.Language = FormatStyle::LK_TableGen;
-  verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
-}
-
-TEST_F(FormatTest, ArrayOfTemplates) {
-  EXPECT_EQ("auto a = new unique_ptr<int>[10];",
-            format("auto a = new unique_ptr<int > [ 10];"));
-
-  FormatStyle Spaces = getLLVMStyle();
-  Spaces.SpacesInSquareBrackets = true;
-  EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
-            format("auto a = new unique_ptr<int > [10];", Spaces));
-}
-
-TEST_F(FormatTest, ArrayAsTemplateType) {
-  EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
-            format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
-
-  FormatStyle Spaces = getLLVMStyle();
-  Spaces.SpacesInSquareBrackets = true;
-  EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
-            format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
-}
-
-TEST_F(FormatTest, NoSpaceAfterSuper) {
-    verifyFormat("__super::FooBar();");
-}
-
-TEST(FormatStyle, GetStyleOfFile) {
-  vfs::InMemoryFileSystem FS;
-  // Test 1: format file in the same directory.
-  ASSERT_TRUE(
-      FS.addFile("/a/.clang-format", 0,
-                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
-  ASSERT_TRUE(
-      FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
-  auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
-  ASSERT_TRUE((bool)Style1);
-  ASSERT_EQ(*Style1, getLLVMStyle());
-
-  // Test 2.1: fallback to default.
-  ASSERT_TRUE(
-      FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
-  auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
-  ASSERT_TRUE((bool)Style2);
-  ASSERT_EQ(*Style2, getMozillaStyle());
-
-  // Test 2.2: no format on 'none' fallback style.
-  Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
-  ASSERT_TRUE((bool)Style2);
-  ASSERT_EQ(*Style2, getNoStyle());
-
-  // Test 2.3: format if config is found with no based style while fallback is
-  // 'none'.
-  ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
-                         llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
-  Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
-  ASSERT_TRUE((bool)Style2);
-  ASSERT_EQ(*Style2, getLLVMStyle());
-
-  // Test 2.4: format if yaml with no based style, while fallback is 'none'.
-  Style2 = getStyle("{}", "a.h", "none", "", &FS);
-  ASSERT_TRUE((bool)Style2);
-  ASSERT_EQ(*Style2, getLLVMStyle());
-
-  // Test 3: format file in parent directory.
-  ASSERT_TRUE(
-      FS.addFile("/c/.clang-format", 0,
-                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
-  ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
-                         llvm::MemoryBuffer::getMemBuffer("int i;")));
-  auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
-  ASSERT_TRUE((bool)Style3);
-  ASSERT_EQ(*Style3, getGoogleStyle());
-
-  // Test 4: error on invalid fallback style
-  auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
-  ASSERT_FALSE((bool)Style4);
-  llvm::consumeError(Style4.takeError());
-
-  // Test 5: error on invalid yaml on command line
-  auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
-  ASSERT_FALSE((bool)Style5);
-  llvm::consumeError(Style5.takeError());
-
-  // Test 6: error on invalid style
-  auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
-  ASSERT_FALSE((bool)Style6);
-  llvm::consumeError(Style6.takeError());
-
-  // Test 7: found config file, error on parsing it
-  ASSERT_TRUE(
-      FS.addFile("/d/.clang-format", 0,
-                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
-                                                  "InvalidKey: InvalidValue")));
-  ASSERT_TRUE(
-      FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
-  auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
-  ASSERT_FALSE((bool)Style7);
-  llvm::consumeError(Style7.takeError());
-}
-
-TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
-  // Column limit is 20.
-  std::string Code = "Type *a =\n"
-                     "    new Type();\n"
-                     "g(iiiii, 0, jjjjj,\n"
-                     "  0, kkkkk, 0, mm);\n"
-                     "int  bad     = format   ;";
-  std::string Expected = "auto a = new Type();\n"
-                         "g(iiiii, nullptr,\n"
-                         "  jjjjj, nullptr,\n"
-                         "  kkkkk, nullptr,\n"
-                         "  mm);\n"
-                         "int  bad     = format   ;";
-  FileID ID = Context.createInMemoryFile("format.cpp", Code);
-  tooling::Replacements Replaces = toReplacements(
-      {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
-                            "auto "),
-       tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
-                            "nullptr"),
-       tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
-                            "nullptr"),
-       tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
-                            "nullptr")});
-
-  format::FormatStyle Style = format::getLLVMStyle();
-  Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
-  auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
-  EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
-      << llvm::toString(FormattedReplaces.takeError()) << "\n";
-  auto Result = applyAllReplacements(Code, *FormattedReplaces);
-  EXPECT_TRUE(static_cast<bool>(Result));
-  EXPECT_EQ(Expected, *Result);
-}
-
-TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
-  std::string Code = "#include \"a.h\"\n"
-                     "#include \"c.h\"\n"
-                     "\n"
-                     "int main() {\n"
-                     "  return 0;\n"
-                     "}";
-  std::string Expected = "#include \"a.h\"\n"
-                         "#include \"b.h\"\n"
-                         "#include \"c.h\"\n"
-                         "\n"
-                         "int main() {\n"
-                         "  return 0;\n"
-                         "}";
-  FileID ID = Context.createInMemoryFile("fix.cpp", Code);
-  tooling::Replacements Replaces = toReplacements(
-      {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
-                            "#include \"b.h\"\n")});
-
-  format::FormatStyle Style = format::getLLVMStyle();
-  Style.SortIncludes = true;
-  auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
-  EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
-      << llvm::toString(FormattedReplaces.takeError()) << "\n";
-  auto Result = applyAllReplacements(Code, *FormattedReplaces);
-  EXPECT_TRUE(static_cast<bool>(Result));
-  EXPECT_EQ(Expected, *Result);
-}
-
-} // end namespace
-} // end namespace format
-} // end namespace clang
+//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Format/Format.h"
+
+#include "../Tooling/ReplacementTest.h"
+#include "FormatTestUtils.h"
+
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "gtest/gtest.h"
+
+#define DEBUG_TYPE "format-test"
+
+using clang::tooling::ReplacementTest;
+using clang::tooling::toReplacements;
+
+namespace clang {
+namespace format {
+namespace {
+
+FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
+
+class FormatTest : public ::testing::Test {
+protected:
+  enum IncompleteCheck {
+    IC_ExpectComplete,
+    IC_ExpectIncomplete,
+    IC_DoNotCheck
+  };
+
+  std::string format(llvm::StringRef Code,
+                     const FormatStyle &Style = getLLVMStyle(),
+                     IncompleteCheck CheckIncomplete = IC_ExpectComplete) {
+    DEBUG(llvm::errs() << "---\n");
+    DEBUG(llvm::errs() << Code << "\n\n");
+    std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
+    bool IncompleteFormat = false;
+    tooling::Replacements Replaces =
+        reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
+    if (CheckIncomplete != IC_DoNotCheck) {
+      bool ExpectedIncompleteFormat = CheckIncomplete == IC_ExpectIncomplete;
+      EXPECT_EQ(ExpectedIncompleteFormat, IncompleteFormat) << Code << "\n\n";
+    }
+    ReplacementCount = Replaces.size();
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE(static_cast<bool>(Result));
+    DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
+  }
+
+  FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
+    FormatStyle Style = getLLVMStyle();
+    Style.ColumnLimit = ColumnLimit;
+    return Style;
+  }
+
+  FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
+    FormatStyle Style = getGoogleStyle();
+    Style.ColumnLimit = ColumnLimit;
+    return Style;
+  }
+
+  void verifyFormat(llvm::StringRef Code,
+                    const FormatStyle &Style = getLLVMStyle()) {
+    EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
+    if (Style.Language == FormatStyle::LK_Cpp) {
+      // Objective-C++ is a superset of C++, so everything checked for C++
+      // needs to be checked for Objective-C++ as well.
+      FormatStyle ObjCStyle = Style;
+      ObjCStyle.Language = FormatStyle::LK_ObjC;
+      EXPECT_EQ(Code.str(), format(test::messUp(Code), ObjCStyle));
+    }
+  }
+
+  void verifyIncompleteFormat(llvm::StringRef Code,
+                              const FormatStyle &Style = getLLVMStyle()) {
+    EXPECT_EQ(Code.str(),
+              format(test::messUp(Code), Style, IC_ExpectIncomplete));
+  }
+
+  void verifyGoogleFormat(llvm::StringRef Code) {
+    verifyFormat(Code, getGoogleStyle());
+  }
+
+  void verifyIndependentOfContext(llvm::StringRef text) {
+    verifyFormat(text);
+    verifyFormat(llvm::Twine("void f() { " + text + " }").str());
+  }
+
+  /// \brief Verify that clang-format does not crash on the given input.
+  void verifyNoCrash(llvm::StringRef Code,
+                     const FormatStyle &Style = getLLVMStyle()) {
+    format(Code, Style, IC_DoNotCheck);
+  }
+
+  int ReplacementCount;
+};
+
+TEST_F(FormatTest, MessUp) {
+  EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
+  EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
+  EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
+  EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
+  EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
+}
+
+//===----------------------------------------------------------------------===//
+// Basic function tests.
+//===----------------------------------------------------------------------===//
+
+TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
+  EXPECT_EQ(";", format(";"));
+}
+
+TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
+  EXPECT_EQ("int i;", format("  int i;"));
+  EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
+  EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
+  EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
+}
+
+TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
+  EXPECT_EQ("int i;", format("int\ni;"));
+}
+
+TEST_F(FormatTest, FormatsNestedBlockStatements) {
+  EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
+}
+
+TEST_F(FormatTest, FormatsNestedCall) {
+  verifyFormat("Method(f1, f2(f3));");
+  verifyFormat("Method(f1(f2, f3()));");
+  verifyFormat("Method(f1(f2, (f3())));");
+}
+
+TEST_F(FormatTest, NestedNameSpecifiers) {
+  verifyFormat("vector<::Type> v;");
+  verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
+  verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
+  verifyFormat("bool a = 2 < ::SomeFunction();");
+  verifyFormat("ALWAYS_INLINE ::std::string getName();");
+  verifyFormat("some::string getName();");
+}
+
+TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
+  EXPECT_EQ("if (a) {\n"
+            "  f();\n"
+            "}",
+            format("if(a){f();}"));
+  EXPECT_EQ(4, ReplacementCount);
+  EXPECT_EQ("if (a) {\n"
+            "  f();\n"
+            "}",
+            format("if (a) {\n"
+                   "  f();\n"
+                   "}"));
+  EXPECT_EQ(0, ReplacementCount);
+  EXPECT_EQ("/*\r\n"
+            "\r\n"
+            "*/\r\n",
+            format("/*\r\n"
+                   "\r\n"
+                   "*/\r\n"));
+  EXPECT_EQ(0, ReplacementCount);
+}
+
+TEST_F(FormatTest, RemovesEmptyLines) {
+  EXPECT_EQ("class C {\n"
+            "  int i;\n"
+            "};",
+            format("class C {\n"
+                   " int i;\n"
+                   "\n"
+                   "};"));
+
+  // Don't remove empty lines at the start of namespaces or extern "C" blocks.
+  EXPECT_EQ("namespace N {\n"
+            "\n"
+            "int i;\n"
+            "}",
+            format("namespace N {\n"
+                   "\n"
+                   "int    i;\n"
+                   "}",
+                   getGoogleStyle()));
+  EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
+            "\n"
+            "int i;\n"
+            "}",
+            format("extern /**/ \"C\" /**/ {\n"
+                   "\n"
+                   "int    i;\n"
+                   "}",
+                   getGoogleStyle()));
+
+  // ...but do keep inlining and removing empty lines for non-block extern "C"
+  // functions.
+  verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
+  EXPECT_EQ("extern \"C\" int f() {\n"
+            "  int i = 42;\n"
+            "  return i;\n"
+            "}",
+            format("extern \"C\" int f() {\n"
+                   "\n"
+                   "  int i = 42;\n"
+                   "  return i;\n"
+                   "}",
+                   getGoogleStyle()));
+
+  // Remove empty lines at the beginning and end of blocks.
+  EXPECT_EQ("void f() {\n"
+            "\n"
+            "  if (a) {\n"
+            "\n"
+            "    f();\n"
+            "  }\n"
+            "}",
+            format("void f() {\n"
+                   "\n"
+                   "  if (a) {\n"
+                   "\n"
+                   "    f();\n"
+                   "\n"
+                   "  }\n"
+                   "\n"
+                   "}",
+                   getLLVMStyle()));
+  EXPECT_EQ("void f() {\n"
+            "  if (a) {\n"
+            "    f();\n"
+            "  }\n"
+            "}",
+            format("void f() {\n"
+                   "\n"
+                   "  if (a) {\n"
+                   "\n"
+                   "    f();\n"
+                   "\n"
+                   "  }\n"
+                   "\n"
+                   "}",
+                   getGoogleStyle()));
+
+  // Don't remove empty lines in more complex control statements.
+  EXPECT_EQ("void f() {\n"
+            "  if (a) {\n"
+            "    f();\n"
+            "\n"
+            "  } else if (b) {\n"
+            "    f();\n"
+            "  }\n"
+            "}",
+            format("void f() {\n"
+                   "  if (a) {\n"
+                   "    f();\n"
+                   "\n"
+                   "  } else if (b) {\n"
+                   "    f();\n"
+                   "\n"
+                   "  }\n"
+                   "\n"
+                   "}"));
+
+  // FIXME: This is slightly inconsistent.
+  FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
+  LLVMWithNoNamespaceFix.FixNamespaceComments = false;
+  EXPECT_EQ("namespace {\n"
+            "int i;\n"
+            "}",
+            format("namespace {\n"
+                   "int i;\n"
+                   "\n"
+                   "}", LLVMWithNoNamespaceFix));
+  EXPECT_EQ("namespace {\n"
+            "int i;\n"
+            "}",
+            format("namespace {\n"
+                   "int i;\n"
+                   "\n"
+                   "}"));
+  EXPECT_EQ("namespace {\n"
+            "int i;\n"
+            "\n"
+            "} // namespace",
+            format("namespace {\n"
+                   "int i;\n"
+                   "\n"
+                   "}  // namespace"));
+
+  FormatStyle Style = getLLVMStyle();
+  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
+  Style.MaxEmptyLinesToKeep = 2;
+  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
+  Style.BraceWrapping.AfterClass = true;
+  Style.BraceWrapping.AfterFunction = true;
+  Style.KeepEmptyLinesAtTheStartOfBlocks = false;
+
+  EXPECT_EQ("class Foo\n"
+            "{\n"
+            "  Foo() {}\n"
+            "\n"
+            "  void funk() {}\n"
+            "};",
+            format("class Foo\n"
+                   "{\n"
+                   "  Foo()\n"
+                   "  {\n"
+                   "  }\n"
+                   "\n"
+                   "  void funk() {}\n"
+                   "};",
+                   Style));
+}
+
+TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
+  verifyFormat("x = (a) and (b);");
+  verifyFormat("x = (a) or (b);");
+  verifyFormat("x = (a) bitand (b);");
+  verifyFormat("x = (a) bitor (b);");
+  verifyFormat("x = (a) not_eq (b);");
+  verifyFormat("x = (a) and_eq (b);");
+  verifyFormat("x = (a) or_eq (b);");
+  verifyFormat("x = (a) xor (b);");
+}
+
+//===----------------------------------------------------------------------===//
+// Tests for control statements.
+//===----------------------------------------------------------------------===//
+
+TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
+  verifyFormat("if (true)\n  f();\ng();");
+  verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
+  verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
+
+  FormatStyle AllowsMergedIf = getLLVMStyle();
+  AllowsMergedIf.AlignEscapedNewlinesLeft = true;
+  AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
+  verifyFormat("if (a)\n"
+               "  // comment\n"
+               "  f();",
+               AllowsMergedIf);
+  verifyFormat("{\n"
+               "  if (a)\n"
+               "  label:\n"
+               "    f();\n"
+               "}",
+               AllowsMergedIf);
+  verifyFormat("#define A \\\n"
+               "  if (a)  \\\n"
+               "  label:  \\\n"
+               "    f()",
+               AllowsMergedIf);
+  verifyFormat("if (a)\n"
+               "  ;",
+               AllowsMergedIf);
+  verifyFormat("if (a)\n"
+               "  if (b) return;",
+               AllowsMergedIf);
+
+  verifyFormat("if (a) // Can't merge this\n"
+               "  f();\n",
+               AllowsMergedIf);
+  verifyFormat("if (a) /* still don't merge */\n"
+               "  f();",
+               AllowsMergedIf);
+  verifyFormat("if (a) { // Never merge this\n"
+               "  f();\n"
+               "}",
+               AllowsMergedIf);
+  verifyFormat("if (a) { /* Never merge this */\n"
+               "  f();\n"
+               "}",
+               AllowsMergedIf);
+
+  AllowsMergedIf.ColumnLimit = 14;
+  verifyFormat("if (a) return;", AllowsMergedIf);
+  verifyFormat("if (aaaaaaaaa)\n"
+               "  return;",
+               AllowsMergedIf);
+
+  AllowsMergedIf.ColumnLimit = 13;
+  verifyFormat("if (a)\n  return;", AllowsMergedIf);
+}
+
+TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
+  FormatStyle AllowsMergedLoops = getLLVMStyle();
+  AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
+  verifyFormat("while (true) continue;", AllowsMergedLoops);
+  verifyFormat("for (;;) continue;", AllowsMergedLoops);
+  verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
+  verifyFormat("while (true)\n"
+               "  ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;)\n"
+               "  ;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;)\n"
+               "  for (;;) continue;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;) // Can't merge this\n"
+               "  continue;",
+               AllowsMergedLoops);
+  verifyFormat("for (;;) /* still don't merge */\n"
+               "  continue;",
+               AllowsMergedLoops);
+}
+
+TEST_F(FormatTest, FormatShortBracedStatements) {
+  FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
+  AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true;
+
+  AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = true;
+  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
+
+  verifyFormat("if (true) {}", AllowSimpleBracedStatements);
+  verifyFormat("while (true) {}", AllowSimpleBracedStatements);
+  verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
+  verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
+  verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
+  verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
+  verifyFormat("if (true) { //\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+  verifyFormat("if (true) {\n"
+               "  f();\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+  verifyFormat("if (true) {\n"
+               "  f();\n"
+               "} else {\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+
+  verifyFormat("template <int> struct A2 {\n"
+               "  struct B {};\n"
+               "};",
+               AllowSimpleBracedStatements);
+
+  AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = false;
+  verifyFormat("if (true) {\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+  verifyFormat("if (true) {\n"
+               "  f();\n"
+               "} else {\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+
+  AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
+  verifyFormat("while (true) {\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+  verifyFormat("for (;;) {\n"
+               "  f();\n"
+               "}",
+               AllowSimpleBracedStatements);
+}
+
+TEST_F(FormatTest, ParseIfElse) {
+  verifyFormat("if (true)\n"
+               "  if (true)\n"
+               "    if (true)\n"
+               "      f();\n"
+               "    else\n"
+               "      g();\n"
+               "  else\n"
+               "    h();\n"
+               "else\n"
+               "  i();");
+  verifyFormat("if (true)\n"
+               "  if (true)\n"
+               "    if (true) {\n"
+               "      if (true)\n"
+               "        f();\n"
+               "    } else {\n"
+               "      g();\n"
+               "    }\n"
+               "  else\n"
+               "    h();\n"
+               "else {\n"
+               "  i();\n"
+               "}");
+  verifyFormat("void f() {\n"
+               "  if (a) {\n"
+               "  } else {\n"
+               "  }\n"
+               "}");
+}
+
+TEST_F(FormatTest, ElseIf) {
+  verifyFormat("if (a) {\n} else if (b) {\n}");
+  verifyFormat("if (a)\n"
+               "  f();\n"
+               "else if (b)\n"
+               "  g();\n"
+               "else\n"
+               "  h();");
+  verifyFormat("if (a) {\n"
+               "  f();\n"
+               "}\n"
+               "// or else ..\n"
+               "else {\n"
+               "  g()\n"
+               "}");
+
+  verifyFormat("if (a) {\n"
+               "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
+               "}");
+  verifyFormat("if (a) {\n"
+               "} else if (\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
+               "}",
+               getLLVMStyleWithColumns(62));
+}
+
+TEST_F(FormatTest, FormatsForLoop) {
+  verifyFormat(
+      "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
+      "     ++VeryVeryLongLoopVariable)\n"
+      "  ;");
+  verifyFormat("for (;;)\n"
+               "  f();");
+  verifyFormat("for (;;) {\n}");
+  verifyFormat("for (;;) {\n"
+               "  f();\n"
+               "}");
+  verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
+
+  verifyFormat(
+      "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
+      "                                          E = UnwrappedLines.end();\n"
+      "     I != E; ++I) {\n}");
+
+  verifyFormat(
+      "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
+      "     ++IIIII) {\n}");
+  verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
+               "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
+               "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
+  verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
+               "         I = FD->getDeclsInPrototypeScope().begin(),\n"
+               "         E = FD->getDeclsInPrototypeScope().end();\n"
+               "     I != E; ++I) {\n}");
+  verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
+               "         I = Container.begin(),\n"
+               "         E = Container.end();\n"
+               "     I != E; ++I) {\n}",
+               getLLVMStyleWithColumns(76));
+
+  verifyFormat(
+      "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
+      "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
+      "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
+      "     ++aaaaaaaaaaa) {\n}");
+  verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+               "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
+               "     ++i) {\n}");
+  verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
+               "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
+               "}");
+  verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
+               "         aaaaaaaaaa);\n"
+               "     iter; ++iter) {\n"
+               "}");
+  verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
+               "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
+               "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
+
+  FormatStyle NoBinPacking = getLLVMStyle();
+  NoBinPacking.BinPackParameters = false;
+  verifyFormat("for (int aaaaaaaaaaa = 1;\n"
+               "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
+               "                                           aaaaaaaaaaaaaaaa,\n"
+               "                                           aaaaaaaaaaaaaaaa,\n"
+               "                                           aaaaaaaaaaaaaaaa);\n"
+               "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
+               "}",
+               NoBinPacking);
+  verifyFormat(
+      "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
+      "                                          E = UnwrappedLines.end();\n"
+      "     I != E;\n"
+      "     ++I) {\n}",
+      NoBinPacking);
+}
+
+TEST_F(FormatTest, RangeBasedForLoops) {
+  verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+               "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
+  verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
+               "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
+  verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
+               "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
+  verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
+               "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
+}
+
+TEST_F(FormatTest, ForEachLoops) {
+  verifyFormat("void f() {\n"
+               "  foreach (Item *item, itemlist) {}\n"
+               "  Q_FOREACH (Item *item, itemlist) {}\n"
+               "  BOOST_FOREACH (Item *item, itemlist) {}\n"
+               "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
+               "}");
+
+  // As function-like macros.
+  verifyFormat("#define foreach(x, y)\n"
+               "#define Q_FOREACH(x, y)\n"
+               "#define BOOST_FOREACH(x, y)\n"
+               "#define UNKNOWN_FOREACH(x, y)\n");
+
+  // Not as function-like macros.
+  verifyFormat("#define foreach (x, y)\n"
+               "#define Q_FOREACH (x, y)\n"
+               "#define BOOST_FOREACH (x, y)\n"
+               "#define UNKNOWN_FOREACH (x, y)\n");
+}
+
+TEST_F(FormatTest, FormatsWhileLoop) {
+  verifyFormat("while (true) {\n}");
+  verifyFormat("while (true)\n"
+               "  f();");
+  verifyFormat("while () {\n}");
+  verifyFormat("while () {\n"
+               "  f();\n"
+               "}");
+}
+
+TEST_F(FormatTest, FormatsDoWhile) {
+  verifyFormat("do {\n"
+               "  do_something();\n"
+               "} while (something());");
+  verifyFormat("do\n"
+               "  do_something();\n"
+               "while (something());");
+}
+
+TEST_F(FormatTest, FormatsSwitchStatement) {
+  verifyFormat("switch (x) {\n"
+               "case 1:\n"
+               "  f();\n"
+               "  break;\n"
+               "case kFoo:\n"
+               "case ns::kBar:\n"
+               "case kBaz:\n"
+               "  break;\n"
+               "default:\n"
+               "  g();\n"
+               "  break;\n"
+               "}");
+  verifyFormat("switch (x) {\n"
+               "case 1: {\n"
+               "  f();\n"
+               "  break;\n"
+               "}\n"
+               "case 2: {\n"
+               "  break;\n"
+               "}\n"
+               "}");
+  verifyFormat("switch (x) {\n"
+               "case 1: {\n"
+               "  f();\n"
+               "  {\n"
+               "    g();\n"
+               "    h();\n"
+               "  }\n"
+               "  break;\n"
+               "}\n"
+               "}");
+  verifyFormat("switch (x) {\n"
+               "case 1: {\n"
+               "  f();\n"
+               "  if (foo) {\n"
+               "    g();\n"
+               "    h();\n"
+               "  }\n"
+               "  break;\n"
+               "}\n"
+               "}");
+  verifyFormat("switch (x) {\n"
+               "case 1: {\n"
+               "  f();\n"
+               "  g();\n"
+               "} break;\n"
+               "}");
+  verifyFormat("switch (test)\n"
+               "  ;");
+  verifyFormat("switch (x) {\n"
+               "default: {\n"
+               "  // Do nothing.\n"
+               "}\n"
+               "}");
+  verifyFormat("switch (x) {\n"
+               "// comment\n"
+               "// if 1, do f()\n"
+               "case 1:\n"
+               "  f();\n"
+               "}");
+  verifyFormat("switch (x) {\n"
+               "case 1:\n"
+               "  // Do amazing stuff\n"
+               "  {\n"
+               "    f();\n"
+               "    g();\n"
+               "  }\n"
+               "  break;\n"
+               "}");
+  verifyFormat("#define A          \\\n"
+               "  switch (x) {     \\\n"
+               "  case a:          \\\n"
+               "    foo = b;       \\\n"
+               "  }",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("#define OPERATION_CASE(name)           \\\n"
+               "  case OP_name:                        \\\n"
+               "    return operations::Operation##name\n",
+               getLLVMStyleWithColumns(40));
+  verifyFormat("switch (x) {\n"
+               "case 1:;\n"
+               "default:;\n"
+               "  int i;\n"
+               "}");
+
+  verifyGoogleFormat("switch (x) {\n"
+                     "  case 1:\n"
+                     "    f();\n"
+                     "    break;\n"
+                     "  case kFoo:\n"
+                     "  case ns::kBar:\n"
+                     "  case kBaz:\n"
+                     "    break;\n"
+                     "  default:\n"
+                     "    g();\n"
+                     "    break;\n"
+                     "}");
+  verifyGoogleFormat("switch (x) {\n"
+                     "  case 1: {\n"
+                     "    f();\n"
+                     "    break;\n"
+                     "  }\n"
+                     "}");
+  verifyGoogleFormat("switch (test)\n"
+                     "  ;");
+
+  verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
+                     "  case OP_name:              \\\n"
+                     "    return operations::Operation##name\n");
+  verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
+                     "  // Get the correction operation class.\n"
+                     "  switch (OpCode) {\n"
+                     "    CASE(Add);\n"
+                     "    CASE(Subtract);\n"
+                     "    default:\n"
+                     "      return operations::Unknown;\n"
+                     "  }\n"
+                     "#undef OPERATION_CASE\n"
+                     "}");
+  verifyFormat("DEBUG({\n"
+               "  switch (x) {\n"
+               "  case A:\n"
+               "    f();\n"
+               "    break;\n"
+               "  // On B:\n"
+               "  case B:\n"
+               "    g();\n"
+               "    break;\n"
+               "  }\n"
+               "});");
+  verifyFormat("switch (a) {\n"
+               "case (b):\n"
+               "  return;\n"
+               "}");
+
+  verifyFormat("switch (a) {\n"
+               "case some_namespace::\n"
+               "    some_constant:\n"
+               "  return;\n"
+               "}",
+               getLLVMStyleWithColumns(34));
+}
+
+TEST_F(FormatTest, CaseRanges) {
+  verifyFormat("switch (x) {\n"
+               "case 'A' ... 'Z':\n"
+               "case 1 ... 5:\n"
+               "case a ... b:\n"
+               "  break;\n"
+               "}");
+}
+
+TEST_F(FormatTest, ShortCaseLabels) {
+  FormatStyle Style = getLLVMStyle();
+  Style.AllowShortCaseLabelsOnASingleLine = true;
+  verifyFormat("switch (a) {\n"
+               "case 1: x = 1; break;\n"
+               "case 2: return;\n"
+               "case 3:\n"
+               "case 4:\n"
+               "case 5: return;\n"
+               "case 6: // comment\n"
+               "  return;\n"
+               "case 7:\n"
+               "  // comment\n"
+               "  return;\n"
+               "case 8:\n"
+               "  x = 8; // comment\n"
+               "  break;\n"
+               "default: y = 1; break;\n"
+               "}",
+               Style);
+  verifyFormat("switch (a) {\n"
+               "#if FOO\n"
+               "case 0: return 0;\n"
+               "#endif\n"
+               "}",
+               Style);
+  verifyFormat("switch (a) {\n"
+               "case 1: {\n"
+               "}\n"
+               "case 2: {\n"
+               "  return;\n"
+               "}\n"
+               "case 3: {\n"
+               "  x = 1;\n"
+               "  return;\n"
+               "}\n"
+               "case 4:\n"
+               "  if (x)\n"
+               "    return;\n"
+               "}",
+               Style);
+  Style.ColumnLimit = 21;
+  verifyFormat("switch (a) {\n"
+               "case 1: x = 1; break;\n"
+               "case 2: return;\n"
+               "case 3:\n"
+               "case 4:\n"
+               "case 5: return;\n"
+               "default:\n"
+               "  y = 1;\n"
+               "  break;\n"
+               "}",
+               Style);
+}
+
+TEST_F(FormatTest, FormatsLabels) {
+  verifyFormat("void f() {\n"
+               "  some_code();\n"
+               "test_label:\n"
+               "  some_other_code();\n"
+               "  {\n"
+               "    some_more_code();\n"
+               "  another_label:\n"
+               "    some_more_code();\n"
+               "  }\n"
+               "}");
+  verifyFormat("{\n"
+               "  some_code();\n"
+               "test_label:\n"
+               "  some_other_code();\n"
+               "}");
+  verifyFormat("{\n"
+               "  some_code();\n"
+               "test_label:;\n"
+               "  int i = 0;\n"
+               "}");
+}
+
+//===----------------------------------------------------------------------===//
+// Tests for classes, namespaces, etc.
+//===----------------------------------------------------------------------===//
+
+TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
+  verifyFormat("class A {};");
+}
+
+TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
+  verifyFormat("class A {\n"
+               "public:\n"
+               "public: // comment\n"
+               "protected:\n"
+               "private:\n"
+               "  void f() {}\n"
+               "};");
+  verifyGoogleFormat("class A {\n"
+                     " public:\n"
+                     " protected:\n"
+                     " private:\n"
+                     "  void f() {}\n"
+                     "};");
+  verifyFormat("class A {\n"
+               "public slots:\n"
+               "  void f1() {}\n"
+               "public Q_SLOTS:\n"
+               "  void f2() {}\n"
+               "protected slots:\n"
+               "  void f3() {}\n"
+               "protected Q_SLOTS:\n"
+               "  void f4() {}\n"
+               "private slots:\n"
+               "  void f5() {}\n"
+               "private Q_SLOTS:\n"
+               "  void f6() {}\n"
+               "signals:\n"
+               "  void g1();\n"
+               "Q_SIGNALS:\n"
+               "  void g2();\n"
+               "};");
+
+  // Don't interpret 'signals' the wrong way.
+  verifyFormat("signals.set();");
+  verifyFormat("for (Signals signals : f()) {\n}");
+  verifyFormat("{\n"
+               "  signals.set(); // This needs indentation.\n"
+               "}");
+  verifyFormat("void f() {\n"
+               "label:\n"
+               "  signals.baz();\n"
+               "}");
+}
+
+TEST_F(FormatTest, SeparatesLogicalBlocks) {
+  EXPECT_EQ("class A {\n"
+            "public:\n"
+            "  void f();\n"
+            "\n"
+            "private:\n"
+            "  void g() {}\n"
+            "  // test\n"
+            "protected:\n"
+            "  int h;\n"
+            "};",
+            format("class A {\n"
+                   "public:\n"
+                   "void f();\n"
+                   "private:\n"
+                   "void g() {}\n"
+                   "// test\n"
+                   "protected:\n"
+                   "int h;\n"
+                   "};"));
+  EXPECT_EQ("class A {\n"
+            "protected:\n"
+            "public:\n"
+            "  void f();\n"
+            "};",
+            format("class A {\n"
+                   "protected:\n"
+                   "\n"
+                   "public:\n"
+                   "\n"
+                   "  void f();\n"
+                   "};"));
+
+  // Even ensure proper spacing inside macros.
+  EXPECT_EQ("#define B     \\\n"
+            "  class A {   \\\n"
+            "   protected: \\\n"
+            "   public:    \\\n"
+            "    void f(); \\\n"
+            "  };",
+            format("#define B     \\\n"
+                   "  class A {   \\\n"
+                   "   protected: \\\n"
+                   "              \\\n"
+                   "   public:    \\\n"
+                   "              \\\n"
+                   "    void f(); \\\n"
+                   "  };",
+                   getGoogleStyle()));
+  // But don't remove empty lines after macros ending in access specifiers.
+  EXPECT_EQ("#define A private:\n"
+            "\n"
+            "int i;",
+            format("#define A         private:\n"
+                   "\n"
+                   "int              i;"));
+}
+
+TEST_F(FormatTest, FormatsClasses) {
+  verifyFormat("class A : public B {};");
+  verifyFormat("class A : public ::B {};");
+
+  verifyFormat(
+      "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
+      "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
+  verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+               "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
+               "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
+  verifyFormat(
+      "class A : public B, public C, public D, public E, public F {};");
+  verifyFormat("class AAAAAAAAAAAA : public B,\n"
+               "                     public C,\n"
+               "                     public D,\n"
+               "                     public E,\n"
+               "                     public F,\n"
+               "                     public G {};");
+
+  verifyFormat("class\n"
+               "    ReallyReallyLongClassName {\n"
+               "  int i;\n"
+               "};",
+               getLLVMStyleWithColumns(32));
+  verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
+               "                           aaaaaaaaaaaaaaaa> {};");
+  verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
+               "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
+               "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
+  verifyFormat("template <class R, class C>\n"
+               "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
+               "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
+  verifyFormat("class ::A::B {};");
+}
+
+TEST_F(FormatTest, BreakBeforeInheritanceComma) {
+  FormatStyle StyleWithInheritanceBreak = getLLVMStyle();
+  StyleWithInheritanceBreak.BreakBeforeInheritanceComma = true;
+
+  verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreak);
+  verifyFormat("class MyClass\n"
+               "    : public X\n"
+               "    , public Y {};",
+               StyleWithInheritanceBreak);
+}
+
+TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
+  verifyFormat("class A {\n} a, b;");
+  verifyFormat("struct A {\n} a, b;");
+  verifyFormat("union A {\n} a;");
+}
+
+TEST_F(FormatTest, FormatsEnum) {
+  verifyFormat("enum {\n"
+               "  Zero,\n"
+               "  One = 1,\n"
+               "  Two = One + 1,\n"
+               "  Three = (One + Two),\n"
+               "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
+               "  Five = (One, Two, Three, Four, 5)\n"
+               "};");
+  verifyGoogleFormat("enum {\n"
+                     "  Zero,\n"
+                     "  One = 1,\n"
+                     "  Two = One + 1,\n"
+                     "  Three = (One + Two),\n"
+                     "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
+                     "  Five = (One, Two, Three, Four, 5)\n"
+                     "};");
+  verifyFormat("enum Enum {};");
+  verifyFormat("enum {};");
+  verifyFormat("enum X E {} d;");
+  verifyFormat("enum __attribute__((...)) E {} d;");
+  verifyFormat("enum __declspec__((...)) E {} d;");
+  verifyFormat("enum {\n"
+               "  Bar = Foo<int, int>::value\n"
+               "};",
+               getLLVMStyleWithColumns(30));
+
+  verifyFormat("enum ShortEnum { A, B, C };");
+  verifyGoogleFormat("enum ShortEnum { A, B, C };");
+
+  EXPECT_EQ("enum KeepEmptyLines {\n"
+            "  ONE,\n"
+            "\n"
+            "  TWO,\n"
+            "\n"
+            "  THREE\n"
+            "}",
+            format("enum KeepEmptyLines {\n"
+                   "  ONE,\n"
+                   "\n"
+                   "  TWO,\n"
+                   "\n"
+                   "\n"
+                   "  THREE\n"
+                   "}"));
+  verifyFormat("enum E { // comment\n"
+               "  ONE,\n"
+               "  TWO\n"
+               "};\n"
+               "int i;");
+  // Not enums.
+  verifyFormat("enum X f() {\n"
+               "  a();\n"
+               "  return 42;\n"
+               "}");
+  verifyFormat("enum X Type::f() {\n"
+               "  a();\n"
+               "  return 42;\n"
+               "}");
+  verifyFormat("enum ::X f() {\n"
+               "  a();\n"
+               "  return 42;\n"
+               "}");
+  verifyFormat("enum ns::X f() {\n"
+               "  a();\n"
+               "  return 42;\n"
+               "}");
+}
+
+TEST_F(FormatTest, FormatsEnumsWithErrors) {
+  verifyFormat("enum Type {\n"
+               "  One = 0; // These semicolons should be commas.\n"
+               "  Two = 1;\n"
+               "};");
+  verifyFormat("namespace n {\n"
+               "enum Type {\n"
+               "  One,\n"
+               "  Two, // missing };\n"
+               "  int i;\n"
+               "}\n"
+               "void g() {}");
+}
+
+TEST_F(FormatTest, FormatsEnumStruct) {
+  verifyFormat("enum struct {\n"
+               "  Zero,\n"
+               "  One = 1,\n"
+               "  Two = One + 1,\n"
+               "  Three = (One + Two),\n"
+               "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
+               "  Five = (One, Two, Three, Four, 5)\n"
+               "};");
+  verifyFormat("enum struct Enum {};");
+  verifyFormat("enum struct {};");
+  verifyFormat("enum struct X E {} d;");
+  verifyFormat("enum struct __attribute__((...)) E {} d;");
+  verifyFormat("enum struct __declspec__((...)) E {} d;");
+  verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
+}
+
+TEST_F(FormatTest, FormatsEnumClass) {
+  verifyFormat("enum class {\n"
+               "  Zero,\n"
+               "  One = 1,\n"
+               "  Two = One + 1,\n"
+               "  Three = (One + Two),\n"
+               "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
+               "  Five = (One, Two, Three, Four, 5)\n"
+               "};");
+  verifyFormat("enum class Enum {};");
+  verifyFormat("enum class {};");
+  verifyFormat("enum class X E {} d;");
+  verifyFormat("enum class __attribute__((...)) E {} d;");
+  verifyFormat("enum class __declspec__((...)) E {} d;");
+  verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
+}
+
+TEST_F(FormatTest, FormatsEnumTypes) {
+  verifyFormat("enum X : int {\n"
+               "  A, // Force multiple lines.\n"
+               "  B\n"
+               "};");
+  verifyFormat("enum X : int { A, B };");
+  verifyFormat("enum X : std::uint32_t { A, B };");
+}
+
+TEST_F(FormatTest, FormatsNSEnums) {
+  verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
+  verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
+                     "  // Information about someDecentlyLongValue.\n"
+                     "  someDecentlyLongValue,\n"
+                     "  // Information about anotherDecentlyLongValue.\n"
+                     "  anotherDecentlyLongValue,\n"
+                     "  // Information about aThirdDecentlyLongValue.\n"
+                     "  aThirdDecentlyLongValue\n"
+                     "};");
+  verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
+                     "  a = 1,\n"
+                     "  b = 2,\n"
+                     "  c = 3,\n"
+                     "};");
+  verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
+                     "  a = 1,\n"
+                     "  b = 2,\n"
+                     "  c = 3,\n"
+                     "};");
+  verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
+                     "  a = 1,\n"
+                     "  b = 2,\n"
+                     "  c = 3,\n"
+                     "};");
+}
+
+TEST_F(FormatTest, FormatsBitfields) {
+  verifyFormat("struct Bitfields {\n"
+               "  unsigned sClass : 8;\n"
+               "  unsigned ValueKind : 2;\n"
+               "};");
+  verifyFormat("struct A {\n"
+               "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
+               "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
+               "};");
+  verifyFormat("struct MyStruct {\n"
+               "  uchar data;\n"
+               "  uchar : 8;\n"
+               "  uchar : 8;\n"
+               "  uchar other;\n"
+               "};");
+}
+
+TEST_F(FormatTest, FormatsNamespaces) {
+  FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
+  LLVMWithNoNamespaceFix.FixNamespaceComments = false;
+
+  verifyFormat("namespace some_namespace {\n"
+               "class A {};\n"
+               "void f() { f(); }\n"
+               "}",
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace {\n"
+               "class A {};\n"
+               "void f() { f(); }\n"
+               "}",
+               LLVMWithNoNamespaceFix);
+  verifyFormat("inline namespace X {\n"
+               "class A {};\n"
+               "void f() { f(); }\n"
+               "}",
+               LLVMWithNoNamespaceFix);
+  verifyFormat("using namespace some_namespace;\n"
+               "class A {};\n"
+               "void f() { f(); }",
+               LLVMWithNoNamespaceFix);
+
+  // This code is more common than we thought; if we
+  // layout this correctly the semicolon will go into
+  // its own line, which is undesirable.
+  verifyFormat("namespace {};",
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace {\n"
+               "class A {};\n"
+               "};",
+               LLVMWithNoNamespaceFix);
+
+  verifyFormat("namespace {\n"
+               "int SomeVariable = 0; // comment\n"
+               "} // namespace",
+               LLVMWithNoNamespaceFix);
+  EXPECT_EQ("#ifndef HEADER_GUARD\n"
+            "#define HEADER_GUARD\n"
+            "namespace my_namespace {\n"
+            "int i;\n"
+            "} // my_namespace\n"
+            "#endif // HEADER_GUARD",
+            format("#ifndef HEADER_GUARD\n"
+                   " #define HEADER_GUARD\n"
+                   "   namespace my_namespace {\n"
+                   "int i;\n"
+                   "}    // my_namespace\n"
+                   "#endif    // HEADER_GUARD",
+                   LLVMWithNoNamespaceFix));
+
+  EXPECT_EQ("namespace A::B {\n"
+            "class C {};\n"
+            "}",
+            format("namespace A::B {\n"
+                   "class C {};\n"
+                   "}",
+                   LLVMWithNoNamespaceFix));
+
+  FormatStyle Style = getLLVMStyle();
+  Style.NamespaceIndentation = FormatStyle::NI_All;
+  EXPECT_EQ("namespace out {\n"
+            "  int i;\n"
+            "  namespace in {\n"
+            "    int i;\n"
+            "  } // namespace in\n"
+            "} // namespace out",
+            format("namespace out {\n"
+                   "int i;\n"
+                   "namespace in {\n"
+                   "int i;\n"
+                   "} // namespace in\n"
+                   "} // namespace out",
+                   Style));
+
+  Style.NamespaceIndentation = FormatStyle::NI_Inner;
+  EXPECT_EQ("namespace out {\n"
+            "int i;\n"
+            "namespace in {\n"
+            "  int i;\n"
+            "} // namespace in\n"
+            "} // namespace out",
+            format("namespace out {\n"
+                   "int i;\n"
+                   "namespace in {\n"
+                   "int i;\n"
+                   "} // namespace in\n"
+                   "} // namespace out",
+                   Style));
+}
+
+TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
+
+TEST_F(FormatTest, FormatsInlineASM) {
+  verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
+  verifyFormat("asm(\"nop\" ::: \"memory\");");
+  verifyFormat(
+      "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
+      "    \"cpuid\\n\\t\"\n"
+      "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
+      "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
+      "    : \"a\"(value));");
+  EXPECT_EQ(
+      "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
+      "  __asm {\n"
+      "        mov     edx,[that] // vtable in edx\n"
+      "        mov     eax,methodIndex\n"
+      "        call    [edx][eax*4] // stdcall\n"
+      "  }\n"
+      "}",
+      format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
+             "    __asm {\n"
+             "        mov     edx,[that] // vtable in edx\n"
+             "        mov     eax,methodIndex\n"
+             "        call    [edx][eax*4] // stdcall\n"
+             "    }\n"
+             "}"));
+  EXPECT_EQ("_asm {\n"
+            "  xor eax, eax;\n"
+            "  cpuid;\n"
+            "}",
+            format("_asm {\n"
+                   "  xor eax, eax;\n"
+                   "  cpuid;\n"
+                   "}"));
+  verifyFormat("void function() {\n"
+               "  // comment\n"
+               "  asm(\"\");\n"
+               "}");
+  EXPECT_EQ("__asm {\n"
+            "}\n"
+            "int i;",
+            format("__asm   {\n"
+                   "}\n"
+                   "int   i;"));
+}
+
+TEST_F(FormatTest, FormatTryCatch) {
+  verifyFormat("try {\n"
+               "  throw a * b;\n"
+               "} catch (int a) {\n"
+               "  // Do nothing.\n"
+               "} catch (...) {\n"
+               "  exit(42);\n"
+               "}");
+
+  // Function-level try statements.
+  verifyFormat("int f() try { return 4; } catch (...) {\n"
+               "  return 5;\n"
+               "}");
+  verifyFormat("class A {\n"
+               "  int a;\n"
+               "  A() try : a(0) {\n"
+               "  } catch (...) {\n"
+               "    throw;\n"
+               "  }\n"
+               "};\n");
+
+  // Incomplete try-catch blocks.
+  verifyIncompleteFormat("try {} catch (");
+}
+
+TEST_F(FormatTest, FormatSEHTryCatch) {
+  verifyFormat("__try {\n"
+               "  int a = b * c;\n"
+               "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
+               "  // Do nothing.\n"
+               "}");
+
+  verifyFormat("__try {\n"
+               "  int a = b * c;\n"
+               "} __finally {\n"
+               "  // Do nothing.\n"
+               "}");
+
+  verifyFormat("DEBUG({\n"
+               "  __try {\n"
+               "  } __finally {\n"
+               "  }\n"
+               "});\n");
+}
+
+TEST_F(FormatTest, IncompleteTryCatchBlocks) {
+  verifyFormat("try {\n"
+               "  f();\n"
+               "} catch {\n"
+               "  g();\n"
+               "}");
+  verifyFormat("try {\n"
+               "  f();\n"
+               "} catch (A a) MACRO(x) {\n"
+               "  g();\n"
+               "} catch (B b) MACRO(x) {\n"
+               "  g();\n"
+               "}");
+}
+
+TEST_F(FormatTest, FormatTryCatchBraceStyles) {
+  FormatStyle Style = getLLVMStyle();
+  for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
+                          FormatStyle::BS_WebKit}) {
+    Style.BreakBeforeBraces = BraceStyle;
+    verifyFormat("try {\n"
+                 "  // something\n"
+                 "} catch (...) {\n"
+                 "  // something\n"
+                 "}",
+                 Style);
+  }
+  Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
+  verifyFormat("try {\n"
+               "  // something\n"
+               "}\n"
+               "catch (...) {\n"
+               "  // something\n"
+               "}",
+               Style);
+  verifyFormat("__try {\n"
+               "  // something\n"
+               "}\n"
+               "__finally {\n"
+               "  // something\n"
+               "}",
+               Style);
+  verifyFormat("@try {\n"
+               "  // something\n"
+               "}\n"
+               "@finally {\n"
+               "  // something\n"
+               "}",
+               Style);
+  Style.BreakBeforeBraces = FormatStyle::BS_Allman;
+  verifyFormat("try\n"
+               "{\n"
+               "  // something\n"
+               "}\n"
+               "catch (...)\n"
+               "{\n"
+               "  // something\n"
+               "}",
+               Style);
+  Style.BreakBeforeBraces = FormatStyle::BS_GNU;
+  verifyFormat("try\n"
+               "  {\n"
+               "    // something\n"
+               "  }\n"
+               "catch (...)\n"
+               "  {\n"
+               "    // something\n"
+               "  }",
+               Style);
+  Style.BreakBeforeBraces = FormatStyle::BS_Custom;
+  Style.BraceWrapping.BeforeCatch = true;
+  verifyFormat("try {\n"
+               "  // something\n"
+               "}\n"
+               "catch (...) {\n"
+               "  // something\n"
+               "}",
+               Style);
+}
+
+TEST_F(FormatTest, StaticInitializers) {
+  verifyFormat("static SomeClass SC = {1, 'a'};");
+
+  verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
+               "    100000000, "
+               "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
+
+  // Here, everything other than the "}" would fit on a line.
+  verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
+               "    10000000000000000000000000};");
+  EXPECT_EQ("S s = {a,\n"
+            "\n"
+            "       b};",
+            format("S s = {\n"
+                   "  a,\n"
+                   "\n"
+                   "  b\n"
+                   "};"));
+
+  // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
+  // line. However, the formatting looks a bit off and this probably doesn't
+  // happen often in practice.
+  verifyFormat("static int Variable[1] = {\n"
+               "    {1000000000000000000000000000000000000}};",
+               getLLVMStyleWithColumns(40));
+}
+
+TEST_F(FormatTest, DesignatedInitializers) {
+  verifyFormat("const struct A a = {.a = 1, .b = 2};");
+  verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
+               "                    .bbbbbbbbbb = 2,\n"
+               "                    .cccccccccc = 3,\n"
+               "                    .dddddddddd = 4,\n"
+               "                    .eeeeeeeeee = 5};");
+  verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
+               "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
+               "    .ccccccccccccccccccccccccccc = 3,\n"
+               "    .ddddddddddddddddddddddddddd = 4,\n"
+               "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
+
+  verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
+}
+
+TEST_F(FormatTest, NestedStaticInitializers) {
+  verifyFormat("static A x = {{{}}};\n");
+  verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
+               "               {init1, init2, init3, init4}}};",
+               getLLVMStyleWithColumns(50));
+
+  verifyFormat("somes Status::global_reps[3] = {\n"
+               "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
+               "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
+               "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
+               getLLVMStyleWithColumns(60));
+  verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
+                     "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
+                     "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
+                     "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
+  verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
+               "                  {rect.fRight - rect.fLeft, rect.fBottom - "
+               "rect.fTop}};");
+
+  verifyFormat(
+      "SomeArrayOfSomeType a = {\n"
+      "    {{1, 2, 3},\n"
+      "     {1, 2, 3},\n"
+      "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
+      "      333333333333333333333333333333},\n"
+      "     {1, 2, 3},\n"
+      "     {1, 2, 3}}};");
+  verifyFormat(
+      "SomeArrayOfSomeType a = {\n"
+      "    {{1, 2, 3}},\n"
+      "    {{1, 2, 3}},\n"
+      "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
+      "      333333333333333333333333333333}},\n"
+      "    {{1, 2, 3}},\n"
+      "    {{1, 2, 3}}};");
+
+  verifyFormat("struct {\n"
+               "  unsigned bit;\n"
+               "  const char *const name;\n"
+               "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
+               "                 {kOsWin, \"Windows\"},\n"
+               "                 {kOsLinux, \"Linux\"},\n"
+               "                 {kOsCrOS, \"Chrome OS\"}};");
+  verifyFormat("struct {\n"
+               "  unsigned bit;\n"
+               "  const char *const name;\n"
+               "} kBitsToOs[] = {\n"
+               "    {kOsMac, \"Mac\"},\n"
+               "    {kOsWin, \"Windows\"},\n"
+               "    {kOsLinux, \"Linux\"},\n"
+               "    {kOsCrOS, \"Chrome OS\"},\n"
+               "};");
+}
+
+TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
+  verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
+               "                      \\\n"
+               "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
+}
+
+TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
+  verifyFormat("virtual void write(ELFWriter *writerrr,\n"
+               "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
+
+  // Do break defaulted and deleted functions.
+  verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
+               "    default;",
+               getLLVMStyleWithColumns(40));
+  verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
+               "    delete;",
+               getLLVMStyleWithColumns(40));
+}
+
+TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
+  verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
+               getLLVMStyleWithColumns(40));
+  verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
+               getLLVMStyleWithColumns(40));
+  EXPECT_EQ("#define Q                              \\\n"
+            "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
+            "  \"aaaaaaaa.cpp\"",
+            format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
+                   getLLVMStyleWithColumns(40)));
+}
+
+TEST_F(FormatTest, UnderstandsLinePPDirective) {
+  EXPECT_EQ("# 123 \"A string literal\"",
+            format("   #     123    \"A string literal\""));
+}
+
+TEST_F(FormatTest, LayoutUnknownPPDirective) {
+  EXPECT_EQ("#;", format("#;"));
+  verifyFormat("#\n;\n;\n;");
+}
+
+TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
+  EXPECT_EQ("#line 42 \"test\"\n",
+            format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
+  EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
+                                    getLLVMStyleWithColumns(12)));
+}
+
+TEST_F(FormatTest, EndOfFileEndsPPDirective) {
+  EXPECT_EQ("#line 42 \"test\"",
+            format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
+  EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
+}
+
+TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
+  verifyFormat("#define A \\x20");
+  verifyFormat("#define A \\ x20");
+  EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
+  verifyFormat("#define A ''");
+  verifyFormat("#define A ''qqq");
+  verifyFormat("#define A `qqq");
+  verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
+  EXPECT_EQ("const char *c = STRINGIFY(\n"
+            "\\na : b);",
+            format("const char * c = STRINGIFY(\n"
+                   "\\na : b);"));
+
+  verifyFormat("a\r\\");
+  verifyFormat("a\v\\");
+  verifyFormat("a\f\\");
+}
+
+TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
+  verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
+  verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
+  verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
+  // FIXME: We never break before the macro name.
+  verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
+
+  verifyFormat("#define A A\n#define A A");
+  verifyFormat("#define A(X) A\n#define A A");
+
+  verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
+  verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
+}
+
+TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
+  EXPECT_EQ("// somecomment\n"
+            "#include \"a.h\"\n"
+            "#define A(  \\\n"
+            "    A, B)\n"
+            "#include \"b.h\"\n"
+            "// somecomment\n",
+            format("  // somecomment\n"
+                   "  #include \"a.h\"\n"
+                   "#define A(A,\\\n"
+                   "    B)\n"
+                   "    #include \"b.h\"\n"
+                   " // somecomment\n",
+                   getLLVMStyleWithColumns(13)));
+}
+
+TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
+
+TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
+  EXPECT_EQ("#define A    \\\n"
+            "  c;         \\\n"
+            "  e;\n"
+            "f;",
+            format("#define A c; e;\n"
+                   "f;",
+                   getLLVMStyleWithColumns(14)));
+}
+
+TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
+
+TEST_F(FormatTest, MacroDefinitionInsideStatement) {
+  EXPECT_EQ("int x,\n"
+            "#define A\n"
+            "    y;",
+            format("int x,\n#define A\ny;"));
+}
+
+TEST_F(FormatTest, HashInMacroDefinition) {
+  EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
+  verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
+  verifyFormat("#define A  \\\n"
+               "  {        \\\n"
+               "    f(#c); \\\n"
+               "  }",
+               getLLVMStyleWithColumns(11));
+
+  verifyFormat("#define A(X)         \\\n"
+               "  void function##X()",
+               getLLVMStyleWithColumns(22));
+
+  verifyFormat("#define A(a, b, c)   \\\n"
+               "  void a##b##c()",
+               getLLVMStyleWithColumns(22));
+
+  verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
+}
+
+TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
+  EXPECT_EQ("#define A (x)", format("#define A (x)"));
+  EXPECT_EQ("#define A(x)", format("#define A(x)"));
+}
+
+TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
+  EXPECT_EQ("#define A b;", format("#define A \\\n"
+                                   "          \\\n"
+                                   "  b;",
+                                   getLLVMStyleWithColumns(25)));
+  EXPECT_EQ("#define A \\\n"
+            "          \\\n"
+            "  a;      \\\n"
+            "  b;",
+            format("#define A \\\n"
+                   "          \\\n"
+                   "  a;      \\\n"
+                   "  b;",
+                   getLLVMStyleWithColumns(11)));
+  EXPECT_EQ("#define A \\\n"
+            "  a;      \\\n"
+            "          \\\n"
+            "  b;",
+            format("#define A \\\n"
+                   "  a;      \\\n"
+                   "          \\\n"
+                   "  b;",
+                   getLLVMStyleWithColumns(11)));
+}
+
+TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
+  verifyIncompleteFormat("#define A :");
+  verifyFormat("#define SOMECASES  \\\n"
+               "  case 1:          \\\n"
+               "  case 2\n",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("#define MACRO(a) \\\n"
+               "  if (a)         \\\n"
+               "    f();         \\\n"
+               "  else           \\\n"
+               "    g()",
+               getLLVMStyleWithColumns(18));
+  verifyFormat("#define A template <typename T>");
+  verifyIncompleteFormat("#define STR(x) #x\n"
+                         "f(STR(this_is_a_string_literal{));");
+  verifyFormat("#pragma omp threadprivate( \\\n"
+               "    y)), // expected-warning",
+               getLLVMStyleWithColumns(28));
+  verifyFormat("#d, = };");
+  verifyFormat("#if \"a");
+  verifyIncompleteFormat("({\n"
+                         "#define b     \\\n"
+                         "  }           \\\n"
+                         "  a\n"
+                         "a",
+                         getLLVMStyleWithColumns(15));
+  verifyFormat("#define A     \\\n"
+               "  {           \\\n"
+               "    {\n"
+               "#define B     \\\n"
+               "  }           \\\n"
+               "  }",
+               getLLVMStyleWithColumns(15));
+  verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
+  verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
+  verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
+  verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
+}
+
+TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
+  verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
+  EXPECT_EQ("class A : public QObject {\n"
+            "  Q_OBJECT\n"
+            "\n"
+            "  A() {}\n"
+            "};",
+            format("class A  :  public QObject {\n"
+                   "     Q_OBJECT\n"
+                   "\n"
+                   "  A() {\n}\n"
+                   "}  ;"));
+  EXPECT_EQ("MACRO\n"
+            "/*static*/ int i;",
+            format("MACRO\n"
+                   " /*static*/ int   i;"));
+  EXPECT_EQ("SOME_MACRO\n"
+            "namespace {\n"
+            "void f();\n"
+            "} // namespace",
+            format("SOME_MACRO\n"
+                   "  namespace    {\n"
+                   "void   f(  );\n"
+                   "} // namespace"));
+  // Only if the identifier contains at least 5 characters.
+  EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
+  EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
+  // Only if everything is upper case.
+  EXPECT_EQ("class A : public QObject {\n"
+            "  Q_Object A() {}\n"
+            "};",
+            format("class A  :  public QObject {\n"
+                   "     Q_Object\n"
+                   "  A() {\n}\n"
+                   "}  ;"));
+
+  // Only if the next line can actually start an unwrapped line.
+  EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
+            format("SOME_WEIRD_LOG_MACRO\n"
+                   "<< SomeThing;"));
+
+  verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
+               "(n, buffers))\n",
+               getChromiumStyle(FormatStyle::LK_Cpp));
+}
+
+TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
+  EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
+            "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
+            "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
+            "class X {};\n"
+            "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
+            "int *createScopDetectionPass() { return 0; }",
+            format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
+                   "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
+                   "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
+                   "  class X {};\n"
+                   "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
+                   "  int *createScopDetectionPass() { return 0; }"));
+  // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
+  // braces, so that inner block is indented one level more.
+  EXPECT_EQ("int q() {\n"
+            "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
+            "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
+            "  IPC_END_MESSAGE_MAP()\n"
+            "}",
+            format("int q() {\n"
+                   "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
+                   "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
+                   "  IPC_END_MESSAGE_MAP()\n"
+                   "}"));
+
+  // Same inside macros.
+  EXPECT_EQ("#define LIST(L) \\\n"
+            "  L(A)          \\\n"
+            "  L(B)          \\\n"
+            "  L(C)",
+            format("#define LIST(L) \\\n"
+                   "  L(A) \\\n"
+                   "  L(B) \\\n"
+                   "  L(C)",
+                   getGoogleStyle()));
+
+  // These must not be recognized as macros.
+  EXPECT_EQ("int q() {\n"
+            "  f(x);\n"
+            "  f(x) {}\n"
+            "  f(x)->g();\n"
+            "  f(x)->*g();\n"
+            "  f(x).g();\n"
+            "  f(x) = x;\n"
+            "  f(x) += x;\n"
+            "  f(x) -= x;\n"
+            "  f(x) *= x;\n"
+            "  f(x) /= x;\n"
+            "  f(x) %= x;\n"
+            "  f(x) &= x;\n"
+            "  f(x) |= x;\n"
+            "  f(x) ^= x;\n"
+            "  f(x) >>= x;\n"
+            "  f(x) <<= x;\n"
+            "  f(x)[y].z();\n"
+            "  LOG(INFO) << x;\n"
+            "  ifstream(x) >> x;\n"
+            "}\n",
+            format("int q() {\n"
+                   "  f(x)\n;\n"
+                   "  f(x)\n {}\n"
+                   "  f(x)\n->g();\n"
+                   "  f(x)\n->*g();\n"
+                   "  f(x)\n.g();\n"
+                   "  f(x)\n = x;\n"
+                   "  f(x)\n += x;\n"
+                   "  f(x)\n -= x;\n"
+                   "  f(x)\n *= x;\n"
+                   "  f(x)\n /= x;\n"
+                   "  f(x)\n %= x;\n"
+                   "  f(x)\n &= x;\n"
+                   "  f(x)\n |= x;\n"
+                   "  f(x)\n ^= x;\n"
+                   "  f(x)\n >>= x;\n"
+                   "  f(x)\n <<= x;\n"
+                   "  f(x)\n[y].z();\n"
+                   "  LOG(INFO)\n << x;\n"
+                   "  ifstream(x)\n >> x;\n"
+                   "}\n"));
+  EXPECT_EQ("int q() {\n"
+            "  F(x)\n"
+            "  if (1) {\n"
+            "  }\n"
+            "  F(x)\n"
+            "  while (1) {\n"
+            "  }\n"
+            "  F(x)\n"
+            "  G(x);\n"
+            "  F(x)\n"
+            "  try {\n"
+            "    Q();\n"
+            "  } catch (...) {\n"
+            "  }\n"
+            "}\n",
+            format("int q() {\n"
+                   "F(x)\n"
+                   "if (1) {}\n"
+                   "F(x)\n"
+                   "while (1) {}\n"
+                   "F(x)\n"
+                   "G(x);\n"
+                   "F(x)\n"
+                   "try { Q(); } catch (...) {}\n"
+                   "}\n"));
+  EXPECT_EQ("class A {\n"
+            "  A() : t(0) {}\n"
+            "  A(int i) noexcept() : {}\n"
+            "  A(X x)\n" // FIXME: function-level try blocks are broken.
+            "  try : t(0) {\n"
+            "  } catch (...) {\n"
+            "  }\n"
+            "};",
+            format("class A {\n"
+                   "  A()\n : t(0) {}\n"
+                   "  A(int i)\n noexcept() : {}\n"
+                   "  A(X x)\n"
+                   "  try : t(0) {} catch (...) {}\n"
+                   "};"));
+  EXPECT_EQ("class SomeClass {\n"
+            "public:\n"
+            "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
+            "};",
+            format("class SomeClass {\n"
+                   "public:\n"
+                   "  SomeClass()\n"
+                   "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
+                   "};"));
+  EXPECT_EQ("class SomeClass {\n"
+            "public:\n"
+            "  SomeClass()\n"
+            "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
+            "};",
+            format("class SomeClass {\n"
+                   "public:\n"
+                   "  SomeClass()\n"
+                   "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
+                   "};",
+                   getLLVMStyleWithColumns(40)));
+
+  verifyFormat("MACRO(>)");
+}
+
+TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
+  verifyFormat("#define A \\\n"
+               "  f({     \\\n"
+               "    g();  \\\n"
+               "  });",
+               getLLVMStyleWithColumns(11));
+}
+
+TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) {
+  EXPECT_EQ("{\n  {\n#define A\n  }\n}", format("{{\n#define A\n}}"));
+}
+
+TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
+  verifyFormat("{\n  { a #c; }\n}");
+}
+
+TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
+  EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
+            format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
+  EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
+            format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
+}
+
+TEST_F(FormatTest, EscapedNewlines) {
+  EXPECT_EQ(
+      "#define A \\\n  int i;  \\\n  int j;",
+      format("#define A \\\nint i;\\\n  int j;", getLLVMStyleWithColumns(11)));
+  EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
+  EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
+  EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
+  EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
+}
+
+TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
+  verifyFormat("#define A \\\n"
+               "  int v(  \\\n"
+               "      a); \\\n"
+               "  int i;",
+               getLLVMStyleWithColumns(11));
+}
+
+TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
+  EXPECT_EQ(
+      "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
+      "                      \\\n"
+      "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
+      "\n"
+      "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
+      "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
+      format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
+             "\\\n"
+             "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
+             "  \n"
+             "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
+             "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
+}
+
+TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
+  EXPECT_EQ("int\n"
+            "#define A\n"
+            "    a;",
+            format("int\n#define A\na;"));
+  verifyFormat("functionCallTo(\n"
+               "    someOtherFunction(\n"
+               "        withSomeParameters, whichInSequence,\n"
+               "        areLongerThanALine(andAnotherCall,\n"
+               "#define A B\n"
+               "                           withMoreParamters,\n"
+               "                           whichStronglyInfluenceTheLayout),\n"
+               "        andMoreParameters),\n"
+               "    trailing);",
+               getLLVMStyleWithColumns(69));
+  verifyFormat("Foo::Foo()\n"
+               "#ifdef BAR\n"
+               "    : baz(0)\n"
+               "#endif\n"
+               "{\n"
+               "}");
+  verifyFormat("void f() {\n"
+               "  if (true)\n"
+               "#ifdef A\n"
+               "    f(42);\n"
+               "  x();\n"
+               "#else\n"
+               "    g();\n"
+               "  x();\n"
+               "#endif\n"
+               "}");
+  verifyFormat("void f(param1, param2,\n"
+               "       param3,\n"
+               "#ifdef A\n"
+               "       param4(param5,\n"
+               "#ifdef A1\n"
+               "              param6,\n"
+               "#ifdef A2\n"
+               "              param7),\n"
+               "#else\n"
+               "              param8),\n"
+               "       param9,\n"
+               "#endif\n"
+               "       param10,\n"
+               "#endif\n"
+               "       param11)\n"
+               "#else\n"
+               "       param12)\n"
+               "#endif\n"
+               "{\n"
+               "  x();\n"
+               "}",
+               getLLVMStyleWithColumns(28));
+  verifyFormat("#if 1\n"
+               "int i;");
+  verifyFormat("#if 1\n"
+               "#endif\n"
+               "#if 1\n"
+               "#else\n"
+               "#endif\n");
+  verifyFormat("DEBUG({\n"
+               "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
+               "});\n"
+               "#if a\n"
+               "#else\n"
+               "#endif");
+
+  verifyIncompleteFormat("void f(\n"
+                         "#if A\n"
+                         "    );\n"
+                         "#else\n"
+                         "#endif");
+}
+
+TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
+  verifyFormat("#endif\n"
+               "#if B");
+}
+
+TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
+  FormatStyle SingleLine = getLLVMStyle();
+  SingleLine.AllowShortIfStatementsOnASingleLine = true;
+  verifyFormat("#if 0\n"
+               "#elif 1\n"
+               "#endif\n"
+               "void foo() {\n"
+               "  if (test) foo2();\n"
+               "}",
+               SingleLine);
+}
+
+TEST_F(FormatTest, LayoutBlockInsideParens) {
+  verifyFormat("functionCall({ int i; });");
+  verifyFormat("functionCall({\n"
+               "  int i;\n"
+               "  int j;\n"
+               "});");
+  verifyFormat("functionCall(\n"
+               "    {\n"
+               "      int i;\n"
+               "      int j;\n"
+               "    },\n"
+               "    aaaa, bbbb, cccc);");
+  verifyFormat("functionA(functionB({\n"
+               "            int i;\n"
+               "            int j;\n"
+               "          }),\n"
+               "          aaaa, bbbb, cccc);");
+  verifyFormat("functionCall(\n"
+               "    {\n"
+               "      int i;\n"
+               "      int j;\n"
+               "    },\n"
+               "    aaaa, bbbb, // comment\n"
+               "    cccc);");
+  verifyFormat("functionA(functionB({\n"
+               "            int i;\n"
+               "            int j;\n"
+               "          }),\n"
+               "          aaaa, bbbb, // comment\n"
+               "          cccc);");
+  verifyFormat("functionCall(aaaa, bbbb, { int i; });");
+  verifyFormat("functionCall(aaaa, bbbb, {\n"
+               "  int i;\n"
+               "  int j;\n"
+               "});");
+  verifyFormat(
+      "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
+      "    {\n"
+      "      int i; // break\n"
+      "    },\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+      "                                     ccccccccccccccccc));");
+  verifyFormat("DEBUG({\n"
+               "  if (a)\n"
+               "    f();\n"
+               "});");
+}
+
+TEST_F(FormatTest, LayoutBlockInsideStatement) {
+  EXPECT_EQ("SOME_MACRO { int i; }\n"
+            "int i;",
+            format("  SOME_MACRO  {int i;}  int i;"));
+}
+
+TEST_F(FormatTest, LayoutNestedBlocks) {
+  verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
+               "  struct s {\n"
+               "    int i;\n"
+               "  };\n"
+               "  s kBitsToOs[] = {{10}};\n"
+               "  for (int i = 0; i < 10; ++i)\n"
+               "    return;\n"
+               "}");
+  verifyFormat("call(parameter, {\n"
+               "  something();\n"
+               "  // Comment using all columns.\n"
+               "  somethingelse();\n"
+               "});",
+               getLLVMStyleWithColumns(40));
+  verifyFormat("DEBUG( //\n"
+               "    { f(); }, a);");
+  verifyFormat("DEBUG( //\n"
+               "    {\n"
+               "      f(); //\n"
+               "    },\n"
+               "    a);");
+
+  EXPECT_EQ("call(parameter, {\n"
+            "  something();\n"
+            "  // Comment too\n"
+            "  // looooooooooong.\n"
+            "  somethingElse();\n"
+            "});",
+            format("call(parameter, {\n"
+                   "  something();\n"
+                   "  // Comment too looooooooooong.\n"
+                   "  somethingElse();\n"
+                   "});",
+                   getLLVMStyleWithColumns(29)));
+  EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
+  EXPECT_EQ("DEBUG({ // comment\n"
+            "  int i;\n"
+            "});",
+            format("DEBUG({ // comment\n"
+                   "int  i;\n"
+                   "});"));
+  EXPECT_EQ("DEBUG({\n"
+            "  int i;\n"
+            "\n"
+            "  // comment\n"
+            "  int j;\n"
+            "});",
+            format("DEBUG({\n"
+                   "  int  i;\n"
+                   "\n"
+                   "  // comment\n"
+                   "  int  j;\n"
+                   "});"));
+
+  verifyFormat("DEBUG({\n"
+               "  if (a)\n"
+               "    return;\n"
+               "});");
+  verifyGoogleFormat("DEBUG({\n"
+                     "  if (a) return;\n"
+                     "});");
+  FormatStyle Style = getGoogleStyle();
+  Style.ColumnLimit = 45;
+  verifyFormat("Debug(aaaaa,\n"
+               "      {\n"
+               "        if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
+               "      },\n"
+               "      a);",
+               Style);
+
+  verifyFormat("SomeFunction({MACRO({ return output; }), b});");
+
+  verifyNoCrash("^{v^{a}}");
+}
+
+TEST_F(FormatTest, FormatNestedBlocksInMacros) {
+  EXPECT_EQ("#define MACRO()                     \\\n"
+            "  Debug(aaa, /* force line break */ \\\n"
+            "        {                           \\\n"
+            "          int i;                    \\\n"
+            "          int j;                    \\\n"
+            "        })",
+            format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
+                   "          {  int   i;  int  j;   })",
+                   getGoogleStyle()));
+
+  EXPECT_EQ("#define A                                       \\\n"
+            "  [] {                                          \\\n"
+            "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
+            "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
+            "  }",
+            format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
+                   "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
+                   getGoogleStyle()));
+}
+
+TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
+  EXPECT_EQ("{}", format("{}"));
+  verifyFormat("enum E {};");
+  verifyFormat("enum E {}");
+}
+
+TEST_F(FormatTest, FormatBeginBlockEndMacros) {
+  FormatStyle Style = getLLVMStyle();
+  Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
+  Style.MacroBlockEnd = "^[A-Z_]+_END$";
+  verifyFormat("FOO_BEGIN\n"
+               "  FOO_ENTRY\n"
+               "FOO_END", Style);
+  verifyFormat("FOO_BEGIN\n"
+               "  NESTED_FOO_BEGIN\n"
+               "    NESTED_FOO_ENTRY\n"
+               "  NESTED_FOO_END\n"
+               "FOO_END", Style);
+  verifyFormat("FOO_BEGIN(Foo, Bar)\n"
+               "  int x;\n"
+               "  x = 1;\n"
+               "FOO_END(Baz)", Style);
+}
+
+//===----------------------------------------------------------------------===//
+// Line break tests.
+//===----------------------------------------------------------------------===//
+
+TEST_F(FormatTest, PreventConfusingIndents) {
+  verifyFormat(
+      "void f() {\n"
+      "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
+      "                         parameter, parameter, parameter)),\n"
+      "                     SecondLongCall(parameter));\n"
+      "}");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
+      "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
+  verifyFormat("int a = bbbb && ccc &&\n"
+               "        fffff(\n"
+               "#define A Just forcing a new line\n"
+               "            ddd);");
+}
+
+TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
+  verifyFormat(
+      "bool aaaaaaa =\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
+      "    bbbbbbbb();");
+  verifyFormat(
+      "bool aaaaaaa =\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
+      "    bbbbbbbb();");
+
+  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
+               "    ccccccccc == ddddddddddd;");
+  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
+               "    ccccccccc == ddddddddddd;");
+  verifyFormat(
+      "bool aaaaaaaaaaaaaaaaaaaaa =\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
+      "    ccccccccc == ddddddddddd;");
+
+  verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
+               "                 aaaaaa) &&\n"
+               "         bbbbbb && cccccc;");
+  verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
+               "                 aaaaaa) >>\n"
+               "         bbbbbb;");
+  verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
+               "    SourceMgr.getSpellingColumnNumber(\n"
+               "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
+               "    1);");
+
+  verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+               "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
+               "    cccccc) {\n}");
+  verifyFormat("b = a &&\n"
+               "    // Comment\n"
+               "    b.c && d;");
+
+  // If the LHS of a comparison is not a binary expression itself, the
+  // additional linebreak confuses many people.
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
+      "}");
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
+      "}");
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
+      "}");
+  // Even explicit parentheses stress the precedence enough to make the
+  // additional break unnecessary.
+  verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
+               "}");
+  // This cases is borderline, but with the indentation it is still readable.
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
+      "}",
+      getLLVMStyleWithColumns(75));
+
+  // If the LHS is a binary expression, we should still use the additional break
+  // as otherwise the formatting hides the operator precedence.
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
+               "    5) {\n"
+               "}");
+
+  FormatStyle OnePerLine = getLLVMStyle();
+  OnePerLine.BinPackParameters = false;
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
+      OnePerLine);
+
+  verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
+               "                .aaa(aaaaaaaaaaaaa) *\n"
+               "            aaaaaaa +\n"
+               "        aaaaaaa;",
+               getLLVMStyleWithColumns(40));
+}
+
+TEST_F(FormatTest, ExpressionIndentation) {
+  verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
+               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
+               "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
+               "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
+               "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
+               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
+               "                 ccccccccccccccccccccccccccccccccccccccccc;");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
+               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
+               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
+               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
+               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
+               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
+  verifyFormat("if () {\n"
+               "} else if (aaaaa && bbbbb > // break\n"
+               "                        ccccc) {\n"
+               "}");
+  verifyFormat("if () {\n"
+               "} else if (aaaaa &&\n"
+               "           bbbbb > // break\n"
+               "               ccccc &&\n"
+               "           ddddd) {\n"
+               "}");
+
+  // Presence of a trailing comment used to change indentation of b.
+  verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
+               "       b;\n"
+               "return aaaaaaaaaaaaaaaaaaa +\n"
+               "       b; //",
+               getLLVMStyleWithColumns(30));
+}
+
+TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
+  // Not sure what the best system is here. Like this, the LHS can be found
+  // immediately above an operator (everything with the same or a higher
+  // indent). The RHS is aligned right of the operator and so compasses
+  // everything until something with the same indent as the operator is found.
+  // FIXME: Is this a good system?
+  FormatStyle Style = getLLVMStyle();
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  verifyFormat(
+      "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+      "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+      "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                    > ccccccccccccccccccccccccccccccccccccccccc;",
+      Style);
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
+               Style);
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
+               Style);
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
+               Style);
+  verifyFormat("if () {\n"
+               "} else if (aaaaa\n"
+               "           && bbbbb // break\n"
+               "                  > ccccc) {\n"
+               "}",
+               Style);
+  verifyFormat("return (a)\n"
+               "       // comment\n"
+               "       + b;",
+               Style);
+  verifyFormat(
+      "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+      "             + cc;",
+      Style);
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
+               Style);
+
+  // Forced by comments.
+  verifyFormat(
+      "unsigned ContentSize =\n"
+      "    sizeof(int16_t)   // DWARF ARange version number\n"
+      "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
+      "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
+      "    + sizeof(int8_t); // Segment Size (in bytes)");
+
+  verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
+               "       == boost::fusion::at_c<1>(iiii).second;",
+               Style);
+
+  Style.ColumnLimit = 60;
+  verifyFormat("zzzzzzzzzz\n"
+               "    = bbbbbbbbbbbbbbbbb\n"
+               "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               Style);
+}
+
+TEST_F(FormatTest, EnforcedOperatorWraps) {
+  // Here we'd like to wrap after the || operators, but a comment is forcing an
+  // earlier wrap.
+  verifyFormat("bool x = aaaaa //\n"
+               "         || bbbbb\n"
+               "         //\n"
+               "         || cccc;");
+}
+
+TEST_F(FormatTest, NoOperandAlignment) {
+  FormatStyle Style = getLLVMStyle();
+  Style.AlignOperands = false;
+  verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
+               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               Style);
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
+  verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+               "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+               "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        > ccccccccccccccccccccccccccccccccccccccccc;",
+               Style);
+
+  verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+               "    + cc;",
+               Style);
+  verifyFormat("int a = aa\n"
+               "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
+               "        * cccccccccccccccccccccccccccccccccccc;\n",
+               Style);
+
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  verifyFormat("return (a > b\n"
+               "    // comment1\n"
+               "    // comment2\n"
+               "    || c);",
+               Style);
+}
+
+TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
+  FormatStyle Style = getLLVMStyle();
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
+  verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
+               Style);
+}
+
+TEST_F(FormatTest, ConstructorInitializers) {
+  verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
+  verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
+               getLLVMStyleWithColumns(45));
+  verifyFormat("Constructor()\n"
+               "    : Inttializer(FitsOnTheLine) {}",
+               getLLVMStyleWithColumns(44));
+  verifyFormat("Constructor()\n"
+               "    : Inttializer(FitsOnTheLine) {}",
+               getLLVMStyleWithColumns(43));
+
+  verifyFormat("template <typename T>\n"
+               "Constructor() : Initializer(FitsOnTheLine) {}",
+               getLLVMStyleWithColumns(45));
+
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
+
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+      "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+      "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
+  verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    : aaaaaaaaaa(aaaaaa) {}");
+
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
+
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
+
+  verifyFormat("Constructor(int Parameter = 0)\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
+               "}",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
+
+  // Here a line could be saved by splitting the second initializer onto two
+  // lines, but that is not desirable.
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
+
+  FormatStyle OnePerLine = getLLVMStyle();
+  OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+  OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
+               OnePerLine);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
+               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
+               OnePerLine);
+  verifyFormat("MyClass::MyClass(int var)\n"
+               "    : some_var_(var),            // 4 space indent\n"
+               "      some_other_var_(var + 1) { // lined up\n"
+               "}",
+               OnePerLine);
+  verifyFormat("Constructor()\n"
+               "    : aaaaa(aaaaaa),\n"
+               "      aaaaa(aaaaaa),\n"
+               "      aaaaa(aaaaaa),\n"
+               "      aaaaa(aaaaaa),\n"
+               "      aaaaa(aaaaaa) {}",
+               OnePerLine);
+  verifyFormat("Constructor()\n"
+               "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
+               "            aaaaaaaaaaaaaaaaaaaaaa) {}",
+               OnePerLine);
+  OnePerLine.BinPackParameters = false;
+  verifyFormat(
+      "Constructor()\n"
+      "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "          aaaaaaaaaaa().aaa(),\n"
+      "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
+      OnePerLine);
+  OnePerLine.ColumnLimit = 60;
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
+               "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
+               OnePerLine);
+
+  EXPECT_EQ("Constructor()\n"
+            "    : // Comment forcing unwanted break.\n"
+            "      aaaa(aaaa) {}",
+            format("Constructor() :\n"
+                   "    // Comment forcing unwanted break.\n"
+                   "    aaaa(aaaa) {}"));
+}
+
+TEST_F(FormatTest, MemoizationTests) {
+  // This breaks if the memoization lookup does not take \c Indent and
+  // \c LastSpace into account.
+  verifyFormat(
+      "extern CFRunLoopTimerRef\n"
+      "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
+      "                     CFTimeInterval interval, CFOptionFlags flags,\n"
+      "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
+      "                     CFRunLoopTimerContext *context) {}");
+
+  // Deep nesting somewhat works around our memoization.
+  verifyFormat(
+      "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
+      "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
+      "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
+      "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
+      "                aaaaa())))))))))))))))))))))))))))))))))))))));",
+      getLLVMStyleWithColumns(65));
+  verifyFormat(
+      "aaaaa(\n"
+      "    aaaaa,\n"
+      "    aaaaa(\n"
+      "        aaaaa,\n"
+      "        aaaaa(\n"
+      "            aaaaa,\n"
+      "            aaaaa(\n"
+      "                aaaaa,\n"
+      "                aaaaa(\n"
+      "                    aaaaa,\n"
+      "                    aaaaa(\n"
+      "                        aaaaa,\n"
+      "                        aaaaa(\n"
+      "                            aaaaa,\n"
+      "                            aaaaa(\n"
+      "                                aaaaa,\n"
+      "                                aaaaa(\n"
+      "                                    aaaaa,\n"
+      "                                    aaaaa(\n"
+      "                                        aaaaa,\n"
+      "                                        aaaaa(\n"
+      "                                            aaaaa,\n"
+      "                                            aaaaa(\n"
+      "                                                aaaaa,\n"
+      "                                                aaaaa))))))))))));",
+      getLLVMStyleWithColumns(65));
+  verifyFormat(
+      "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
+      "                                  a),\n"
+      "                                a),\n"
+      "                              a),\n"
+      "                            a),\n"
+      "                          a),\n"
+      "                        a),\n"
+      "                      a),\n"
+      "                    a),\n"
+      "                  a),\n"
+      "                a),\n"
+      "              a),\n"
+      "            a),\n"
+      "          a),\n"
+      "        a),\n"
+      "      a),\n"
+      "    a),\n"
+      "  a)",
+      getLLVMStyleWithColumns(65));
+
+  // This test takes VERY long when memoization is broken.
+  FormatStyle OnePerLine = getLLVMStyle();
+  OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+  OnePerLine.BinPackParameters = false;
+  std::string input = "Constructor()\n"
+                      "    : aaaa(a,\n";
+  for (unsigned i = 0, e = 80; i != e; ++i) {
+    input += "           a,\n";
+  }
+  input += "           a) {}";
+  verifyFormat(input, OnePerLine);
+}
+
+TEST_F(FormatTest, BreaksAsHighAsPossible) {
+  verifyFormat(
+      "void f() {\n"
+      "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
+      "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
+      "    f();\n"
+      "}");
+  verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
+               "    Intervals[i - 1].getRange().getLast()) {\n}");
+}
+
+TEST_F(FormatTest, BreaksFunctionDeclarations) {
+  // Principially, we break function declarations in a certain order:
+  // 1) break amongst arguments.
+  verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
+               "                              Cccccccccccccc cccccccccccccc);");
+  verifyFormat("template <class TemplateIt>\n"
+               "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
+               "                            TemplateIt *stop) {}");
+
+  // 2) break after return type.
+  verifyFormat(
+      "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
+      getGoogleStyle());
+
+  // 3) break after (.
+  verifyFormat(
+      "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
+      "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
+      getGoogleStyle());
+
+  // 4) break before after nested name specifiers.
+  verifyFormat(
+      "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
+      "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
+      getGoogleStyle());
+
+  // However, there are exceptions, if a sufficient amount of lines can be
+  // saved.
+  // FIXME: The precise cut-offs wrt. the number of saved lines might need some
+  // more adjusting.
+  verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
+               "                                  Cccccccccccccc cccccccccc,\n"
+               "                                  Cccccccccccccc cccccccccc,\n"
+               "                                  Cccccccccccccc cccccccccc,\n"
+               "                                  Cccccccccccccc cccccccccc);");
+  verifyFormat(
+      "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
+      "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
+      "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
+      getGoogleStyle());
+  verifyFormat(
+      "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
+      "                                          Cccccccccccccc cccccccccc,\n"
+      "                                          Cccccccccccccc cccccccccc,\n"
+      "                                          Cccccccccccccc cccccccccc,\n"
+      "                                          Cccccccccccccc cccccccccc,\n"
+      "                                          Cccccccccccccc cccccccccc,\n"
+      "                                          Cccccccccccccc cccccccccc);");
+  verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
+               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
+               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
+               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
+               "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
+
+  // Break after multi-line parameters.
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "    bbbb bbbb);");
+  verifyFormat("void SomeLoooooooooooongFunction(\n"
+               "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "    int bbbbbbbbbbbbb);");
+
+  // Treat overloaded operators like other functions.
+  verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
+               "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
+  verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
+               "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
+  verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
+               "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
+  verifyGoogleFormat(
+      "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
+      "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
+  verifyGoogleFormat(
+      "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
+      "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
+               "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
+  verifyGoogleFormat(
+      "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
+      "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
+  verifyGoogleFormat(
+      "template <typename T>\n"
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
+
+  FormatStyle Style = getLLVMStyle();
+  Style.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
+               Style);
+  verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
+               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
+               Style);
+}
+
+TEST_F(FormatTest, TrailingReturnType) {
+  verifyFormat("auto foo() -> int;\n");
+  verifyFormat("struct S {\n"
+               "  auto bar() const -> int;\n"
+               "};");
+  verifyFormat("template <size_t Order, typename T>\n"
+               "auto load_img(const std::string &filename)\n"
+               "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
+  verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
+               "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
+  verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
+  verifyFormat("template <typename T>\n"
+               "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
+               "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
+
+  // Not trailing return types.
+  verifyFormat("void f() { auto a = b->c(); }");
+}
+
+TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
+  // Avoid breaking before trailing 'const' or other trailing annotations, if
+  // they are not function-like.
+  FormatStyle Style = getGoogleStyle();
+  Style.ColumnLimit = 47;
+  verifyFormat("void someLongFunction(\n"
+               "    int someLoooooooooooooongParameter) const {\n}",
+               getLLVMStyleWithColumns(47));
+  verifyFormat("LoooooongReturnType\n"
+               "someLoooooooongFunction() const {}",
+               getLLVMStyleWithColumns(47));
+  verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
+               "    const {}",
+               Style);
+  verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
+               "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
+  verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
+               "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
+  verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
+               "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
+  verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
+               "                   aaaaaaaaaaa aaaaa) const override;");
+  verifyGoogleFormat(
+      "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+      "    const override;");
+
+  // Even if the first parameter has to be wrapped.
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) const {}",
+               getLLVMStyleWithColumns(46));
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) const {}",
+               Style);
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) override {}",
+               Style);
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) OVERRIDE {}",
+               Style);
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) final {}",
+               Style);
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) FINAL {}",
+               Style);
+  verifyFormat("void someLongFunction(\n"
+               "    int parameter) const override {}",
+               Style);
+
+  Style.BreakBeforeBraces = FormatStyle::BS_Allman;
+  verifyFormat("void someLongFunction(\n"
+               "    int someLongParameter) const\n"
+               "{\n"
+               "}",
+               Style);
+
+  // Unless these are unknown annotations.
+  verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
+               "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    LONG_AND_UGLY_ANNOTATION;");
+
+  // Breaking before function-like trailing annotations is fine to keep them
+  // close to their arguments.
+  verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
+  verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
+               "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
+  verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
+               "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
+  verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
+                     "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
+  verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
+
+  verifyFormat(
+      "void aaaaaaaaaaaaaaaaaa()\n"
+      "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
+  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    __attribute__((unused));");
+  verifyGoogleFormat(
+      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    GUARDED_BY(aaaaaaaaaaaa);");
+  verifyGoogleFormat(
+      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    GUARDED_BY(aaaaaaaaaaaa);");
+  verifyGoogleFormat(
+      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
+      "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyGoogleFormat(
+      "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
+}
+
+TEST_F(FormatTest, FunctionAnnotations) {
+  verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
+               "int OldFunction(const string &parameter) {}");
+  verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
+               "string OldFunction(const string &parameter) {}");
+  verifyFormat("template <typename T>\n"
+               "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
+               "string OldFunction(const string &parameter) {}");
+
+  // Not function annotations.
+  verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+  verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
+               "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
+  verifyFormat("MACRO(abc).function() // wrap\n"
+               "    << abc;");
+  verifyFormat("MACRO(abc)->function() // wrap\n"
+               "    << abc;");
+  verifyFormat("MACRO(abc)::function() // wrap\n"
+               "    << abc;");
+}
+
+TEST_F(FormatTest, BreaksDesireably) {
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
+               "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
+               "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
+               "}");
+
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
+
+  verifyFormat(
+      "aaaaaaaa(aaaaaaaaaaaaa,\n"
+      "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
+      "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+               "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat(
+      "void f() {\n"
+      "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
+      "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
+      "}");
+  verifyFormat(
+      "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
+  verifyFormat(
+      "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
+  verifyFormat(
+      "aaaaaa(aaa,\n"
+      "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+      "       aaaa);");
+  verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+               "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  // Indent consistently independent of call expression and unary operator.
+  verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
+               "    dddddddddddddddddddddddddddddd));");
+  verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
+               "    dddddddddddddddddddddddddddddd));");
+  verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
+               "    dddddddddddddddddddddddddddddd));");
+
+  // This test case breaks on an incorrect memoization, i.e. an optimization not
+  // taking into account the StopAt value.
+  verifyFormat(
+      "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
+      "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
+      "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
+      "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat("{\n  {\n    {\n"
+               "      Annotation.SpaceRequiredBefore =\n"
+               "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
+               "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
+               "    }\n  }\n}");
+
+  // Break on an outer level if there was a break on an inner level.
+  EXPECT_EQ("f(g(h(a, // comment\n"
+            "      b, c),\n"
+            "    d, e),\n"
+            "  x, y);",
+            format("f(g(h(a, // comment\n"
+                   "    b, c), d, e), x, y);"));
+
+  // Prefer breaking similar line breaks.
+  verifyFormat(
+      "const int kTrackingOptions = NSTrackingMouseMoved |\n"
+      "                             NSTrackingMouseEnteredAndExited |\n"
+      "                             NSTrackingActiveAlways;");
+}
+
+TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
+  FormatStyle NoBinPacking = getGoogleStyle();
+  NoBinPacking.BinPackParameters = false;
+  NoBinPacking.BinPackArguments = true;
+  verifyFormat("void f() {\n"
+               "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
+               "}",
+               NoBinPacking);
+  verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
+               "       int aaaaaaaaaaaaaaaaaaaa,\n"
+               "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
+               NoBinPacking);
+
+  NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
+  verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                        vector<int> bbbbbbbbbbbbbbb);",
+               NoBinPacking);
+  // FIXME: This behavior difference is probably not wanted. However, currently
+  // we cannot distinguish BreakBeforeParameter being set because of the wrapped
+  // template arguments from BreakBeforeParameter being set because of the
+  // one-per-line formatting.
+  verifyFormat(
+      "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                                             aaaaaaaaaa> aaaaaaaaaa);",
+      NoBinPacking);
+  verifyFormat(
+      "void fffffffffff(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
+      "        aaaaaaaaaa);");
+}
+
+TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
+  FormatStyle NoBinPacking = getGoogleStyle();
+  NoBinPacking.BinPackParameters = false;
+  NoBinPacking.BinPackArguments = false;
+  verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
+               "  aaaaaaaaaaaaaaaaaaaa,\n"
+               "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
+               NoBinPacking);
+  verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
+               "        aaaaaaaaaaaaa,\n"
+               "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
+               NoBinPacking);
+  verifyFormat(
+      "aaaaaaaa(aaaaaaaaaaaaa,\n"
+      "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
+      "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
+      NoBinPacking);
+  verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaaaaaaaaaaaaaaaaa();",
+               NoBinPacking);
+  verifyFormat("void f() {\n"
+               "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
+               "}",
+               NoBinPacking);
+
+  verifyFormat(
+      "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "             aaaaaaaaaaaa,\n"
+      "             aaaaaaaaaaaa);",
+      NoBinPacking);
+  verifyFormat(
+      "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
+      "                               ddddddddddddddddddddddddddddd),\n"
+      "             test);",
+      NoBinPacking);
+
+  verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
+               "    aaaaaaaaaaaaaaaaaa;",
+               NoBinPacking);
+  verifyFormat("a(\"a\"\n"
+               "  \"a\",\n"
+               "  a);");
+
+  NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
+  verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
+               "                aaaaaaaaa,\n"
+               "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               NoBinPacking);
+  verifyFormat(
+      "void f() {\n"
+      "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
+      "      .aaaaaaa();\n"
+      "}",
+      NoBinPacking);
+  verifyFormat(
+      "template <class SomeType, class SomeOtherType>\n"
+      "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
+      NoBinPacking);
+}
+
+TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
+  FormatStyle Style = getLLVMStyleWithColumns(15);
+  Style.ExperimentalAutoDetectBinPacking = true;
+  EXPECT_EQ("aaa(aaaa,\n"
+            "    aaaa,\n"
+            "    aaaa);\n"
+            "aaa(aaaa,\n"
+            "    aaaa,\n"
+            "    aaaa);",
+            format("aaa(aaaa,\n" // one-per-line
+                   "  aaaa,\n"
+                   "    aaaa  );\n"
+                   "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
+                   Style));
+  EXPECT_EQ("aaa(aaaa, aaaa,\n"
+            "    aaaa);\n"
+            "aaa(aaaa, aaaa,\n"
+            "    aaaa);",
+            format("aaa(aaaa,  aaaa,\n" // bin-packed
+                   "    aaaa  );\n"
+                   "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
+                   Style));
+}
+
+TEST_F(FormatTest, FormatsBuilderPattern) {
+  verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
+               "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
+               "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
+               "    .StartsWith(\".init\", ORDER_INIT)\n"
+               "    .StartsWith(\".fini\", ORDER_FINI)\n"
+               "    .StartsWith(\".hash\", ORDER_HASH)\n"
+               "    .Default(ORDER_TEXT);\n");
+
+  verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
+               "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
+  verifyFormat(
+      "aaaaaaa->aaaaaaa\n"
+      "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+      "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaa->aaaaaaa\n"
+      "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+      "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
+      "    aaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
+      "    aaaaaa->aaaaaaaaaaaa()\n"
+      "        ->aaaaaaaaaaaaaaaa(\n"
+      "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+      "        ->aaaaaaaaaaaaaaaaa();");
+  verifyGoogleFormat(
+      "void f() {\n"
+      "  someo->Add((new util::filetools::Handler(dir))\n"
+      "                 ->OnEvent1(NewPermanentCallback(\n"
+      "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
+      "                 ->OnEvent2(NewPermanentCallback(\n"
+      "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
+      "                 ->OnEvent3(NewPermanentCallback(\n"
+      "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
+      "                 ->OnEvent5(NewPermanentCallback(\n"
+      "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
+      "                 ->OnEvent6(NewPermanentCallback(\n"
+      "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
+      "}");
+
+  verifyFormat(
+      "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
+  verifyFormat("aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa();");
+  verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa();");
+  verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaa();");
+  verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    ->aaaaaaaaaaaaaae(0)\n"
+               "    ->aaaaaaaaaaaaaaa();");
+
+  // Don't linewrap after very short segments.
+  verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat("aaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
+
+  // Prefer not to break after empty parentheses.
+  verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
+               "    First->LastNewlineOffset);");
+
+  // Prefer not to create "hanging" indents.
+  verifyFormat(
+      "return !soooooooooooooome_map\n"
+      "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+      "            .second;");
+  verifyFormat(
+      "return aaaaaaaaaaaaaaaa\n"
+      "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
+      "    .aaaa(aaaaaaaaaaaaaa);");
+  // No hanging indent here.
+  verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("aaaaaaaaaaaaaaaaaa\n"
+               "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               getLLVMStyleWithColumns(59));
+  verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+}
+
+TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+      "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
+      "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
+
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
+               "    ccccccccccccccccccccccccc) {\n}");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
+               "    ccccccccccccccccccccccccc) {\n}");
+
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
+               "    ccccccccccccccccccccccccc) {\n}");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
+               "    ccccccccccccccccccccccccc) {\n}");
+
+  verifyFormat(
+      "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
+      "    ccccccccccccccccccccccccc) {\n}");
+  verifyFormat(
+      "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
+      "    ccccccccccccccccccccccccc) {\n}");
+
+  verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
+               "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
+               "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
+               "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
+  verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
+               "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
+               "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
+               "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
+
+  verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
+               "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
+               "    aaaaaaaaaaaaaaa != aa) {\n}");
+  verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
+               "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
+               "    aaaaaaaaaaaaaaa != aa) {\n}");
+}
+
+TEST_F(FormatTest, BreaksAfterAssignments) {
+  verifyFormat(
+      "unsigned Cost =\n"
+      "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
+      "                        SI->getPointerAddressSpaceee());\n");
+  verifyFormat(
+      "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
+      "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
+
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("unsigned OriginalStartColumn =\n"
+               "    SourceMgr.getSpellingColumnNumber(\n"
+               "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
+               "    1;");
+}
+
+TEST_F(FormatTest, AlignsAfterAssignments) {
+  verifyFormat(
+      "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
+}
+
+TEST_F(FormatTest, AlignsAfterReturn) {
+  verifyFormat(
+      "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
+      "       aaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat(
+      "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
+      "        aaaaaaaaaaaaaaaaaaaaaa());");
+  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat("return\n"
+               "    // true if code is one of a or b.\n"
+               "    code == a || code == b;");
+}
+
+TEST_F(FormatTest, AlignsAfterOpenBracket) {
+  verifyFormat(
+      "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
+      "                                                aaaaaaaaa aaaaaaa) {}");
+  verifyFormat(
+      "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
+      "                                               aaaaaaaaaaa aaaaaaaaa);");
+  verifyFormat(
+      "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
+      "                                             aaaaaaaaaaaaaaaaaaaaa));");
+  FormatStyle Style = getLLVMStyle();
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
+               Style);
+  verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
+               "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
+               Style);
+  verifyFormat("SomeLongVariableName->someFunction(\n"
+               "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
+               Style);
+  verifyFormat(
+      "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
+      "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
+      Style);
+  verifyFormat(
+      "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
+      "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
+      "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
+      Style);
+
+  verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
+               "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
+               "        b));",
+               Style);
+
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+  Style.BinPackArguments = false;
+  Style.BinPackParameters = false;
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaa aaaaaaaa,\n"
+               "    aaaaaaaaa aaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
+               Style);
+  verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
+               "    aaaaaaaaaaa aaaaaaaaa,\n"
+               "    aaaaaaaaaaa aaaaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               Style);
+  verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
+               "    aaaaaaaaaaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
+               Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
+      Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
+      Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
+      "    aaaaaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
+      "    aaaaaaaaaaaaaaaa);",
+      Style);
+}
+
+TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
+  FormatStyle Style = getLLVMStyleWithColumns(40);
+  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
+               "          bbbbbbbbbbbbbbbbbbbbbb);",
+               Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
+  Style.AlignOperands = false;
+  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
+               "          bbbbbbbbbbbbbbbbbbbbbb);",
+               Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  Style.AlignOperands = true;
+  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
+               "          bbbbbbbbbbbbbbbbbbbbbb);",
+               Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  Style.AlignOperands = false;
+  verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
+               "    bbbbbbbbbbbbbbbbbbbbbb);",
+               Style);
+}
+
+TEST_F(FormatTest, BreaksConditionalExpressions) {
+  verifyFormat(
+      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
+      "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaa(aaaaaaaaa, aaaaaaaaa,\n"
+      "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
+      "                                                    : aaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaa);");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaa);");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        : aaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    ? aaaaaaaaaaaaaaa\n"
+      "    : aaaaaaaaaaaaaaa;");
+  verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
+               "          aaaaaaaaa\n"
+               "      ? b\n"
+               "      : c);");
+  verifyFormat("return aaaa == bbbb\n"
+               "           // comment\n"
+               "           ? aaaa\n"
+               "           : bbbb;");
+  verifyFormat("unsigned Indent =\n"
+               "    format(TheLine.First,\n"
+               "           IndentForLevel[TheLine.Level] >= 0\n"
+               "               ? IndentForLevel[TheLine.Level]\n"
+               "               : TheLine * 2,\n"
+               "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
+               "                  ? aaaaaaaaaaaaaaa\n"
+               "                  : bbbbbbbbbbbbbbb //\n"
+               "                        ? ccccccccccccccc\n"
+               "                        : ddddddddddddddd;");
+  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
+               "                  ? aaaaaaaaaaaaaaa\n"
+               "                  : (bbbbbbbbbbbbbbb //\n"
+               "                         ? ccccccccccccccc\n"
+               "                         : ddddddddddddddd);");
+  verifyFormat(
+      "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
+      "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
+      "                                            aaaaaaaaaaaaaaaaaaaaa\n"
+      "                                      : aaaaaaaaaa;");
+  verifyFormat(
+      "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
+      "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+
+  FormatStyle NoBinPacking = getLLVMStyle();
+  NoBinPacking.BinPackArguments = false;
+  verifyFormat(
+      "void f() {\n"
+      "  g(aaa,\n"
+      "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "        ? aaaaaaaaaaaaaaa\n"
+      "        : aaaaaaaaaaaaaaa);\n"
+      "}",
+      NoBinPacking);
+  verifyFormat(
+      "void f() {\n"
+      "  g(aaa,\n"
+      "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "        ?: aaaaaaaaaaaaaaa);\n"
+      "}",
+      NoBinPacking);
+
+  verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
+               "             // comment.\n"
+               "             ccccccccccccccccccccccccccccccccccccccc\n"
+               "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
+
+  // Assignments in conditional expressions. Apparently not uncommon :-(.
+  verifyFormat("return a != b\n"
+               "           // comment\n"
+               "           ? a = b\n"
+               "           : a = b;");
+  verifyFormat("return a != b\n"
+               "           // comment\n"
+               "           ? a = a != b\n"
+               "                     // comment\n"
+               "                     ? a = b\n"
+               "                     : a\n"
+               "           : a;\n");
+  verifyFormat("return a != b\n"
+               "           // comment\n"
+               "           ? a\n"
+               "           : a = a != b\n"
+               "                     // comment\n"
+               "                     ? a = b\n"
+               "                     : a;");
+}
+
+TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
+  FormatStyle Style = getLLVMStyle();
+  Style.BreakBeforeTernaryOperators = false;
+  Style.ColumnLimit = 70;
+  verifyFormat(
+      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+      "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+      "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
+      "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+      "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+      "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaa(aaaaaaaa, aaaaaaaaaa,\n"
+      "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+      "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
+      "                                                      aaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+      "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaa);",
+      Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaa);",
+      Style);
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               Style);
+  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
+               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               Style);
+  verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
+               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
+               "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               Style);
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
+               Style);
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
+               Style);
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+      "    aaaaaaaaaaaaaaa :\n"
+      "    aaaaaaaaaaaaaaa;",
+      Style);
+  verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
+               "          aaaaaaaaa ?\n"
+               "      b :\n"
+               "      c);",
+               Style);
+  verifyFormat("unsigned Indent =\n"
+               "    format(TheLine.First,\n"
+               "           IndentForLevel[TheLine.Level] >= 0 ?\n"
+               "               IndentForLevel[TheLine.Level] :\n"
+               "               TheLine * 2,\n"
+               "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
+               Style);
+  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
+               "                  aaaaaaaaaaaaaaa :\n"
+               "                  bbbbbbbbbbbbbbb ? //\n"
+               "                      ccccccccccccccc :\n"
+               "                      ddddddddddddddd;",
+               Style);
+  verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
+               "                  aaaaaaaaaaaaaaa :\n"
+               "                  (bbbbbbbbbbbbbbb ? //\n"
+               "                       ccccccccccccccc :\n"
+               "                       ddddddddddddddd);",
+               Style);
+  verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+               "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
+               "            ccccccccccccccccccccccccccc;",
+               Style);
+  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
+               "           aaaaa :\n"
+               "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
+               Style);
+}
+
+TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
+  verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
+               "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
+  verifyFormat("bool a = true, b = false;");
+
+  verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+               "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
+               "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
+               "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
+  verifyFormat(
+      "bool aaaaaaaaaaaaaaaaaaaaa =\n"
+      "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
+      "     d = e && f;");
+  verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
+               "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
+  verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
+               "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
+  verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
+               "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
+
+  FormatStyle Style = getGoogleStyle();
+  Style.PointerAlignment = FormatStyle::PAS_Left;
+  Style.DerivePointerAlignment = false;
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
+               "    *b = bbbbbbbbbbbbbbbbbbb;",
+               Style);
+  verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
+               "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
+               Style);
+  verifyFormat("vector<int*> a, b;", Style);
+  verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
+}
+
+TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
+  verifyFormat("arr[foo ? bar : baz];");
+  verifyFormat("f()[foo ? bar : baz];");
+  verifyFormat("(a + b)[foo ? bar : baz];");
+  verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
+}
+
+TEST_F(FormatTest, AlignsStringLiterals) {
+  verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
+               "                                      \"short literal\");");
+  verifyFormat(
+      "looooooooooooooooooooooooongFunction(\n"
+      "    \"short literal\"\n"
+      "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
+  verifyFormat("someFunction(\"Always break between multi-line\"\n"
+               "             \" string literals\",\n"
+               "             and, other, parameters);");
+  EXPECT_EQ("fun + \"1243\" /* comment */\n"
+            "      \"5678\";",
+            format("fun + \"1243\" /* comment */\n"
+                   "    \"5678\";",
+                   getLLVMStyleWithColumns(28)));
+  EXPECT_EQ(
+      "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
+      "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
+      "         \"aaaaaaaaaaaaaaaa\";",
+      format("aaaaaa ="
+             "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
+             "aaaaaaaaaaaaaaaaaaaaa\" "
+             "\"aaaaaaaaaaaaaaaa\";"));
+  verifyFormat("a = a + \"a\"\n"
+               "        \"a\"\n"
+               "        \"a\";");
+  verifyFormat("f(\"a\", \"b\"\n"
+               "       \"c\");");
+
+  verifyFormat(
+      "#define LL_FORMAT \"ll\"\n"
+      "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
+      "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
+
+  verifyFormat("#define A(X)          \\\n"
+               "  \"aaaaa\" #X \"bbbbbb\" \\\n"
+               "  \"ccccc\"",
+               getLLVMStyleWithColumns(23));
+  verifyFormat("#define A \"def\"\n"
+               "f(\"abc\" A \"ghi\"\n"
+               "  \"jkl\");");
+
+  verifyFormat("f(L\"a\"\n"
+               "  L\"b\");");
+  verifyFormat("#define A(X)            \\\n"
+               "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
+               "  L\"ccccc\"",
+               getLLVMStyleWithColumns(25));
+
+  verifyFormat("f(@\"a\"\n"
+               "  @\"b\");");
+  verifyFormat("NSString s = @\"a\"\n"
+               "             @\"b\"\n"
+               "             @\"c\";");
+  verifyFormat("NSString s = @\"a\"\n"
+               "              \"b\"\n"
+               "              \"c\";");
+}
+
+TEST_F(FormatTest, ReturnTypeBreakingStyle) {
+  FormatStyle Style = getLLVMStyle();
+  // No declarations or definitions should be moved to own line.
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
+  verifyFormat("class A {\n"
+               "  int f() { return 1; }\n"
+               "  int g();\n"
+               "};\n"
+               "int f() { return 1; }\n"
+               "int g();\n",
+               Style);
+
+  // All declarations and definitions should have the return type moved to its
+  // own
+  // line.
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
+  verifyFormat("class E {\n"
+               "  int\n"
+               "  f() {\n"
+               "    return 1;\n"
+               "  }\n"
+               "  int\n"
+               "  g();\n"
+               "};\n"
+               "int\n"
+               "f() {\n"
+               "  return 1;\n"
+               "}\n"
+               "int\n"
+               "g();\n",
+               Style);
+
+  // Top-level definitions, and no kinds of declarations should have the
+  // return type moved to its own line.
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
+  verifyFormat("class B {\n"
+               "  int f() { return 1; }\n"
+               "  int g();\n"
+               "};\n"
+               "int\n"
+               "f() {\n"
+               "  return 1;\n"
+               "}\n"
+               "int g();\n",
+               Style);
+
+  // Top-level definitions and declarations should have the return type moved
+  // to its own line.
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
+  verifyFormat("class C {\n"
+               "  int f() { return 1; }\n"
+               "  int g();\n"
+               "};\n"
+               "int\n"
+               "f() {\n"
+               "  return 1;\n"
+               "}\n"
+               "int\n"
+               "g();\n",
+               Style);
+
+  // All definitions should have the return type moved to its own line, but no
+  // kinds of declarations.
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
+  verifyFormat("class D {\n"
+               "  int\n"
+               "  f() {\n"
+               "    return 1;\n"
+               "  }\n"
+               "  int g();\n"
+               "};\n"
+               "int\n"
+               "f() {\n"
+               "  return 1;\n"
+               "}\n"
+               "int g();\n",
+               Style);
+  verifyFormat("const char *\n"
+               "f(void) {\n" // Break here.
+               "  return \"\";\n"
+               "}\n"
+               "const char *bar(void);\n", // No break here.
+               Style);
+  verifyFormat("template <class T>\n"
+               "T *\n"
+               "f(T &c) {\n" // Break here.
+               "  return NULL;\n"
+               "}\n"
+               "template <class T> T *f(T &c);\n", // No break here.
+               Style);
+  verifyFormat("class C {\n"
+               "  int\n"
+               "  operator+() {\n"
+               "    return 1;\n"
+               "  }\n"
+               "  int\n"
+               "  operator()() {\n"
+               "    return 1;\n"
+               "  }\n"
+               "};\n",
+               Style);
+  verifyFormat("void\n"
+               "A::operator()() {}\n"
+               "void\n"
+               "A::operator>>() {}\n"
+               "void\n"
+               "A::operator+() {}\n",
+               Style);
+  verifyFormat("void *operator new(std::size_t s);", // No break here.
+               Style);
+  verifyFormat("void *\n"
+               "operator new(std::size_t s) {}",
+               Style);
+  verifyFormat("void *\n"
+               "operator delete[](void *ptr) {}",
+               Style);
+  Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
+  verifyFormat("const char *\n"
+               "f(void)\n" // Break here.
+               "{\n"
+               "  return \"\";\n"
+               "}\n"
+               "const char *bar(void);\n", // No break here.
+               Style);
+  verifyFormat("template <class T>\n"
+               "T *\n"     // Problem here: no line break
+               "f(T &c)\n" // Break here.
+               "{\n"
+               "  return NULL;\n"
+               "}\n"
+               "template <class T> T *f(T &c);\n", // No break here.
+               Style);
+}
+
+TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
+  FormatStyle NoBreak = getLLVMStyle();
+  NoBreak.AlwaysBreakBeforeMultilineStrings = false;
+  FormatStyle Break = getLLVMStyle();
+  Break.AlwaysBreakBeforeMultilineStrings = true;
+  verifyFormat("aaaa = \"bbbb\"\n"
+               "       \"cccc\";",
+               NoBreak);
+  verifyFormat("aaaa =\n"
+               "    \"bbbb\"\n"
+               "    \"cccc\";",
+               Break);
+  verifyFormat("aaaa(\"bbbb\"\n"
+               "     \"cccc\");",
+               NoBreak);
+  verifyFormat("aaaa(\n"
+               "    \"bbbb\"\n"
+               "    \"cccc\");",
+               Break);
+  verifyFormat("aaaa(qqq, \"bbbb\"\n"
+               "          \"cccc\");",
+               NoBreak);
+  verifyFormat("aaaa(qqq,\n"
+               "     \"bbbb\"\n"
+               "     \"cccc\");",
+               Break);
+  verifyFormat("aaaa(qqq,\n"
+               "     L\"bbbb\"\n"
+               "     L\"cccc\");",
+               Break);
+  verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
+               "                      \"bbbb\"));",
+               Break);
+  verifyFormat("string s = someFunction(\n"
+               "    \"abc\"\n"
+               "    \"abc\");",
+               Break);
+
+  // As we break before unary operators, breaking right after them is bad.
+  verifyFormat("string foo = abc ? \"x\"\n"
+               "                   \"blah blah blah blah blah blah\"\n"
+               "                 : \"y\";",
+               Break);
+
+  // Don't break if there is no column gain.
+  verifyFormat("f(\"aaaa\"\n"
+               "  \"bbbb\");",
+               Break);
+
+  // Treat literals with escaped newlines like multi-line string literals.
+  EXPECT_EQ("x = \"a\\\n"
+            "b\\\n"
+            "c\";",
+            format("x = \"a\\\n"
+                   "b\\\n"
+                   "c\";",
+                   NoBreak));
+  EXPECT_EQ("xxxx =\n"
+            "    \"a\\\n"
+            "b\\\n"
+            "c\";",
+            format("xxxx = \"a\\\n"
+                   "b\\\n"
+                   "c\";",
+                   Break));
+
+  // Exempt ObjC strings for now.
+  EXPECT_EQ("NSString *const kString = @\"aaaa\"\n"
+            "                          @\"bbbb\";",
+            format("NSString *const kString = @\"aaaa\"\n"
+                   "@\"bbbb\";",
+                   Break));
+
+  Break.ColumnLimit = 0;
+  verifyFormat("const char *hello = \"hello llvm\";", Break);
+}
+
+TEST_F(FormatTest, AlignsPipes) {
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
+      "                     << aaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
+      "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
+      "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
+      "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
+  verifyFormat(
+      "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+      "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
+  verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
+               "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
+  verifyFormat(
+      "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
+      "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
+               "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
+  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                    aaaaaaaaaaaaaaaaaaaaa)\n"
+               "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat("LOG_IF(aaa == //\n"
+               "       bbb)\n"
+               "    << a << b;");
+
+  // But sometimes, breaking before the first "<<" is desirable.
+  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
+               "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
+  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
+               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
+               "    << BEF << IsTemplate << Description << E->getType();");
+  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
+               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
+               "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    << aaa;");
+
+  verifyFormat(
+      "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+
+  // Incomplete string literal.
+  EXPECT_EQ("llvm::errs() << \"\n"
+            "             << a;",
+            format("llvm::errs() << \"\n<<a;"));
+
+  verifyFormat("void f() {\n"
+               "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
+               "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
+               "}");
+
+  // Handle 'endl'.
+  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
+               "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
+  verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
+
+  // Handle '\n'.
+  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
+               "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
+  verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
+               "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
+  verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
+               "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
+  verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
+}
+
+TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
+  verifyFormat("return out << \"somepacket = {\\n\"\n"
+               "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
+               "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
+               "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
+               "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
+               "           << \"}\";");
+
+  verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
+               "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
+               "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
+      "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
+      "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
+      "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
+      "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
+  verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
+               "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
+  verifyFormat(
+      "void f() {\n"
+      "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
+      "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
+      "}");
+
+  // Breaking before the first "<<" is generally not desirable.
+  verifyFormat(
+      "llvm::errs()\n"
+      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
+      getLLVMStyleWithColumns(70));
+  verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
+               "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
+               "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
+               "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
+               getLLVMStyleWithColumns(70));
+
+  verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
+               "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
+               "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
+  verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
+               "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
+               "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
+  verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
+               "           (aaaa + aaaa);",
+               getLLVMStyleWithColumns(40));
+  verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
+               "                  (aaaaaaa + aaaaa));",
+               getLLVMStyleWithColumns(40));
+  verifyFormat(
+      "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
+      "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
+      "                  bbbbbbbbbbbbbbbbbbbbbbb);");
+}
+
+TEST_F(FormatTest, UnderstandsEquals) {
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaa =\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat(
+      "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
+  verifyFormat(
+      "if (a) {\n"
+      "  f();\n"
+      "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+      "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
+      "}");
+
+  verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+               "        100000000 + 10000000) {\n}");
+}
+
+TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
+               "    .looooooooooooooooooooooooooooooooooooooongFunction();");
+
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
+               "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
+
+  verifyFormat(
+      "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
+      "                                                          Parameter2);");
+
+  verifyFormat(
+      "ShortObject->shortFunction(\n"
+      "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
+      "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
+
+  verifyFormat("loooooooooooooongFunction(\n"
+               "    LoooooooooooooongObject->looooooooooooooooongFunction());");
+
+  verifyFormat(
+      "function(LoooooooooooooooooooooooooooooooooooongObject\n"
+      "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
+
+  verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
+               "    .WillRepeatedly(Return(SomeValue));");
+  verifyFormat("void f() {\n"
+               "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
+               "      .Times(2)\n"
+               "      .WillRepeatedly(Return(SomeValue));\n"
+               "}");
+  verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
+               "    ccccccccccccccccccccccc);");
+  verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "          .aaaaa(aaaaa),\n"
+               "      aaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("void f() {\n"
+               "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
+               "}");
+  verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
+               "}");
+
+  // Here, it is not necessary to wrap at "." or "->".
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
+               "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
+  verifyFormat(
+      "aaaaaaaaaaa->aaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
+
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
+  verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
+               "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
+  verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
+               "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
+
+  verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    .a();");
+
+  FormatStyle NoBinPacking = getLLVMStyle();
+  NoBinPacking.BinPackParameters = false;
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
+               "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
+               "                         aaaaaaaaaaaaaaaaaaa,\n"
+               "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+               NoBinPacking);
+
+  // If there is a subsequent call, change to hanging indentation.
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
+      "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
+  verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
+}
+
+TEST_F(FormatTest, WrapsTemplateDeclarations) {
+  verifyFormat("template <typename T>\n"
+               "virtual void loooooooooooongFunction(int Param1, int Param2);");
+  verifyFormat("template <typename T>\n"
+               "// T should be one of {A, B}.\n"
+               "virtual void loooooooooooongFunction(int Param1, int Param2);");
+  verifyFormat(
+      "template <typename T>\n"
+      "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
+  verifyFormat("template <typename T>\n"
+               "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
+               "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
+  verifyFormat(
+      "template <typename T>\n"
+      "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
+      "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
+  verifyFormat(
+      "template <typename T>\n"
+      "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
+      "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
+      "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("template <typename T>\n"
+               "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    int aaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat(
+      "template <typename T1, typename T2 = char, typename T3 = char,\n"
+      "          typename T4 = char>\n"
+      "void f();");
+  verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
+               "          template <typename> class cccccccccccccccccccccc,\n"
+               "          typename ddddddddddddd>\n"
+               "class C {};");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat("void f() {\n"
+               "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
+               "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
+               "}");
+
+  verifyFormat("template <typename T> class C {};");
+  verifyFormat("template <typename T> void f();");
+  verifyFormat("template <typename T> void f() {}");
+  verifyFormat(
+      "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
+      "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
+      "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
+      "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
+      "        bbbbbbbbbbbbbbbbbbbbbbbb);",
+      getLLVMStyleWithColumns(72));
+  EXPECT_EQ("static_cast<A< //\n"
+            "    B> *>(\n"
+            "\n"
+            "    );",
+            format("static_cast<A<//\n"
+                   "    B>*>(\n"
+                   "\n"
+                   "    );"));
+  verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
+
+  FormatStyle AlwaysBreak = getLLVMStyle();
+  AlwaysBreak.AlwaysBreakTemplateDeclarations = true;
+  verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
+  verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
+  verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
+  verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
+               "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
+  verifyFormat("template <template <typename> class Fooooooo,\n"
+               "          template <typename> class Baaaaaaar>\n"
+               "struct C {};",
+               AlwaysBreak);
+  verifyFormat("template <typename T> // T can be A, B or C.\n"
+               "struct C {};",
+               AlwaysBreak);
+  verifyFormat("template <enum E> class A {\n"
+               "public:\n"
+               "  E *f();\n"
+               "};");
+}
+
+TEST_F(FormatTest, WrapsTemplateParameters) {
+  FormatStyle Style = getLLVMStyle();
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
+  verifyFormat(
+      "template <typename... a> struct q {};\n"
+      "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
+      "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
+      "    y;",
+      Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  verifyFormat(
+      "template <typename... a> struct r {};\n"
+      "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
+      "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
+      "    y;",
+      Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
+  verifyFormat(
+      "template <typename... a> struct s {};\n"
+      "extern s<\n"
+      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
+      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
+      "    y;",
+      Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  verifyFormat(
+      "template <typename... a> struct t {};\n"
+      "extern t<\n"
+      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
+      "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
+      "    y;",
+      Style);
+}
+
+TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
+
+  // FIXME: Should we have the extra indent after the second break?
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+      "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+
+  verifyFormat(
+      "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
+      "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
+
+  // Breaking at nested name specifiers is generally not desirable.
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+      "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                   aaaaaaaaaaaaaaaaaaaaa);",
+      getLLVMStyleWithColumns(74));
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
+}
+
+TEST_F(FormatTest, UnderstandsTemplateParameters) {
+  verifyFormat("A<int> a;");
+  verifyFormat("A<A<A<int>>> a;");
+  verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
+  verifyFormat("bool x = a < 1 || 2 > a;");
+  verifyFormat("bool x = 5 < f<int>();");
+  verifyFormat("bool x = f<int>() > 5;");
+  verifyFormat("bool x = 5 < a<int>::x;");
+  verifyFormat("bool x = a < 4 ? a > 2 : false;");
+  verifyFormat("bool x = f() ? a < 2 : a > 2;");
+
+  verifyGoogleFormat("A<A<int>> a;");
+  verifyGoogleFormat("A<A<A<int>>> a;");
+  verifyGoogleFormat("A<A<A<A<int>>>> a;");
+  verifyGoogleFormat("A<A<int> > a;");
+  verifyGoogleFormat("A<A<A<int> > > a;");
+  verifyGoogleFormat("A<A<A<A<int> > > > a;");
+  verifyGoogleFormat("A<::A<int>> a;");
+  verifyGoogleFormat("A<::A> a;");
+  verifyGoogleFormat("A< ::A> a;");
+  verifyGoogleFormat("A< ::A<int> > a;");
+  EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
+  EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
+  EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
+  EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
+  EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
+            format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
+
+  verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
+
+  verifyFormat("test >> a >> b;");
+  verifyFormat("test << a >> b;");
+
+  verifyFormat("f<int>();");
+  verifyFormat("template <typename T> void f() {}");
+  verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
+  verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
+               "sizeof(char)>::type>;");
+  verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
+  verifyFormat("f(a.operator()<A>());");
+  verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "      .template operator()<A>());",
+               getLLVMStyleWithColumns(35));
+
+  // Not template parameters.
+  verifyFormat("return a < b && c > d;");
+  verifyFormat("void f() {\n"
+               "  while (a < b && c > d) {\n"
+               "  }\n"
+               "}");
+  verifyFormat("template <typename... Types>\n"
+               "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
+  verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
+  verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
+}
+
+TEST_F(FormatTest, BitshiftOperatorWidth) {
+  EXPECT_EQ("int a = 1 << 2; /* foo\n"
+            "                   bar */",
+            format("int    a=1<<2;  /* foo\n"
+                   "                   bar */"));
+
+  EXPECT_EQ("int b = 256 >> 1; /* foo\n"
+            "                     bar */",
+            format("int  b  =256>>1 ;  /* foo\n"
+                   "                      bar */"));
+}
+
+TEST_F(FormatTest, UnderstandsBinaryOperators) {
+  verifyFormat("COMPARE(a, ==, b);");
+  verifyFormat("auto s = sizeof...(Ts) - 1;");
+}
+
+TEST_F(FormatTest, UnderstandsPointersToMembers) {
+  verifyFormat("int A::*x;");
+  verifyFormat("int (S::*func)(void *);");
+  verifyFormat("void f() { int (S::*func)(void *); }");
+  verifyFormat("typedef bool *(Class::*Member)() const;");
+  verifyFormat("void f() {\n"
+               "  (a->*f)();\n"
+               "  a->*x;\n"
+               "  (a.*f)();\n"
+               "  ((*a).*f)();\n"
+               "  a.*x;\n"
+               "}");
+  verifyFormat("void f() {\n"
+               "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
+               "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
+               "}");
+  verifyFormat(
+      "(aaaaaaaaaa->*bbbbbbb)(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
+  FormatStyle Style = getLLVMStyle();
+  Style.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("typedef bool* (Class::*Member)() const;", Style);
+}
+
+TEST_F(FormatTest, UnderstandsUnaryOperators) {
+  verifyFormat("int a = -2;");
+  verifyFormat("f(-1, -2, -3);");
+  verifyFormat("a[-1] = 5;");
+  verifyFormat("int a = 5 + -2;");
+  verifyFormat("if (i == -1) {\n}");
+  verifyFormat("if (i != -1) {\n}");
+  verifyFormat("if (i > -1) {\n}");
+  verifyFormat("if (i < -1) {\n}");
+  verifyFormat("++(a->f());");
+  verifyFormat("--(a->f());");
+  verifyFormat("(a->f())++;");
+  verifyFormat("a[42]++;");
+  verifyFormat("if (!(a->f())) {\n}");
+
+  verifyFormat("a-- > b;");
+  verifyFormat("b ? -a : c;");
+  verifyFormat("n * sizeof char16;");
+  verifyFormat("n * alignof char16;", getGoogleStyle());
+  verifyFormat("sizeof(char);");
+  verifyFormat("alignof(char);", getGoogleStyle());
+
+  verifyFormat("return -1;");
+  verifyFormat("switch (a) {\n"
+               "case -1:\n"
+               "  break;\n"
+               "}");
+  verifyFormat("#define X -1");
+  verifyFormat("#define X -kConstant");
+
+  verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
+  verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
+
+  verifyFormat("int a = /* confusing comment */ -1;");
+  // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
+  verifyFormat("int a = i /* confusing comment */++;");
+}
+
+TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
+  verifyFormat("if (!aaaaaaaaaa( // break\n"
+               "        aaaaa)) {\n"
+               "}");
+  verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
+               "    aaaaa));");
+  verifyFormat("*aaa = aaaaaaa( // break\n"
+               "    bbbbbb);");
+}
+
+TEST_F(FormatTest, UnderstandsOverloadedOperators) {
+  verifyFormat("bool operator<();");
+  verifyFormat("bool operator>();");
+  verifyFormat("bool operator=();");
+  verifyFormat("bool operator==();");
+  verifyFormat("bool operator!=();");
+  verifyFormat("int operator+();");
+  verifyFormat("int operator++();");
+  verifyFormat("bool operator,();");
+  verifyFormat("bool operator();");
+  verifyFormat("bool operator()();");
+  verifyFormat("bool operator[]();");
+  verifyFormat("operator bool();");
+  verifyFormat("operator int();");
+  verifyFormat("operator void *();");
+  verifyFormat("operator SomeType<int>();");
+  verifyFormat("operator SomeType<int, int>();");
+  verifyFormat("operator SomeType<SomeType<int>>();");
+  verifyFormat("void *operator new(std::size_t size);");
+  verifyFormat("void *operator new[](std::size_t size);");
+  verifyFormat("void operator delete(void *ptr);");
+  verifyFormat("void operator delete[](void *ptr);");
+  verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
+               "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
+               "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
+
+  verifyFormat(
+      "ostream &operator<<(ostream &OutputStream,\n"
+      "                    SomeReallyLongType WithSomeReallyLongValue);");
+  verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
+               "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
+               "  return left.group < right.group;\n"
+               "}");
+  verifyFormat("SomeType &operator=(const SomeType &S);");
+  verifyFormat("f.template operator()<int>();");
+
+  verifyGoogleFormat("operator void*();");
+  verifyGoogleFormat("operator SomeType<SomeType<int>>();");
+  verifyGoogleFormat("operator ::A();");
+
+  verifyFormat("using A::operator+;");
+  verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
+               "int i;");
+}
+
+TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
+  verifyFormat("Deleted &operator=(const Deleted &) & = default;");
+  verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
+  verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
+  verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
+  verifyFormat("Deleted &operator=(const Deleted &) &;");
+  verifyFormat("Deleted &operator=(const Deleted &) &&;");
+  verifyFormat("SomeType MemberFunction(const Deleted &) &;");
+  verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
+  verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
+  verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
+  verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
+  verifyFormat("SomeType MemberFunction(const Deleted &) const &;");
+  verifyFormat("template <typename T>\n"
+               "void F(T) && = delete;",
+               getGoogleStyle());
+
+  FormatStyle AlignLeft = getLLVMStyle();
+  AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("void A::b() && {}", AlignLeft);
+  verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
+  verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
+               AlignLeft);
+  verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
+  verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
+  verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
+  verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
+  verifyFormat("auto Function(T) & -> void {}", AlignLeft);
+  verifyFormat("auto Function(T) & -> void;", AlignLeft);
+  verifyFormat("SomeType MemberFunction(const Deleted&) const &;", AlignLeft);
+
+  FormatStyle Spaces = getLLVMStyle();
+  Spaces.SpacesInCStyleCastParentheses = true;
+  verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
+  verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
+  verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
+  verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
+
+  Spaces.SpacesInCStyleCastParentheses = false;
+  Spaces.SpacesInParentheses = true;
+  verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
+  verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
+  verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
+  verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
+}
+
+TEST_F(FormatTest, UnderstandsNewAndDelete) {
+  verifyFormat("void f() {\n"
+               "  A *a = new A;\n"
+               "  A *a = new (placement) A;\n"
+               "  delete a;\n"
+               "  delete (A *)a;\n"
+               "}");
+  verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
+               "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+               "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
+               "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat("delete[] h->p;");
+}
+
+TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
+  verifyFormat("int *f(int *a) {}");
+  verifyFormat("int main(int argc, char **argv) {}");
+  verifyFormat("Test::Test(int b) : a(b * b) {}");
+  verifyIndependentOfContext("f(a, *a);");
+  verifyFormat("void g() { f(*a); }");
+  verifyIndependentOfContext("int a = b * 10;");
+  verifyIndependentOfContext("int a = 10 * b;");
+  verifyIndependentOfContext("int a = b * c;");
+  verifyIndependentOfContext("int a += b * c;");
+  verifyIndependentOfContext("int a -= b * c;");
+  verifyIndependentOfContext("int a *= b * c;");
+  verifyIndependentOfContext("int a /= b * c;");
+  verifyIndependentOfContext("int a = *b;");
+  verifyIndependentOfContext("int a = *b * c;");
+  verifyIndependentOfContext("int a = b * *c;");
+  verifyIndependentOfContext("int a = b * (10);");
+  verifyIndependentOfContext("S << b * (10);");
+  verifyIndependentOfContext("return 10 * b;");
+  verifyIndependentOfContext("return *b * *c;");
+  verifyIndependentOfContext("return a & ~b;");
+  verifyIndependentOfContext("f(b ? *c : *d);");
+  verifyIndependentOfContext("int a = b ? *c : *d;");
+  verifyIndependentOfContext("*b = a;");
+  verifyIndependentOfContext("a * ~b;");
+  verifyIndependentOfContext("a * !b;");
+  verifyIndependentOfContext("a * +b;");
+  verifyIndependentOfContext("a * -b;");
+  verifyIndependentOfContext("a * ++b;");
+  verifyIndependentOfContext("a * --b;");
+  verifyIndependentOfContext("a[4] * b;");
+  verifyIndependentOfContext("a[a * a] = 1;");
+  verifyIndependentOfContext("f() * b;");
+  verifyIndependentOfContext("a * [self dostuff];");
+  verifyIndependentOfContext("int x = a * (a + b);");
+  verifyIndependentOfContext("(a *)(a + b);");
+  verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
+  verifyIndependentOfContext("int *pa = (int *)&a;");
+  verifyIndependentOfContext("return sizeof(int **);");
+  verifyIndependentOfContext("return sizeof(int ******);");
+  verifyIndependentOfContext("return (int **&)a;");
+  verifyIndependentOfContext("f((*PointerToArray)[10]);");
+  verifyFormat("void f(Type (*parameter)[10]) {}");
+  verifyFormat("void f(Type (&parameter)[10]) {}");
+  verifyGoogleFormat("return sizeof(int**);");
+  verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
+  verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
+  verifyFormat("auto a = [](int **&, int ***) {};");
+  verifyFormat("auto PointerBinding = [](const char *S) {};");
+  verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
+  verifyFormat("[](const decltype(*a) &value) {}");
+  verifyFormat("decltype(a * b) F();");
+  verifyFormat("#define MACRO() [](A *a) { return 1; }");
+  verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
+  verifyIndependentOfContext("typedef void (*f)(int *a);");
+  verifyIndependentOfContext("int i{a * b};");
+  verifyIndependentOfContext("aaa && aaa->f();");
+  verifyIndependentOfContext("int x = ~*p;");
+  verifyFormat("Constructor() : a(a), area(width * height) {}");
+  verifyFormat("Constructor() : a(a), area(a, width * height) {}");
+  verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
+  verifyFormat("void f() { f(a, c * d); }");
+  verifyFormat("void f() { f(new a(), c * d); }");
+  verifyFormat("void f(const MyOverride &override);");
+  verifyFormat("void f(const MyFinal &final);");
+  verifyIndependentOfContext("bool a = f() && override.f();");
+  verifyIndependentOfContext("bool a = f() && final.f();");
+
+  verifyIndependentOfContext("InvalidRegions[*R] = 0;");
+
+  verifyIndependentOfContext("A<int *> a;");
+  verifyIndependentOfContext("A<int **> a;");
+  verifyIndependentOfContext("A<int *, int *> a;");
+  verifyIndependentOfContext("A<int *[]> a;");
+  verifyIndependentOfContext(
+      "const char *const p = reinterpret_cast<const char *const>(q);");
+  verifyIndependentOfContext("A<int **, int **> a;");
+  verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
+  verifyFormat("for (char **a = b; *a; ++a) {\n}");
+  verifyFormat("for (; a && b;) {\n}");
+  verifyFormat("bool foo = true && [] { return false; }();");
+
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyGoogleFormat("int const* a = &b;");
+  verifyGoogleFormat("**outparam = 1;");
+  verifyGoogleFormat("*outparam = a * b;");
+  verifyGoogleFormat("int main(int argc, char** argv) {}");
+  verifyGoogleFormat("A<int*> a;");
+  verifyGoogleFormat("A<int**> a;");
+  verifyGoogleFormat("A<int*, int*> a;");
+  verifyGoogleFormat("A<int**, int**> a;");
+  verifyGoogleFormat("f(b ? *c : *d);");
+  verifyGoogleFormat("int a = b ? *c : *d;");
+  verifyGoogleFormat("Type* t = **x;");
+  verifyGoogleFormat("Type* t = *++*x;");
+  verifyGoogleFormat("*++*x;");
+  verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
+  verifyGoogleFormat("Type* t = x++ * y;");
+  verifyGoogleFormat(
+      "const char* const p = reinterpret_cast<const char* const>(q);");
+  verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
+  verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
+  verifyGoogleFormat("template <typename T>\n"
+                     "void f(int i = 0, SomeType** temps = NULL);");
+
+  FormatStyle Left = getLLVMStyle();
+  Left.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("x = *a(x) = *a(y);", Left);
+  verifyFormat("for (;; *a = b) {\n}", Left);
+  verifyFormat("return *this += 1;", Left);
+
+  verifyIndependentOfContext("a = *(x + y);");
+  verifyIndependentOfContext("a = &(x + y);");
+  verifyIndependentOfContext("*(x + y).call();");
+  verifyIndependentOfContext("&(x + y)->call();");
+  verifyFormat("void f() { &(*I).first; }");
+
+  verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
+  verifyFormat(
+      "int *MyValues = {\n"
+      "    *A, // Operator detection might be confused by the '{'\n"
+      "    *BB // Operator detection might be confused by previous comment\n"
+      "};");
+
+  verifyIndependentOfContext("if (int *a = &b)");
+  verifyIndependentOfContext("if (int &a = *b)");
+  verifyIndependentOfContext("if (a & b[i])");
+  verifyIndependentOfContext("if (a::b::c::d & b[i])");
+  verifyIndependentOfContext("if (*b[i])");
+  verifyIndependentOfContext("if (int *a = (&b))");
+  verifyIndependentOfContext("while (int *a = &b)");
+  verifyIndependentOfContext("size = sizeof *a;");
+  verifyIndependentOfContext("if (a && (b = c))");
+  verifyFormat("void f() {\n"
+               "  for (const int &v : Values) {\n"
+               "  }\n"
+               "}");
+  verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
+  verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
+  verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
+
+  verifyFormat("#define A (!a * b)");
+  verifyFormat("#define MACRO     \\\n"
+               "  int *i = a * b; \\\n"
+               "  void f(a *b);",
+               getLLVMStyleWithColumns(19));
+
+  verifyIndependentOfContext("A = new SomeType *[Length];");
+  verifyIndependentOfContext("A = new SomeType *[Length]();");
+  verifyIndependentOfContext("T **t = new T *;");
+  verifyIndependentOfContext("T **t = new T *();");
+  verifyGoogleFormat("A = new SomeType*[Length]();");
+  verifyGoogleFormat("A = new SomeType*[Length];");
+  verifyGoogleFormat("T** t = new T*;");
+  verifyGoogleFormat("T** t = new T*();");
+
+  FormatStyle PointerLeft = getLLVMStyle();
+  PointerLeft.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("delete *x;", PointerLeft);
+  verifyFormat("STATIC_ASSERT((a & b) == 0);");
+  verifyFormat("STATIC_ASSERT(0 == (a & b));");
+  verifyFormat("template <bool a, bool b> "
+               "typename t::if<x && y>::type f() {}");
+  verifyFormat("template <int *y> f() {}");
+  verifyFormat("vector<int *> v;");
+  verifyFormat("vector<int *const> v;");
+  verifyFormat("vector<int *const **const *> v;");
+  verifyFormat("vector<int *volatile> v;");
+  verifyFormat("vector<a * b> v;");
+  verifyFormat("foo<b && false>();");
+  verifyFormat("foo<b & 1>();");
+  verifyFormat("decltype(*::std::declval<const T &>()) void F();");
+  verifyFormat(
+      "template <class T, class = typename std::enable_if<\n"
+      "                       std::is_integral<T>::value &&\n"
+      "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
+      "void F();",
+      getLLVMStyleWithColumns(70));
+  verifyFormat(
+      "template <class T,\n"
+      "          class = typename std::enable_if<\n"
+      "              std::is_integral<T>::value &&\n"
+      "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
+      "          class U>\n"
+      "void F();",
+      getLLVMStyleWithColumns(70));
+  verifyFormat(
+      "template <class T,\n"
+      "          class = typename ::std::enable_if<\n"
+      "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
+      "void F();",
+      getGoogleStyleWithColumns(68));
+
+  verifyIndependentOfContext("MACRO(int *i);");
+  verifyIndependentOfContext("MACRO(auto *a);");
+  verifyIndependentOfContext("MACRO(const A *a);");
+  verifyIndependentOfContext("MACRO(A *const a);");
+  verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
+  verifyFormat("void f() { f(float{1}, a * a); }");
+  // FIXME: Is there a way to make this work?
+  // verifyIndependentOfContext("MACRO(A *a);");
+
+  verifyFormat("DatumHandle const *operator->() const { return input_; }");
+  verifyFormat("return options != nullptr && operator==(*options);");
+
+  EXPECT_EQ("#define OP(x)                                    \\\n"
+            "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
+            "    return s << a.DebugString();                 \\\n"
+            "  }",
+            format("#define OP(x) \\\n"
+                   "  ostream &operator<<(ostream &s, const A &a) { \\\n"
+                   "    return s << a.DebugString(); \\\n"
+                   "  }",
+                   getLLVMStyleWithColumns(50)));
+
+  // FIXME: We cannot handle this case yet; we might be able to figure out that
+  // foo<x> d > v; doesn't make sense.
+  verifyFormat("foo<a<b && c> d> v;");
+
+  FormatStyle PointerMiddle = getLLVMStyle();
+  PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
+  verifyFormat("delete *x;", PointerMiddle);
+  verifyFormat("int * x;", PointerMiddle);
+  verifyFormat("template <int * y> f() {}", PointerMiddle);
+  verifyFormat("int * f(int * a) {}", PointerMiddle);
+  verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
+  verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
+  verifyFormat("A<int *> a;", PointerMiddle);
+  verifyFormat("A<int **> a;", PointerMiddle);
+  verifyFormat("A<int *, int *> a;", PointerMiddle);
+  verifyFormat("A<int * []> a;", PointerMiddle);
+  verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
+  verifyFormat("A = new SomeType *[Length];", PointerMiddle);
+  verifyFormat("T ** t = new T *;", PointerMiddle);
+
+  // Member function reference qualifiers aren't binary operators.
+  verifyFormat("string // break\n"
+               "operator()() & {}");
+  verifyFormat("string // break\n"
+               "operator()() && {}");
+  verifyGoogleFormat("template <typename T>\n"
+                     "auto x() & -> int {}");
+}
+
+TEST_F(FormatTest, UnderstandsAttributes) {
+  verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
+               "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
+  FormatStyle AfterType = getLLVMStyle();
+  AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
+  verifyFormat("__attribute__((nodebug)) void\n"
+               "foo() {}\n",
+               AfterType);
+}
+
+TEST_F(FormatTest, UnderstandsEllipsis) {
+  verifyFormat("int printf(const char *fmt, ...);");
+  verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
+  verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
+
+  FormatStyle PointersLeft = getLLVMStyle();
+  PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
+}
+
+TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
+  EXPECT_EQ("int *a;\n"
+            "int *a;\n"
+            "int *a;",
+            format("int *a;\n"
+                   "int* a;\n"
+                   "int *a;",
+                   getGoogleStyle()));
+  EXPECT_EQ("int* a;\n"
+            "int* a;\n"
+            "int* a;",
+            format("int* a;\n"
+                   "int* a;\n"
+                   "int *a;",
+                   getGoogleStyle()));
+  EXPECT_EQ("int *a;\n"
+            "int *a;\n"
+            "int *a;",
+            format("int *a;\n"
+                   "int * a;\n"
+                   "int *  a;",
+                   getGoogleStyle()));
+  EXPECT_EQ("auto x = [] {\n"
+            "  int *a;\n"
+            "  int *a;\n"
+            "  int *a;\n"
+            "};",
+            format("auto x=[]{int *a;\n"
+                   "int * a;\n"
+                   "int *  a;};",
+                   getGoogleStyle()));
+}
+
+TEST_F(FormatTest, UnderstandsRvalueReferences) {
+  verifyFormat("int f(int &&a) {}");
+  verifyFormat("int f(int a, char &&b) {}");
+  verifyFormat("void f() { int &&a = b; }");
+  verifyGoogleFormat("int f(int a, char&& b) {}");
+  verifyGoogleFormat("void f() { int&& a = b; }");
+
+  verifyIndependentOfContext("A<int &&> a;");
+  verifyIndependentOfContext("A<int &&, int &&> a;");
+  verifyGoogleFormat("A<int&&> a;");
+  verifyGoogleFormat("A<int&&, int&&> a;");
+
+  // Not rvalue references:
+  verifyFormat("template <bool B, bool C> class A {\n"
+               "  static_assert(B && C, \"Something is wrong\");\n"
+               "};");
+  verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
+  verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
+  verifyFormat("#define A(a, b) (a && b)");
+}
+
+TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
+  verifyFormat("void f() {\n"
+               "  x[aaaaaaaaa -\n"
+               "    b] = 23;\n"
+               "}",
+               getLLVMStyleWithColumns(15));
+}
+
+TEST_F(FormatTest, FormatsCasts) {
+  verifyFormat("Type *A = static_cast<Type *>(P);");
+  verifyFormat("Type *A = (Type *)P;");
+  verifyFormat("Type *A = (vector<Type *, int *>)P;");
+  verifyFormat("int a = (int)(2.0f);");
+  verifyFormat("int a = (int)2.0f;");
+  verifyFormat("x[(int32)y];");
+  verifyFormat("x = (int32)y;");
+  verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
+  verifyFormat("int a = (int)*b;");
+  verifyFormat("int a = (int)2.0f;");
+  verifyFormat("int a = (int)~0;");
+  verifyFormat("int a = (int)++a;");
+  verifyFormat("int a = (int)sizeof(int);");
+  verifyFormat("int a = (int)+2;");
+  verifyFormat("my_int a = (my_int)2.0f;");
+  verifyFormat("my_int a = (my_int)sizeof(int);");
+  verifyFormat("return (my_int)aaa;");
+  verifyFormat("#define x ((int)-1)");
+  verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
+  verifyFormat("#define p(q) ((int *)&q)");
+  verifyFormat("fn(a)(b) + 1;");
+
+  verifyFormat("void f() { my_int a = (my_int)*b; }");
+  verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
+  verifyFormat("my_int a = (my_int)~0;");
+  verifyFormat("my_int a = (my_int)++a;");
+  verifyFormat("my_int a = (my_int)-2;");
+  verifyFormat("my_int a = (my_int)1;");
+  verifyFormat("my_int a = (my_int *)1;");
+  verifyFormat("my_int a = (const my_int)-1;");
+  verifyFormat("my_int a = (const my_int *)-1;");
+  verifyFormat("my_int a = (my_int)(my_int)-1;");
+  verifyFormat("my_int a = (ns::my_int)-2;");
+  verifyFormat("case (my_int)ONE:");
+  verifyFormat("auto x = (X)this;");
+
+  // FIXME: single value wrapped with paren will be treated as cast.
+  verifyFormat("void f(int i = (kValue)*kMask) {}");
+
+  verifyFormat("{ (void)F; }");
+
+  // Don't break after a cast's
+  verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
+               "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
+               "                                   bbbbbbbbbbbbbbbbbbbbbb);");
+
+  // These are not casts.
+  verifyFormat("void f(int *) {}");
+  verifyFormat("f(foo)->b;");
+  verifyFormat("f(foo).b;");
+  verifyFormat("f(foo)(b);");
+  verifyFormat("f(foo)[b];");
+  verifyFormat("[](foo) { return 4; }(bar);");
+  verifyFormat("(*funptr)(foo)[4];");
+  verifyFormat("funptrs[4](foo)[4];");
+  verifyFormat("void f(int *);");
+  verifyFormat("void f(int *) = 0;");
+  verifyFormat("void f(SmallVector<int>) {}");
+  verifyFormat("void f(SmallVector<int>);");
+  verifyFormat("void f(SmallVector<int>) = 0;");
+  verifyFormat("void f(int i = (kA * kB) & kMask) {}");
+  verifyFormat("int a = sizeof(int) * b;");
+  verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
+  verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
+  verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
+  verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
+
+  // These are not casts, but at some point were confused with casts.
+  verifyFormat("virtual void foo(int *) override;");
+  verifyFormat("virtual void foo(char &) const;");
+  verifyFormat("virtual void foo(int *a, char *) const;");
+  verifyFormat("int a = sizeof(int *) + b;");
+  verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
+  verifyFormat("bool b = f(g<int>) && c;");
+  verifyFormat("typedef void (*f)(int i) func;");
+
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
+               "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
+  // FIXME: The indentation here is not ideal.
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+      "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
+      "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
+}
+
+TEST_F(FormatTest, FormatsFunctionTypes) {
+  verifyFormat("A<bool()> a;");
+  verifyFormat("A<SomeType()> a;");
+  verifyFormat("A<void (*)(int, std::string)> a;");
+  verifyFormat("A<void *(int)>;");
+  verifyFormat("void *(*a)(int *, SomeType *);");
+  verifyFormat("int (*func)(void *);");
+  verifyFormat("void f() { int (*func)(void *); }");
+  verifyFormat("template <class CallbackClass>\n"
+               "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
+
+  verifyGoogleFormat("A<void*(int*, SomeType*)>;");
+  verifyGoogleFormat("void* (*a)(int);");
+  verifyGoogleFormat(
+      "template <class CallbackClass>\n"
+      "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
+
+  // Other constructs can look somewhat like function types:
+  verifyFormat("A<sizeof(*x)> a;");
+  verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
+  verifyFormat("some_var = function(*some_pointer_var)[0];");
+  verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
+  verifyFormat("int x = f(&h)();");
+  verifyFormat("returnsFunction(&param1, &param2)(param);");
+}
+
+TEST_F(FormatTest, FormatsPointersToArrayTypes) {
+  verifyFormat("A (*foo_)[6];");
+  verifyFormat("vector<int> (*foo_)[6];");
+}
+
+TEST_F(FormatTest, BreaksLongVariableDeclarations) {
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
+               "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
+
+  // Different ways of ()-initializiation.
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
+
+  // Lambdas should not confuse the variable declaration heuristic.
+  verifyFormat("LooooooooooooooooongType\n"
+               "    variable(nullptr, [](A *a) {});",
+               getLLVMStyleWithColumns(40));
+}
+
+TEST_F(FormatTest, BreaksLongDeclarations) {
+  verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
+               "    AnotherNameForTheLongType;");
+  verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
+               "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
+               "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
+               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
+               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
+               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
+  verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
+               "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
+               "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
+               "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
+  FormatStyle Indented = getLLVMStyle();
+  Indented.IndentWrappedFunctionNames = true;
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
+               "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
+               Indented);
+  verifyFormat(
+      "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
+      "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
+      Indented);
+  verifyFormat(
+      "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
+      "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
+      Indented);
+  verifyFormat(
+      "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
+      "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
+      Indented);
+
+  // FIXME: Without the comment, this breaks after "(".
+  verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
+               "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
+               getGoogleStyle());
+
+  verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
+               "                  int LoooooooooooooooooooongParam2) {}");
+  verifyFormat(
+      "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
+      "                                   SourceLocation L, IdentifierIn *II,\n"
+      "                                   Type *T) {}");
+  verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
+               "ReallyReaaallyLongFunctionName(\n"
+               "    const std::string &SomeParameter,\n"
+               "    const SomeType<string, SomeOtherTemplateParameter>\n"
+               "        &ReallyReallyLongParameterName,\n"
+               "    const SomeType<string, SomeOtherTemplateParameter>\n"
+               "        &AnotherLongParameterName) {}");
+  verifyFormat("template <typename A>\n"
+               "SomeLoooooooooooooooooooooongType<\n"
+               "    typename some_namespace::SomeOtherType<A>::Type>\n"
+               "Function() {}");
+
+  verifyGoogleFormat(
+      "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaa;");
+  verifyGoogleFormat(
+      "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
+      "                                   SourceLocation L) {}");
+  verifyGoogleFormat(
+      "some_namespace::LongReturnType\n"
+      "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
+      "    int first_long_parameter, int second_parameter) {}");
+
+  verifyGoogleFormat("template <typename T>\n"
+                     "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
+                     "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
+  verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+                     "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
+               "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaa);");
+  verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
+               "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+
+  verifyFormat("template <typename T> // Templates on own line.\n"
+               "static int            // Some comment.\n"
+               "MyFunction(int a);",
+               getLLVMStyle());
+}
+
+TEST_F(FormatTest, FormatsArrays) {
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
+               "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
+               "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
+  verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
+               "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+               "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
+               "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
+  verifyFormat(
+      "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
+      "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
+      "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
+               "    .aaaaaaaaaaaaaaaaaaaaaa();");
+
+  verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
+                     "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
+  verifyFormat(
+      "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
+      "                                  .aaaaaaa[0]\n"
+      "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
+  verifyFormat("a[::b::c];");
+
+  verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
+
+  FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
+  verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
+}
+
+TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
+  verifyFormat("(a)->b();");
+  verifyFormat("--a;");
+}
+
+TEST_F(FormatTest, HandlesIncludeDirectives) {
+  verifyFormat("#include <string>\n"
+               "#include <a/b/c.h>\n"
+               "#include \"a/b/string\"\n"
+               "#include \"string.h\"\n"
+               "#include \"string.h\"\n"
+               "#include <a-a>\n"
+               "#include < path with space >\n"
+               "#include_next <test.h>"
+               "#include \"abc.h\" // this is included for ABC\n"
+               "#include \"some long include\" // with a comment\n"
+               "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"",
+               getLLVMStyleWithColumns(35));
+  EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
+  EXPECT_EQ("#include <a>", format("#include<a>"));
+
+  verifyFormat("#import <string>");
+  verifyFormat("#import <a/b/c.h>");
+  verifyFormat("#import \"a/b/string\"");
+  verifyFormat("#import \"string.h\"");
+  verifyFormat("#import \"string.h\"");
+  verifyFormat("#if __has_include(<strstream>)\n"
+               "#include <strstream>\n"
+               "#endif");
+
+  verifyFormat("#define MY_IMPORT <a/b>");
+
+  verifyFormat("#if __has_include(<a/b>)");
+  verifyFormat("#if __has_include_next(<a/b>)");
+  verifyFormat("#define F __has_include(<a/b>)");
+  verifyFormat("#define F __has_include_next(<a/b>)");
+
+  // Protocol buffer definition or missing "#".
+  verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
+               getLLVMStyleWithColumns(30));
+
+  FormatStyle Style = getLLVMStyle();
+  Style.AlwaysBreakBeforeMultilineStrings = true;
+  Style.ColumnLimit = 0;
+  verifyFormat("#import \"abc.h\"", Style);
+
+  // But 'import' might also be a regular C++ namespace.
+  verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+}
+
+//===----------------------------------------------------------------------===//
+// Error recovery tests.
+//===----------------------------------------------------------------------===//
+
+TEST_F(FormatTest, IncompleteParameterLists) {
+  FormatStyle NoBinPacking = getLLVMStyle();
+  NoBinPacking.BinPackParameters = false;
+  verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
+               "                        double *min_x,\n"
+               "                        double *max_x,\n"
+               "                        double *min_y,\n"
+               "                        double *max_y,\n"
+               "                        double *min_z,\n"
+               "                        double *max_z, ) {}",
+               NoBinPacking);
+}
+
+TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
+  verifyFormat("void f() { return; }\n42");
+  verifyFormat("void f() {\n"
+               "  if (0)\n"
+               "    return;\n"
+               "}\n"
+               "42");
+  verifyFormat("void f() { return }\n42");
+  verifyFormat("void f() {\n"
+               "  if (0)\n"
+               "    return\n"
+               "}\n"
+               "42");
+}
+
+TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
+  EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
+  EXPECT_EQ("void f() {\n"
+            "  if (a)\n"
+            "    return\n"
+            "}",
+            format("void  f  (  )  {  if  ( a )  return  }"));
+  EXPECT_EQ("namespace N {\n"
+            "void f()\n"
+            "}",
+            format("namespace  N  {  void f()  }"));
+  EXPECT_EQ("namespace N {\n"
+            "void f() {}\n"
+            "void g()\n"
+            "} // namespace N",
+            format("namespace N  { void f( ) { } void g( ) }"));
+}
+
+TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
+  verifyFormat("int aaaaaaaa =\n"
+               "    // Overlylongcomment\n"
+               "    b;",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("function(\n"
+               "    ShortArgument,\n"
+               "    LoooooooooooongArgument);\n",
+               getLLVMStyleWithColumns(20));
+}
+
+TEST_F(FormatTest, IncorrectAccessSpecifier) {
+  verifyFormat("public:");
+  verifyFormat("class A {\n"
+               "public\n"
+               "  void f() {}\n"
+               "};");
+  verifyFormat("public\n"
+               "int qwerty;");
+  verifyFormat("public\n"
+               "B {}");
+  verifyFormat("public\n"
+               "{}");
+  verifyFormat("public\n"
+               "B { int x; }");
+}
+
+TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
+  verifyFormat("{");
+  verifyFormat("#})");
+  verifyNoCrash("(/**/[:!] ?[).");
+}
+
+TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
+  verifyFormat("do {\n}");
+  verifyFormat("do {\n}\n"
+               "f();");
+  verifyFormat("do {\n}\n"
+               "wheeee(fun);");
+  verifyFormat("do {\n"
+               "  f();\n"
+               "}");
+}
+
+TEST_F(FormatTest, IncorrectCodeMissingParens) {
+  verifyFormat("if {\n  foo;\n  foo();\n}");
+  verifyFormat("switch {\n  foo;\n  foo();\n}");
+  verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
+  verifyFormat("while {\n  foo;\n  foo();\n}");
+  verifyFormat("do {\n  foo;\n  foo();\n} while;");
+}
+
+TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
+  verifyIncompleteFormat("namespace {\n"
+                         "class Foo { Foo (\n"
+                         "};\n"
+                         "} // namespace");
+}
+
+TEST_F(FormatTest, IncorrectCodeErrorDetection) {
+  EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
+  EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
+  EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
+  EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
+
+  EXPECT_EQ("{\n"
+            "  {\n"
+            "    breakme(\n"
+            "        qwe);\n"
+            "  }\n",
+            format("{\n"
+                   "    {\n"
+                   " breakme(qwe);\n"
+                   "}\n",
+                   getLLVMStyleWithColumns(10)));
+}
+
+TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
+  verifyFormat("int x = {\n"
+               "    avariable,\n"
+               "    b(alongervariable)};",
+               getLLVMStyleWithColumns(25));
+}
+
+TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
+  verifyFormat("return (a)(b){1, 2, 3};");
+}
+
+TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
+  verifyFormat("vector<int> x{1, 2, 3, 4};");
+  verifyFormat("vector<int> x{\n"
+               "    1, 2, 3, 4,\n"
+               "};");
+  verifyFormat("vector<T> x{{}, {}, {}, {}};");
+  verifyFormat("f({1, 2});");
+  verifyFormat("auto v = Foo{-1};");
+  verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
+  verifyFormat("Class::Class : member{1, 2, 3} {}");
+  verifyFormat("new vector<int>{1, 2, 3};");
+  verifyFormat("new int[3]{1, 2, 3};");
+  verifyFormat("new int{1};");
+  verifyFormat("return {arg1, arg2};");
+  verifyFormat("return {arg1, SomeType{parameter}};");
+  verifyFormat("int count = set<int>{f(), g(), h()}.size();");
+  verifyFormat("new T{arg1, arg2};");
+  verifyFormat("f(MyMap[{composite, key}]);");
+  verifyFormat("class Class {\n"
+               "  T member = {arg1, arg2};\n"
+               "};");
+  verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
+  verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
+  verifyFormat("int a = std::is_integral<int>{} + 0;");
+
+  verifyFormat("int foo(int i) { return fo1{}(i); }");
+  verifyFormat("int foo(int i) { return fo1{}(i); }");
+  verifyFormat("auto i = decltype(x){};");
+  verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
+  verifyFormat("Node n{1, Node{1000}, //\n"
+               "       2};");
+  verifyFormat("Aaaa aaaaaaa{\n"
+               "    {\n"
+               "        aaaa,\n"
+               "    },\n"
+               "};");
+  verifyFormat("class C : public D {\n"
+               "  SomeClass SC{2};\n"
+               "};");
+  verifyFormat("class C : public A {\n"
+               "  class D : public B {\n"
+               "    void f() { int i{2}; }\n"
+               "  };\n"
+               "};");
+  verifyFormat("#define A {a, a},");
+
+  // Cases where distinguising braced lists and blocks is hard.
+  verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
+  verifyFormat("void f() {\n"
+               "  return; // comment\n"
+               "}\n"
+               "SomeType t;");
+  verifyFormat("void f() {\n"
+               "  if (a) {\n"
+               "    f();\n"
+               "  }\n"
+               "}\n"
+               "SomeType t;");
+
+  // In combination with BinPackArguments = false.
+  FormatStyle NoBinPacking = getLLVMStyle();
+  NoBinPacking.BinPackArguments = false;
+  verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
+               "                      bbbbb,\n"
+               "                      ccccc,\n"
+               "                      ddddd,\n"
+               "                      eeeee,\n"
+               "                      ffffff,\n"
+               "                      ggggg,\n"
+               "                      hhhhhh,\n"
+               "                      iiiiii,\n"
+               "                      jjjjjj,\n"
+               "                      kkkkkk};",
+               NoBinPacking);
+  verifyFormat("const Aaaaaa aaaaa = {\n"
+               "    aaaaa,\n"
+               "    bbbbb,\n"
+               "    ccccc,\n"
+               "    ddddd,\n"
+               "    eeeee,\n"
+               "    ffffff,\n"
+               "    ggggg,\n"
+               "    hhhhhh,\n"
+               "    iiiiii,\n"
+               "    jjjjjj,\n"
+               "    kkkkkk,\n"
+               "};",
+               NoBinPacking);
+  verifyFormat(
+      "const Aaaaaa aaaaa = {\n"
+      "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
+      "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
+      "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
+      "};",
+      NoBinPacking);
+
+  // FIXME: The alignment of these trailing comments might be bad. Then again,
+  // this might be utterly useless in real code.
+  verifyFormat("Constructor::Constructor()\n"
+               "    : some_value{         //\n"
+               "                 aaaaaaa, //\n"
+               "                 bbbbbbb} {}");
+
+  // In braced lists, the first comment is always assumed to belong to the
+  // first element. Thus, it can be moved to the next or previous line as
+  // appropriate.
+  EXPECT_EQ("function({// First element:\n"
+            "          1,\n"
+            "          // Second element:\n"
+            "          2});",
+            format("function({\n"
+                   "    // First element:\n"
+                   "    1,\n"
+                   "    // Second element:\n"
+                   "    2});"));
+  EXPECT_EQ("std::vector<int> MyNumbers{\n"
+            "    // First element:\n"
+            "    1,\n"
+            "    // Second element:\n"
+            "    2};",
+            format("std::vector<int> MyNumbers{// First element:\n"
+                   "                           1,\n"
+                   "                           // Second element:\n"
+                   "                           2};",
+                   getLLVMStyleWithColumns(30)));
+  // A trailing comma should still lead to an enforced line break.
+  EXPECT_EQ("vector<int> SomeVector = {\n"
+            "    // aaa\n"
+            "    1, 2,\n"
+            "};",
+            format("vector<int> SomeVector = { // aaa\n"
+                   "    1, 2, };"));
+
+  FormatStyle ExtraSpaces = getLLVMStyle();
+  ExtraSpaces.Cpp11BracedListStyle = false;
+  ExtraSpaces.ColumnLimit = 75;
+  verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
+  verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
+  verifyFormat("f({ 1, 2 });", ExtraSpaces);
+  verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
+  verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
+  verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
+  verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
+  verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
+  verifyFormat("return { arg1, arg2 };", ExtraSpaces);
+  verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
+  verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
+  verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
+  verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
+  verifyFormat("class Class {\n"
+               "  T member = { arg1, arg2 };\n"
+               "};",
+               ExtraSpaces);
+  verifyFormat(
+      "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
+      "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
+      "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
+      ExtraSpaces);
+  verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
+  verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
+               ExtraSpaces);
+  verifyFormat(
+      "someFunction(OtherParam,\n"
+      "             BracedList{ // comment 1 (Forcing interesting break)\n"
+      "                         param1, param2,\n"
+      "                         // comment 2\n"
+      "                         param3, param4 });",
+      ExtraSpaces);
+  verifyFormat(
+      "std::this_thread::sleep_for(\n"
+      "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
+      ExtraSpaces);
+  verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
+               "    aaaaaaa,\n"
+               "    aaaaaaaaaa,\n"
+               "    aaaaa,\n"
+               "    aaaaaaaaaaaaaaa,\n"
+               "    aaa,\n"
+               "    aaaaaaaaaa,\n"
+               "    a,\n"
+               "    aaaaaaaaaaaaaaaaaaaaa,\n"
+               "    aaaaaaaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
+               "    aaaaaaa,\n"
+               "    a};");
+  verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
+}
+
+TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
+  verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
+  verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, //\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+               "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
+  verifyFormat(
+      "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
+      "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
+      "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
+      "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
+      "                 7777777};");
+  verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
+               "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
+               "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
+  verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
+               "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
+               "    // Separating comment.\n"
+               "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
+  verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
+               "    // Leading comment\n"
+               "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
+               "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
+  verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
+               "                 1, 1, 1, 1};",
+               getLLVMStyleWithColumns(39));
+  verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
+               "                 1, 1, 1, 1};",
+               getLLVMStyleWithColumns(38));
+  verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
+               "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
+               getLLVMStyleWithColumns(43));
+  verifyFormat(
+      "static unsigned SomeValues[10][3] = {\n"
+      "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
+      "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
+  verifyFormat("static auto fields = new vector<string>{\n"
+               "    \"aaaaaaaaaaaaa\",\n"
+               "    \"aaaaaaaaaaaaa\",\n"
+               "    \"aaaaaaaaaaaa\",\n"
+               "    \"aaaaaaaaaaaaaa\",\n"
+               "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
+               "    \"aaaaaaaaaaaa\",\n"
+               "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
+               "};");
+  verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
+  verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
+               "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
+               "                 3, cccccccccccccccccccccc};",
+               getLLVMStyleWithColumns(60));
+
+  // Trailing commas.
+  verifyFormat("vector<int> x = {\n"
+               "    1, 1, 1, 1, 1, 1, 1, 1,\n"
+               "};",
+               getLLVMStyleWithColumns(39));
+  verifyFormat("vector<int> x = {\n"
+               "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
+               "};",
+               getLLVMStyleWithColumns(39));
+  verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
+               "                 1, 1, 1, 1,\n"
+               "                 /**/ /**/};",
+               getLLVMStyleWithColumns(39));
+
+  // Trailing comment in the first line.
+  verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
+               "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
+               "    111111111,  222222222,  3333333333,  444444444,  //\n"
+               "    11111111,   22222222,   333333333,   44444444};");
+  // Trailing comment in the last line.
+  verifyFormat("int aaaaa[] = {\n"
+               "    1, 2, 3, // comment\n"
+               "    4, 5, 6  // comment\n"
+               "};");
+
+  // With nested lists, we should either format one item per line or all nested
+  // lists one on line.
+  // FIXME: For some nested lists, we can do better.
+  verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
+               "        {aaaaaaaaaaaaaaaaaaa},\n"
+               "        {aaaaaaaaaaaaaaaaaaaaa},\n"
+               "        {aaaaaaaaaaaaaaaaa}};",
+               getLLVMStyleWithColumns(60));
+  verifyFormat(
+      "SomeStruct my_struct_array = {\n"
+      "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
+      "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
+      "    {aaa, aaa},\n"
+      "    {aaa, aaa},\n"
+      "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
+      "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
+      "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
+
+  // No column layout should be used here.
+  verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
+               "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
+
+  verifyNoCrash("a<,");
+
+  // No braced initializer here.
+  verifyFormat("void f() {\n"
+               "  struct Dummy {};\n"
+               "  f(v);\n"
+               "}");
+
+  // Long lists should be formatted in columns even if they are nested.
+  verifyFormat(
+      "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
+      "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
+
+  // Allow "single-column" layout even if that violates the column limit. There
+  // isn't going to be a better way.
+  verifyFormat("std::vector<int> a = {\n"
+               "    aaaaaaaa,\n"
+               "    aaaaaaaa,\n"
+               "    aaaaaaaa,\n"
+               "    aaaaaaaa,\n"
+               "    aaaaaaaaaa,\n"
+               "    aaaaaaaa,\n"
+               "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
+               getLLVMStyleWithColumns(30));
+  verifyFormat("vector<int> aaaa = {\n"
+               "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+               "    aaaaaa.aaaaaaa,\n"
+               "    aaaaaa.aaaaaaa,\n"
+               "    aaaaaa.aaaaaaa,\n"
+               "    aaaaaa.aaaaaaa,\n"
+               "};");
+
+  // Don't create hanging lists.
+  verifyFormat("someFunction(Param, {List1, List2,\n"
+               "                     List3});",
+               getLLVMStyleWithColumns(35));
+  verifyFormat("someFunction(Param, Param,\n"
+               "             {List1, List2,\n"
+               "              List3});",
+               getLLVMStyleWithColumns(35));
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
+               "                               aaaaaaaaaaaaaaaaaaaaaaa);");
+}
+
+TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
+  FormatStyle DoNotMerge = getLLVMStyle();
+  DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
+
+  verifyFormat("void f() { return 42; }");
+  verifyFormat("void f() {\n"
+               "  return 42;\n"
+               "}",
+               DoNotMerge);
+  verifyFormat("void f() {\n"
+               "  // Comment\n"
+               "}");
+  verifyFormat("{\n"
+               "#error {\n"
+               "  int a;\n"
+               "}");
+  verifyFormat("{\n"
+               "  int a;\n"
+               "#error {\n"
+               "}");
+  verifyFormat("void f() {} // comment");
+  verifyFormat("void f() { int a; } // comment");
+  verifyFormat("void f() {\n"
+               "} // comment",
+               DoNotMerge);
+  verifyFormat("void f() {\n"
+               "  int a;\n"
+               "} // comment",
+               DoNotMerge);
+  verifyFormat("void f() {\n"
+               "} // comment",
+               getLLVMStyleWithColumns(15));
+
+  verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
+  verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
+
+  verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
+  verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
+  verifyFormat("class C {\n"
+               "  C()\n"
+               "      : iiiiiiii(nullptr),\n"
+               "        kkkkkkk(nullptr),\n"
+               "        mmmmmmm(nullptr),\n"
+               "        nnnnnnn(nullptr) {}\n"
+               "};",
+               getGoogleStyle());
+
+  FormatStyle NoColumnLimit = getLLVMStyle();
+  NoColumnLimit.ColumnLimit = 0;
+  EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
+  EXPECT_EQ("class C {\n"
+            "  A() : b(0) {}\n"
+            "};",
+            format("class C{A():b(0){}};", NoColumnLimit));
+  EXPECT_EQ("A()\n"
+            "    : b(0) {\n"
+            "}",
+            format("A()\n:b(0)\n{\n}", NoColumnLimit));
+
+  FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
+  DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
+      FormatStyle::SFS_None;
+  EXPECT_EQ("A()\n"
+            "    : b(0) {\n"
+            "}",
+            format("A():b(0){}", DoNotMergeNoColumnLimit));
+  EXPECT_EQ("A()\n"
+            "    : b(0) {\n"
+            "}",
+            format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
+
+  verifyFormat("#define A          \\\n"
+               "  void f() {       \\\n"
+               "    int i;         \\\n"
+               "  }",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("#define A           \\\n"
+               "  void f() { int i; }",
+               getLLVMStyleWithColumns(21));
+  verifyFormat("#define A            \\\n"
+               "  void f() {         \\\n"
+               "    int i;           \\\n"
+               "  }                  \\\n"
+               "  int j;",
+               getLLVMStyleWithColumns(22));
+  verifyFormat("#define A             \\\n"
+               "  void f() { int i; } \\\n"
+               "  int j;",
+               getLLVMStyleWithColumns(23));
+}
+
+TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
+  FormatStyle MergeInlineOnly = getLLVMStyle();
+  MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
+  verifyFormat("class C {\n"
+               "  int f() { return 42; }\n"
+               "};",
+               MergeInlineOnly);
+  verifyFormat("int f() {\n"
+               "  return 42;\n"
+               "}",
+               MergeInlineOnly);
+}
+
+TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
+  // Elaborate type variable declarations.
+  verifyFormat("struct foo a = {bar};\nint n;");
+  verifyFormat("class foo a = {bar};\nint n;");
+  verifyFormat("union foo a = {bar};\nint n;");
+
+  // Elaborate types inside function definitions.
+  verifyFormat("struct foo f() {}\nint n;");
+  verifyFormat("class foo f() {}\nint n;");
+  verifyFormat("union foo f() {}\nint n;");
+
+  // Templates.
+  verifyFormat("template <class X> void f() {}\nint n;");
+  verifyFormat("template <struct X> void f() {}\nint n;");
+  verifyFormat("template <union X> void f() {}\nint n;");
+
+  // Actual definitions...
+  verifyFormat("struct {\n} n;");
+  verifyFormat(
+      "template <template <class T, class Y>, class Z> class X {\n} n;");
+  verifyFormat("union Z {\n  int n;\n} x;");
+  verifyFormat("class MACRO Z {\n} n;");
+  verifyFormat("class MACRO(X) Z {\n} n;");
+  verifyFormat("class __attribute__(X) Z {\n} n;");
+  verifyFormat("class __declspec(X) Z {\n} n;");
+  verifyFormat("class A##B##C {\n} n;");
+  verifyFormat("class alignas(16) Z {\n} n;");
+  verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
+  verifyFormat("class MACROA MACRO(X) Z {\n} n;");
+
+  // Redefinition from nested context:
+  verifyFormat("class A::B::C {\n} n;");
+
+  // Template definitions.
+  verifyFormat(
+      "template <typename F>\n"
+      "Matcher(const Matcher<F> &Other,\n"
+      "        typename enable_if_c<is_base_of<F, T>::value &&\n"
+      "                             !is_same<F, T>::value>::type * = 0)\n"
+      "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
+
+  // FIXME: This is still incorrectly handled at the formatter side.
+  verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
+  verifyFormat("int i = SomeFunction(a<b, a> b);");
+
+  // FIXME:
+  // This now gets parsed incorrectly as class definition.
+  // verifyFormat("class A<int> f() {\n}\nint n;");
+
+  // Elaborate types where incorrectly parsing the structural element would
+  // break the indent.
+  verifyFormat("if (true)\n"
+               "  class X x;\n"
+               "else\n"
+               "  f();\n");
+
+  // This is simply incomplete. Formatting is not important, but must not crash.
+  verifyFormat("class A:");
+}
+
+TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
+  EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
+            format("#error Leave     all         white!!!!! space* alone!\n"));
+  EXPECT_EQ(
+      "#warning Leave     all         white!!!!! space* alone!\n",
+      format("#warning Leave     all         white!!!!! space* alone!\n"));
+  EXPECT_EQ("#error 1", format("  #  error   1"));
+  EXPECT_EQ("#warning 1", format("  #  warning 1"));
+}
+
+TEST_F(FormatTest, FormatHashIfExpressions) {
+  verifyFormat("#if AAAA && BBBB");
+  verifyFormat("#if (AAAA && BBBB)");
+  verifyFormat("#elif (AAAA && BBBB)");
+  // FIXME: Come up with a better indentation for #elif.
+  verifyFormat(
+      "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
+      "    defined(BBBBBBBB)\n"
+      "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
+      "    defined(BBBBBBBB)\n"
+      "#endif",
+      getLLVMStyleWithColumns(65));
+}
+
+TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
+  FormatStyle AllowsMergedIf = getGoogleStyle();
+  AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true;
+  verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
+  verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
+  verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
+  EXPECT_EQ("if (true) return 42;",
+            format("if (true)\nreturn 42;", AllowsMergedIf));
+  FormatStyle ShortMergedIf = AllowsMergedIf;
+  ShortMergedIf.ColumnLimit = 25;
+  verifyFormat("#define A \\\n"
+               "  if (true) return 42;",
+               ShortMergedIf);
+  verifyFormat("#define A \\\n"
+               "  f();    \\\n"
+               "  if (true)\n"
+               "#define B",
+               ShortMergedIf);
+  verifyFormat("#define A \\\n"
+               "  f();    \\\n"
+               "  if (true)\n"
+               "g();",
+               ShortMergedIf);
+  verifyFormat("{\n"
+               "#ifdef A\n"
+               "  // Comment\n"
+               "  if (true) continue;\n"
+               "#endif\n"
+               "  // Comment\n"
+               "  if (true) continue;\n"
+               "}",
+               ShortMergedIf);
+  ShortMergedIf.ColumnLimit = 29;
+  verifyFormat("#define A                   \\\n"
+               "  if (aaaaaaaaaa) return 1; \\\n"
+               "  return 2;",
+               ShortMergedIf);
+  ShortMergedIf.ColumnLimit = 28;
+  verifyFormat("#define A         \\\n"
+               "  if (aaaaaaaaaa) \\\n"
+               "    return 1;     \\\n"
+               "  return 2;",
+               ShortMergedIf);
+}
+
+TEST_F(FormatTest, FormatStarDependingOnContext) {
+  verifyFormat("void f(int *a);");
+  verifyFormat("void f() { f(fint * b); }");
+  verifyFormat("class A {\n  void f(int *a);\n};");
+  verifyFormat("class A {\n  int *a;\n};");
+  verifyFormat("namespace a {\n"
+               "namespace b {\n"
+               "class A {\n"
+               "  void f() {}\n"
+               "  int *a;\n"
+               "};\n"
+               "} // namespace b\n"
+               "} // namespace a");
+}
+
+TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
+  verifyFormat("while");
+  verifyFormat("operator");
+}
+
+TEST_F(FormatTest, SkipsDeeplyNestedLines) {
+  // This code would be painfully slow to format if we didn't skip it.
+  std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
+                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
+                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
+                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
+                   "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
+                   "A(1, 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
+                   ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
+  // Deeply nested part is untouched, rest is formatted.
+  EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
+            format(std::string("int    i;\n") + Code + "int    j;\n",
+                   getLLVMStyle(), IC_ExpectIncomplete));
+}
+
+//===----------------------------------------------------------------------===//
+// Objective-C tests.
+//===----------------------------------------------------------------------===//
+
+TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
+  verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
+  EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
+            format("-(NSUInteger)indexOfObject:(id)anObject;"));
+  EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
+  EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
+  EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
+            format("-(NSInteger)Method3:(id)anObject;"));
+  EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
+            format("-(NSInteger)Method4:(id)anObject;"));
+  EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
+            format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
+  EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
+            format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
+  EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
+            "forAllCells:(BOOL)flag;",
+            format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
+                   "forAllCells:(BOOL)flag;"));
+
+  // Very long objectiveC method declaration.
+  verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
+               "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
+  verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
+               "                    inRange:(NSRange)range\n"
+               "                   outRange:(NSRange)out_range\n"
+               "                  outRange1:(NSRange)out_range1\n"
+               "                  outRange2:(NSRange)out_range2\n"
+               "                  outRange3:(NSRange)out_range3\n"
+               "                  outRange4:(NSRange)out_range4\n"
+               "                  outRange5:(NSRange)out_range5\n"
+               "                  outRange6:(NSRange)out_range6\n"
+               "                  outRange7:(NSRange)out_range7\n"
+               "                  outRange8:(NSRange)out_range8\n"
+               "                  outRange9:(NSRange)out_range9;");
+
+  // When the function name has to be wrapped.
+  FormatStyle Style = getLLVMStyle();
+  Style.IndentWrappedFunctionNames = false;
+  verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
+               "veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
+               "           anotherName:(NSString)bbbbbbbbbbbbbb {\n"
+               "}",
+               Style);
+  Style.IndentWrappedFunctionNames = true;
+  verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
+               "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
+               "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
+               "}",
+               Style);
+
+  verifyFormat("- (int)sum:(vector<int>)numbers;");
+  verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
+  // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
+  // protocol lists (but not for template classes):
+  // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
+
+  verifyFormat("- (int (*)())foo:(int (*)())f;");
+  verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
+
+  // If there's no return type (very rare in practice!), LLVM and Google style
+  // agree.
+  verifyFormat("- foo;");
+  verifyFormat("- foo:(int)f;");
+  verifyGoogleFormat("- foo:(int)foo;");
+}
+
+
+TEST_F(FormatTest, BreaksStringLiterals) {
+  EXPECT_EQ("\"some text \"\n"
+            "\"other\";",
+            format("\"some text other\";", getLLVMStyleWithColumns(12)));
+  EXPECT_EQ("\"some text \"\n"
+            "\"other\";",
+            format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
+  EXPECT_EQ(
+      "#define A  \\\n"
+      "  \"some \"  \\\n"
+      "  \"text \"  \\\n"
+      "  \"other\";",
+      format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
+  EXPECT_EQ(
+      "#define A  \\\n"
+      "  \"so \"    \\\n"
+      "  \"text \"  \\\n"
+      "  \"other\";",
+      format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
+
+  EXPECT_EQ("\"some text\"",
+            format("\"some text\"", getLLVMStyleWithColumns(1)));
+  EXPECT_EQ("\"some text\"",
+            format("\"some text\"", getLLVMStyleWithColumns(11)));
+  EXPECT_EQ("\"some \"\n"
+            "\"text\"",
+            format("\"some text\"", getLLVMStyleWithColumns(10)));
+  EXPECT_EQ("\"some \"\n"
+            "\"text\"",
+            format("\"some text\"", getLLVMStyleWithColumns(7)));
+  EXPECT_EQ("\"some\"\n"
+            "\" tex\"\n"
+            "\"t\"",
+            format("\"some text\"", getLLVMStyleWithColumns(6)));
+  EXPECT_EQ("\"some\"\n"
+            "\" tex\"\n"
+            "\" and\"",
+            format("\"some tex and\"", getLLVMStyleWithColumns(6)));
+  EXPECT_EQ("\"some\"\n"
+            "\"/tex\"\n"
+            "\"/and\"",
+            format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
+
+  EXPECT_EQ("variable =\n"
+            "    \"long string \"\n"
+            "    \"literal\";",
+            format("variable = \"long string literal\";",
+                   getLLVMStyleWithColumns(20)));
+
+  EXPECT_EQ("variable = f(\n"
+            "    \"long string \"\n"
+            "    \"literal\",\n"
+            "    short,\n"
+            "    loooooooooooooooooooong);",
+            format("variable = f(\"long string literal\", short, "
+                   "loooooooooooooooooooong);",
+                   getLLVMStyleWithColumns(20)));
+
+  EXPECT_EQ(
+      "f(g(\"long string \"\n"
+      "    \"literal\"),\n"
+      "  b);",
+      format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
+  EXPECT_EQ("f(g(\"long string \"\n"
+            "    \"literal\",\n"
+            "    a),\n"
+            "  b);",
+            format("f(g(\"long string literal\", a), b);",
+                   getLLVMStyleWithColumns(20)));
+  EXPECT_EQ(
+      "f(\"one two\".split(\n"
+      "    variable));",
+      format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
+  EXPECT_EQ("f(\"one two three four five six \"\n"
+            "  \"seven\".split(\n"
+            "      really_looooong_variable));",
+            format("f(\"one two three four five six seven\"."
+                   "split(really_looooong_variable));",
+                   getLLVMStyleWithColumns(33)));
+
+  EXPECT_EQ("f(\"some \"\n"
+            "  \"text\",\n"
+            "  other);",
+            format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
+
+  // Only break as a last resort.
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaa(\n"
+      "    aaaaaaaaaaaaaaaaaaaa,\n"
+      "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
+
+  EXPECT_EQ("\"splitmea\"\n"
+            "\"trandomp\"\n"
+            "\"oint\"",
+            format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
+
+  EXPECT_EQ("\"split/\"\n"
+            "\"pathat/\"\n"
+            "\"slashes\"",
+            format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
+
+  EXPECT_EQ("\"split/\"\n"
+            "\"pathat/\"\n"
+            "\"slashes\"",
+            format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
+  EXPECT_EQ("\"split at \"\n"
+            "\"spaces/at/\"\n"
+            "\"slashes.at.any$\"\n"
+            "\"non-alphanumeric%\"\n"
+            "\"1111111111characte\"\n"
+            "\"rs\"",
+            format("\"split at "
+                   "spaces/at/"
+                   "slashes.at."
+                   "any$non-"
+                   "alphanumeric%"
+                   "1111111111characte"
+                   "rs\"",
+                   getLLVMStyleWithColumns(20)));
+
+  // Verify that splitting the strings understands
+  // Style::AlwaysBreakBeforeMultilineStrings.
+  EXPECT_EQ(
+      "aaaaaaaaaaaa(\n"
+      "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
+      "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
+      format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
+             "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
+             "aaaaaaaaaaaaaaaaaaaaaa\");",
+             getGoogleStyle()));
+  EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
+            "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
+            format("return \"aaaaaaaaaaaaaaaaaaaaaa "
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
+                   "aaaaaaaaaaaaaaaaaaaaaa\";",
+                   getGoogleStyle()));
+  EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
+            "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
+            format("llvm::outs() << "
+                   "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
+                   "aaaaaaaaaaaaaaaaaaa\";"));
+  EXPECT_EQ("ffff(\n"
+            "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
+            "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
+            format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
+                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
+                   getGoogleStyle()));
+
+  FormatStyle Style = getLLVMStyleWithColumns(12);
+  Style.BreakStringLiterals = false;
+  EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
+
+  FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
+  AlignLeft.AlignEscapedNewlinesLeft = true;
+  EXPECT_EQ("#define A \\\n"
+            "  \"some \" \\\n"
+            "  \"text \" \\\n"
+            "  \"other\";",
+            format("#define A \"some text other\";", AlignLeft));
+}
+
+TEST_F(FormatTest, FullyRemoveEmptyLines) {
+  FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
+  NoEmptyLines.MaxEmptyLinesToKeep = 0;
+  EXPECT_EQ("int i = a(b());",
+            format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
+}
+
+TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
+  EXPECT_EQ(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+      "(\n"
+      "    \"x\t\");",
+      format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+             "aaaaaaa("
+             "\"x\t\");"));
+}
+
+TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
+  EXPECT_EQ(
+      "u8\"utf8 string \"\n"
+      "u8\"literal\";",
+      format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
+  EXPECT_EQ(
+      "u\"utf16 string \"\n"
+      "u\"literal\";",
+      format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
+  EXPECT_EQ(
+      "U\"utf32 string \"\n"
+      "U\"literal\";",
+      format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
+  EXPECT_EQ("L\"wide string \"\n"
+            "L\"literal\";",
+            format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
+  EXPECT_EQ("@\"NSString \"\n"
+            "@\"literal\";",
+            format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
+
+  // This input makes clang-format try to split the incomplete unicode escape
+  // sequence, which used to lead to a crasher.
+  verifyNoCrash(
+      "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      getLLVMStyleWithColumns(60));
+}
+
+TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
+  FormatStyle Style = getGoogleStyleWithColumns(15);
+  EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
+  EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
+  EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
+  EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
+  EXPECT_EQ("u8R\"x(raw literal)x\";",
+            format("u8R\"x(raw literal)x\";", Style));
+}
+
+TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
+  FormatStyle Style = getLLVMStyleWithColumns(20);
+  EXPECT_EQ(
+      "_T(\"aaaaaaaaaaaaaa\")\n"
+      "_T(\"aaaaaaaaaaaaaa\")\n"
+      "_T(\"aaaaaaaaaaaa\")",
+      format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
+  EXPECT_EQ("f(x,\n"
+            "  _T(\"aaaaaaaaaaaa\")\n"
+            "  _T(\"aaa\"),\n"
+            "  z);",
+            format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
+
+  // FIXME: Handle embedded spaces in one iteration.
+  //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
+  //            "_T(\"aaaaaaaaaaaaa\")\n"
+  //            "_T(\"aaaaaaaaaaaaa\")\n"
+  //            "_T(\"a\")",
+  //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
+  //                   getLLVMStyleWithColumns(20)));
+  EXPECT_EQ(
+      "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
+      format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
+  EXPECT_EQ("f(\n"
+            "#if !TEST\n"
+            "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
+            "#endif\n"
+            "    );",
+            format("f(\n"
+                   "#if !TEST\n"
+                   "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
+                   "#endif\n"
+                   ");"));
+  EXPECT_EQ("f(\n"
+            "\n"
+            "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
+            format("f(\n"
+                   "\n"
+                   "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
+}
+
+TEST_F(FormatTest, BreaksStringLiteralOperands) {
+  // In a function call with two operands, the second can be broken with no line
+  // break before it.
+  EXPECT_EQ("func(a, \"long long \"\n"
+            "        \"long long\");",
+            format("func(a, \"long long long long\");",
+                   getLLVMStyleWithColumns(24)));
+  // In a function call with three operands, the second must be broken with a
+  // line break before it.
+  EXPECT_EQ("func(a,\n"
+            "     \"long long long \"\n"
+            "     \"long\",\n"
+            "     c);",
+            format("func(a, \"long long long long\", c);",
+                   getLLVMStyleWithColumns(24)));
+  // In a function call with three operands, the third must be broken with a
+  // line break before it.
+  EXPECT_EQ("func(a, b,\n"
+            "     \"long long long \"\n"
+            "     \"long\");",
+            format("func(a, b, \"long long long long\");",
+                   getLLVMStyleWithColumns(24)));
+  // In a function call with three operands, both the second and the third must
+  // be broken with a line break before them.
+  EXPECT_EQ("func(a,\n"
+            "     \"long long long \"\n"
+            "     \"long\",\n"
+            "     \"long long long \"\n"
+            "     \"long\");",
+            format("func(a, \"long long long long\", \"long long long long\");",
+                   getLLVMStyleWithColumns(24)));
+  // In a chain of << with two operands, the second can be broken with no line
+  // break before it.
+  EXPECT_EQ("a << \"line line \"\n"
+            "     \"line\";",
+            format("a << \"line line line\";",
+                   getLLVMStyleWithColumns(20)));
+  // In a chain of << with three operands, the second can be broken with no line
+  // break before it.
+  EXPECT_EQ("abcde << \"line \"\n"
+            "         \"line line\"\n"
+            "      << c;",
+            format("abcde << \"line line line\" << c;",
+                   getLLVMStyleWithColumns(20)));
+  // In a chain of << with three operands, the third must be broken with a line
+  // break before it.
+  EXPECT_EQ("a << b\n"
+            "  << \"line line \"\n"
+            "     \"line\";",
+            format("a << b << \"line line line\";",
+                   getLLVMStyleWithColumns(20)));
+  // In a chain of << with three operands, the second can be broken with no line
+  // break before it and the third must be broken with a line break before it.
+  EXPECT_EQ("abcd << \"line line \"\n"
+            "        \"line\"\n"
+            "     << \"line line \"\n"
+            "        \"line\";",
+            format("abcd << \"line line line\" << \"line line line\";",
+                   getLLVMStyleWithColumns(20)));
+  // In a chain of binary operators with two operands, the second can be broken
+  // with no line break before it.
+  EXPECT_EQ("abcd + \"line line \"\n"
+            "       \"line line\";",
+            format("abcd + \"line line line line\";",
+                   getLLVMStyleWithColumns(20)));
+  // In a chain of binary operators with three operands, the second must be
+  // broken with a line break before it.
+  EXPECT_EQ("abcd +\n"
+            "    \"line line \"\n"
+            "    \"line line\" +\n"
+            "    e;",
+            format("abcd + \"line line line line\" + e;",
+                   getLLVMStyleWithColumns(20)));
+  // In a function call with two operands, with AlignAfterOpenBracket enabled,
+  // the first must be broken with a line break before it.
+  FormatStyle Style = getLLVMStyleWithColumns(25);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+  EXPECT_EQ("someFunction(\n"
+            "    \"long long long \"\n"
+            "    \"long\",\n"
+            "    a);",
+            format("someFunction(\"long long long long\", a);", Style));
+}
+
+TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
+  EXPECT_EQ(
+      "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
+      "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
+      "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
+      format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
+             "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
+             "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
+}
+
+TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
+  EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
+            format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
+  EXPECT_EQ("fffffffffff(g(R\"x(\n"
+            "multiline raw string literal xxxxxxxxxxxxxx\n"
+            ")x\",\n"
+            "              a),\n"
+            "            b);",
+            format("fffffffffff(g(R\"x(\n"
+                   "multiline raw string literal xxxxxxxxxxxxxx\n"
+                   ")x\", a), b);",
+                   getGoogleStyleWithColumns(20)));
+  EXPECT_EQ("fffffffffff(\n"
+            "    g(R\"x(qqq\n"
+            "multiline raw string literal xxxxxxxxxxxxxx\n"
+            ")x\",\n"
+            "      a),\n"
+            "    b);",
+            format("fffffffffff(g(R\"x(qqq\n"
+                   "multiline raw string literal xxxxxxxxxxxxxx\n"
+                   ")x\", a), b);",
+                   getGoogleStyleWithColumns(20)));
+
+  EXPECT_EQ("fffffffffff(R\"x(\n"
+            "multiline raw string literal xxxxxxxxxxxxxx\n"
+            ")x\");",
+            format("fffffffffff(R\"x(\n"
+                   "multiline raw string literal xxxxxxxxxxxxxx\n"
+                   ")x\");",
+                   getGoogleStyleWithColumns(20)));
+  EXPECT_EQ("fffffffffff(R\"x(\n"
+            "multiline raw string literal xxxxxxxxxxxxxx\n"
+            ")x\" + bbbbbb);",
+            format("fffffffffff(R\"x(\n"
+                   "multiline raw string literal xxxxxxxxxxxxxx\n"
+                   ")x\" +   bbbbbb);",
+                   getGoogleStyleWithColumns(20)));
+  EXPECT_EQ("fffffffffff(\n"
+            "    R\"x(\n"
+            "multiline raw string literal xxxxxxxxxxxxxx\n"
+            ")x\" +\n"
+            "    bbbbbb);",
+            format("fffffffffff(\n"
+                   " R\"x(\n"
+                   "multiline raw string literal xxxxxxxxxxxxxx\n"
+                   ")x\" + bbbbbb);",
+                   getGoogleStyleWithColumns(20)));
+}
+
+TEST_F(FormatTest, SkipsUnknownStringLiterals) {
+  verifyFormat("string a = \"unterminated;");
+  EXPECT_EQ("function(\"unterminated,\n"
+            "         OtherParameter);",
+            format("function(  \"unterminated,\n"
+                   "    OtherParameter);"));
+}
+
+TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
+  FormatStyle Style = getLLVMStyle();
+  Style.Standard = FormatStyle::LS_Cpp03;
+  EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
+            format("#define x(_a) printf(\"foo\"_a);", Style));
+}
+
+TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
+
+TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
+  EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
+            "             \"ddeeefff\");",
+            format("someFunction(\"aaabbbcccdddeeefff\");",
+                   getLLVMStyleWithColumns(25)));
+  EXPECT_EQ("someFunction1234567890(\n"
+            "    \"aaabbbcccdddeeefff\");",
+            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
+                   getLLVMStyleWithColumns(26)));
+  EXPECT_EQ("someFunction1234567890(\n"
+            "    \"aaabbbcccdddeeeff\"\n"
+            "    \"f\");",
+            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
+                   getLLVMStyleWithColumns(25)));
+  EXPECT_EQ("someFunction1234567890(\n"
+            "    \"aaabbbcccdddeeeff\"\n"
+            "    \"f\");",
+            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
+                   getLLVMStyleWithColumns(24)));
+  EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
+            "             \"ddde \"\n"
+            "             \"efff\");",
+            format("someFunction(\"aaabbbcc ddde efff\");",
+                   getLLVMStyleWithColumns(25)));
+  EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
+            "             \"ddeeefff\");",
+            format("someFunction(\"aaabbbccc ddeeefff\");",
+                   getLLVMStyleWithColumns(25)));
+  EXPECT_EQ("someFunction1234567890(\n"
+            "    \"aaabb \"\n"
+            "    \"cccdddeeefff\");",
+            format("someFunction1234567890(\"aaabb cccdddeeefff\");",
+                   getLLVMStyleWithColumns(25)));
+  EXPECT_EQ("#define A          \\\n"
+            "  string s =       \\\n"
+            "      \"123456789\"  \\\n"
+            "      \"0\";         \\\n"
+            "  int i;",
+            format("#define A string s = \"1234567890\"; int i;",
+                   getLLVMStyleWithColumns(20)));
+  // FIXME: Put additional penalties on breaking at non-whitespace locations.
+  EXPECT_EQ("someFunction(\"aaabbbcc \"\n"
+            "             \"dddeeeff\"\n"
+            "             \"f\");",
+            format("someFunction(\"aaabbbcc dddeeefff\");",
+                   getLLVMStyleWithColumns(25)));
+}
+
+TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
+  EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
+  EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
+  EXPECT_EQ("\"test\"\n"
+            "\"\\n\"",
+            format("\"test\\n\"", getLLVMStyleWithColumns(7)));
+  EXPECT_EQ("\"tes\\\\\"\n"
+            "\"n\"",
+            format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
+  EXPECT_EQ("\"\\\\\\\\\"\n"
+            "\"\\n\"",
+            format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
+  EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
+  EXPECT_EQ("\"\\uff01\"\n"
+            "\"test\"",
+            format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
+  EXPECT_EQ("\"\\Uff01ff02\"",
+            format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
+  EXPECT_EQ("\"\\x000000000001\"\n"
+            "\"next\"",
+            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
+  EXPECT_EQ("\"\\x000000000001next\"",
+            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
+  EXPECT_EQ("\"\\x000000000001\"",
+            format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
+  EXPECT_EQ("\"test\"\n"
+            "\"\\000000\"\n"
+            "\"000001\"",
+            format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
+  EXPECT_EQ("\"test\\000\"\n"
+            "\"00000000\"\n"
+            "\"1\"",
+            format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
+}
+
+TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
+  verifyFormat("void f() {\n"
+               "  return g() {}\n"
+               "  void h() {}");
+  verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
+               "g();\n"
+               "}");
+}
+
+TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
+  verifyFormat(
+      "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
+}
+
+TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
+  verifyFormat("class X {\n"
+               "  void f() {\n"
+               "  }\n"
+               "};",
+               getLLVMStyleWithColumns(12));
+}
+
+TEST_F(FormatTest, ConfigurableIndentWidth) {
+  FormatStyle EightIndent = getLLVMStyleWithColumns(18);
+  EightIndent.IndentWidth = 8;
+  EightIndent.ContinuationIndentWidth = 8;
+  verifyFormat("void f() {\n"
+               "        someFunction();\n"
+               "        if (true) {\n"
+               "                f();\n"
+               "        }\n"
+               "}",
+               EightIndent);
+  verifyFormat("class X {\n"
+               "        void f() {\n"
+               "        }\n"
+               "};",
+               EightIndent);
+  verifyFormat("int x[] = {\n"
+               "        call(),\n"
+               "        call()};",
+               EightIndent);
+}
+
+TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
+  verifyFormat("double\n"
+               "f();",
+               getLLVMStyleWithColumns(8));
+}
+
+TEST_F(FormatTest, ConfigurableUseOfTab) {
+  FormatStyle Tab = getLLVMStyleWithColumns(42);
+  Tab.IndentWidth = 8;
+  Tab.UseTab = FormatStyle::UT_Always;
+  Tab.AlignEscapedNewlinesLeft = true;
+
+  EXPECT_EQ("if (aaaaaaaa && // q\n"
+            "    bb)\t\t// w\n"
+            "\t;",
+            format("if (aaaaaaaa &&// q\n"
+                   "bb)// w\n"
+                   ";",
+                   Tab));
+  EXPECT_EQ("if (aaa && bbb) // w\n"
+            "\t;",
+            format("if(aaa&&bbb)// w\n"
+                   ";",
+                   Tab));
+
+  verifyFormat("class X {\n"
+               "\tvoid f() {\n"
+               "\t\tsomeFunction(parameter1,\n"
+               "\t\t\t     parameter2);\n"
+               "\t}\n"
+               "};",
+               Tab);
+  verifyFormat("#define A                        \\\n"
+               "\tvoid f() {               \\\n"
+               "\t\tsomeFunction(    \\\n"
+               "\t\t    parameter1,  \\\n"
+               "\t\t    parameter2); \\\n"
+               "\t}",
+               Tab);
+
+  Tab.TabWidth = 4;
+  Tab.IndentWidth = 8;
+  verifyFormat("class TabWidth4Indent8 {\n"
+               "\t\tvoid f() {\n"
+               "\t\t\t\tsomeFunction(parameter1,\n"
+               "\t\t\t\t\t\t\t parameter2);\n"
+               "\t\t}\n"
+               "};",
+               Tab);
+
+  Tab.TabWidth = 4;
+  Tab.IndentWidth = 4;
+  verifyFormat("class TabWidth4Indent4 {\n"
+               "\tvoid f() {\n"
+               "\t\tsomeFunction(parameter1,\n"
+               "\t\t\t\t\t parameter2);\n"
+               "\t}\n"
+               "};",
+               Tab);
+
+  Tab.TabWidth = 8;
+  Tab.IndentWidth = 4;
+  verifyFormat("class TabWidth8Indent4 {\n"
+               "    void f() {\n"
+               "\tsomeFunction(parameter1,\n"
+               "\t\t     parameter2);\n"
+               "    }\n"
+               "};",
+               Tab);
+
+  Tab.TabWidth = 8;
+  Tab.IndentWidth = 8;
+  EXPECT_EQ("/*\n"
+            "\t      a\t\tcomment\n"
+            "\t      in multiple lines\n"
+            "       */",
+            format("   /*\t \t \n"
+                   " \t \t a\t\tcomment\t \t\n"
+                   " \t \t in multiple lines\t\n"
+                   " \t  */",
+                   Tab));
+
+  Tab.UseTab = FormatStyle::UT_ForIndentation;
+  verifyFormat("{\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "};",
+               Tab);
+  verifyFormat("enum AA {\n"
+               "\ta1, // Force multiple lines\n"
+               "\ta2,\n"
+               "\ta3\n"
+               "};",
+               Tab);
+  EXPECT_EQ("if (aaaaaaaa && // q\n"
+            "    bb)         // w\n"
+            "\t;",
+            format("if (aaaaaaaa &&// q\n"
+                   "bb)// w\n"
+                   ";",
+                   Tab));
+  verifyFormat("class X {\n"
+               "\tvoid f() {\n"
+               "\t\tsomeFunction(parameter1,\n"
+               "\t\t             parameter2);\n"
+               "\t}\n"
+               "};",
+               Tab);
+  verifyFormat("{\n"
+               "\tQ(\n"
+               "\t    {\n"
+               "\t\t    int a;\n"
+               "\t\t    someFunction(aaaaaaaa,\n"
+               "\t\t                 bbbbbbb);\n"
+               "\t    },\n"
+               "\t    p);\n"
+               "}",
+               Tab);
+  EXPECT_EQ("{\n"
+            "\t/* aaaa\n"
+            "\t   bbbb */\n"
+            "}",
+            format("{\n"
+                   "/* aaaa\n"
+                   "   bbbb */\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+            "\t  bbbbbbbbbbbbb\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "/*\n"
+                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
+                   "*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+            "\t// bbbbbbbbbbbbb\n"
+            "}",
+            format("{\n"
+                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+            "\t  bbbbbbbbbbbbb\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
+                   "\t*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            "\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   "\n"
+                   "\t*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            " asdf\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   " asdf\n"
+                   "\t*/\n"
+                   "}",
+                   Tab));
+
+  Tab.UseTab = FormatStyle::UT_Never;
+  EXPECT_EQ("/*\n"
+            "              a\t\tcomment\n"
+            "              in multiple lines\n"
+            "       */",
+            format("   /*\t \t \n"
+                   " \t \t a\t\tcomment\t \t\n"
+                   " \t \t in multiple lines\t\n"
+                   " \t  */",
+                   Tab));
+  EXPECT_EQ("/* some\n"
+            "   comment */",
+            format(" \t \t /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("int a; /* some\n"
+            "   comment */",
+            format(" \t \t int a; /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+
+  EXPECT_EQ("int a; /* some\n"
+            "comment */",
+            format(" \t \t int\ta; /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("f(\"\t\t\"); /* some\n"
+            "    comment */",
+            format(" \t \t f(\"\t\t\"); /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "  /*\n"
+            "   * Comment\n"
+            "   */\n"
+            "  int i;\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   "\t * Comment\n"
+                   "\t */\n"
+                   "\t int i;\n"
+                   "}"));
+
+  Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
+  Tab.TabWidth = 8;
+  Tab.IndentWidth = 8;
+  EXPECT_EQ("if (aaaaaaaa && // q\n"
+            "    bb)         // w\n"
+            "\t;",
+            format("if (aaaaaaaa &&// q\n"
+                   "bb)// w\n"
+                   ";",
+                   Tab));
+  EXPECT_EQ("if (aaa && bbb) // w\n"
+            "\t;",
+            format("if(aaa&&bbb)// w\n"
+                   ";",
+                   Tab));
+  verifyFormat("class X {\n"
+               "\tvoid f() {\n"
+               "\t\tsomeFunction(parameter1,\n"
+               "\t\t\t     parameter2);\n"
+               "\t}\n"
+               "};",
+               Tab);
+  verifyFormat("#define A                        \\\n"
+               "\tvoid f() {               \\\n"
+               "\t\tsomeFunction(    \\\n"
+               "\t\t    parameter1,  \\\n"
+               "\t\t    parameter2); \\\n"
+               "\t}",
+               Tab);
+  Tab.TabWidth = 4;
+  Tab.IndentWidth = 8;
+  verifyFormat("class TabWidth4Indent8 {\n"
+               "\t\tvoid f() {\n"
+               "\t\t\t\tsomeFunction(parameter1,\n"
+               "\t\t\t\t\t\t\t parameter2);\n"
+               "\t\t}\n"
+               "};",
+               Tab);
+  Tab.TabWidth = 4;
+  Tab.IndentWidth = 4;
+  verifyFormat("class TabWidth4Indent4 {\n"
+               "\tvoid f() {\n"
+               "\t\tsomeFunction(parameter1,\n"
+               "\t\t\t\t\t parameter2);\n"
+               "\t}\n"
+               "};",
+               Tab);
+  Tab.TabWidth = 8;
+  Tab.IndentWidth = 4;
+  verifyFormat("class TabWidth8Indent4 {\n"
+               "    void f() {\n"
+               "\tsomeFunction(parameter1,\n"
+               "\t\t     parameter2);\n"
+               "    }\n"
+               "};",
+               Tab);
+  Tab.TabWidth = 8;
+  Tab.IndentWidth = 8;
+  EXPECT_EQ("/*\n"
+            "\t      a\t\tcomment\n"
+            "\t      in multiple lines\n"
+            "       */",
+            format("   /*\t \t \n"
+                   " \t \t a\t\tcomment\t \t\n"
+                   " \t \t in multiple lines\t\n"
+                   " \t  */",
+                   Tab));
+  verifyFormat("{\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
+               "};",
+               Tab);
+  verifyFormat("enum AA {\n"
+               "\ta1, // Force multiple lines\n"
+               "\ta2,\n"
+               "\ta3\n"
+               "};",
+               Tab);
+  EXPECT_EQ("if (aaaaaaaa && // q\n"
+            "    bb)         // w\n"
+            "\t;",
+            format("if (aaaaaaaa &&// q\n"
+                   "bb)// w\n"
+                   ";",
+                   Tab));
+  verifyFormat("class X {\n"
+               "\tvoid f() {\n"
+               "\t\tsomeFunction(parameter1,\n"
+               "\t\t\t     parameter2);\n"
+               "\t}\n"
+               "};",
+               Tab);
+  verifyFormat("{\n"
+               "\tQ(\n"
+               "\t    {\n"
+               "\t\t    int a;\n"
+               "\t\t    someFunction(aaaaaaaa,\n"
+               "\t\t\t\t bbbbbbb);\n"
+               "\t    },\n"
+               "\t    p);\n"
+               "}",
+               Tab);
+  EXPECT_EQ("{\n"
+            "\t/* aaaa\n"
+            "\t   bbbb */\n"
+            "}",
+            format("{\n"
+                   "/* aaaa\n"
+                   "   bbbb */\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+            "\t  bbbbbbbbbbbbb\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "/*\n"
+                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
+                   "*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+            "\t// bbbbbbbbbbbbb\n"
+            "}",
+            format("{\n"
+                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+            "\t  bbbbbbbbbbbbb\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
+                   "\t*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            "\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   "\n"
+                   "\t*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "\t/*\n"
+            " asdf\n"
+            "\t*/\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   " asdf\n"
+                   "\t*/\n"
+                   "}",
+                   Tab));
+  EXPECT_EQ("/*\n"
+            "\t      a\t\tcomment\n"
+            "\t      in multiple lines\n"
+            "       */",
+            format("   /*\t \t \n"
+                   " \t \t a\t\tcomment\t \t\n"
+                   " \t \t in multiple lines\t\n"
+                   " \t  */",
+                   Tab));
+  EXPECT_EQ("/* some\n"
+            "   comment */",
+            format(" \t \t /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("int a; /* some\n"
+            "   comment */",
+            format(" \t \t int a; /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("int a; /* some\n"
+            "comment */",
+            format(" \t \t int\ta; /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("f(\"\t\t\"); /* some\n"
+            "    comment */",
+            format(" \t \t f(\"\t\t\"); /* some\n"
+                   " \t \t    comment */",
+                   Tab));
+  EXPECT_EQ("{\n"
+            "  /*\n"
+            "   * Comment\n"
+            "   */\n"
+            "  int i;\n"
+            "}",
+            format("{\n"
+                   "\t/*\n"
+                   "\t * Comment\n"
+                   "\t */\n"
+                   "\t int i;\n"
+                   "}"));
+  Tab.AlignConsecutiveAssignments = true;
+  Tab.AlignConsecutiveDeclarations = true;
+  Tab.TabWidth = 4;
+  Tab.IndentWidth = 4;
+  verifyFormat("class Assign {\n"
+               "\tvoid f() {\n"
+               "\t\tint         x      = 123;\n"
+               "\t\tint         random = 4;\n"
+               "\t\tstd::string alphabet =\n"
+               "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
+               "\t}\n"
+               "};",
+               Tab);
+}
+
+TEST_F(FormatTest, CalculatesOriginalColumn) {
+  EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+            "q\"; /* some\n"
+            "       comment */",
+            format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+                   "q\"; /* some\n"
+                   "       comment */",
+                   getLLVMStyle()));
+  EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
+            "/* some\n"
+            "   comment */",
+            format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
+                   " /* some\n"
+                   "    comment */",
+                   getLLVMStyle()));
+  EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+            "qqq\n"
+            "/* some\n"
+            "   comment */",
+            format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+                   "qqq\n"
+                   " /* some\n"
+                   "    comment */",
+                   getLLVMStyle()));
+  EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+            "wwww; /* some\n"
+            "         comment */",
+            format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+                   "wwww; /* some\n"
+                   "         comment */",
+                   getLLVMStyle()));
+}
+
+TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
+  FormatStyle NoSpace = getLLVMStyle();
+  NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
+
+  verifyFormat("while(true)\n"
+               "  continue;",
+               NoSpace);
+  verifyFormat("for(;;)\n"
+               "  continue;",
+               NoSpace);
+  verifyFormat("if(true)\n"
+               "  f();\n"
+               "else if(true)\n"
+               "  f();",
+               NoSpace);
+  verifyFormat("do {\n"
+               "  do_something();\n"
+               "} while(something());",
+               NoSpace);
+  verifyFormat("switch(x) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               NoSpace);
+  verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
+  verifyFormat("size_t x = sizeof(x);", NoSpace);
+  verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
+  verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
+  verifyFormat("alignas(128) char a[128];", NoSpace);
+  verifyFormat("size_t x = alignof(MyType);", NoSpace);
+  verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
+  verifyFormat("int f() throw(Deprecated);", NoSpace);
+  verifyFormat("typedef void (*cb)(int);", NoSpace);
+  verifyFormat("T A::operator()();", NoSpace);
+  verifyFormat("X A::operator++(T);", NoSpace);
+
+  FormatStyle Space = getLLVMStyle();
+  Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
+
+  verifyFormat("int f ();", Space);
+  verifyFormat("void f (int a, T b) {\n"
+               "  while (true)\n"
+               "    continue;\n"
+               "}",
+               Space);
+  verifyFormat("if (true)\n"
+               "  f ();\n"
+               "else if (true)\n"
+               "  f ();",
+               Space);
+  verifyFormat("do {\n"
+               "  do_something ();\n"
+               "} while (something ());",
+               Space);
+  verifyFormat("switch (x) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               Space);
+  verifyFormat("A::A () : a (1) {}", Space);
+  verifyFormat("void f () __attribute__ ((asdf));", Space);
+  verifyFormat("*(&a + 1);\n"
+               "&((&a)[1]);\n"
+               "a[(b + c) * d];\n"
+               "(((a + 1) * 2) + 3) * 4;",
+               Space);
+  verifyFormat("#define A(x) x", Space);
+  verifyFormat("#define A (x) x", Space);
+  verifyFormat("#if defined(x)\n"
+               "#endif",
+               Space);
+  verifyFormat("auto i = std::make_unique<int> (5);", Space);
+  verifyFormat("size_t x = sizeof (x);", Space);
+  verifyFormat("auto f (int x) -> decltype (x);", Space);
+  verifyFormat("int f (T x) noexcept (x.create ());", Space);
+  verifyFormat("alignas (128) char a[128];", Space);
+  verifyFormat("size_t x = alignof (MyType);", Space);
+  verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
+  verifyFormat("int f () throw (Deprecated);", Space);
+  verifyFormat("typedef void (*cb) (int);", Space);
+  verifyFormat("T A::operator() ();", Space);
+  verifyFormat("X A::operator++ (T);", Space);
+}
+
+TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
+  FormatStyle Spaces = getLLVMStyle();
+
+  Spaces.SpacesInParentheses = true;
+  verifyFormat("call( x, y, z );", Spaces);
+  verifyFormat("call();", Spaces);
+  verifyFormat("std::function<void( int, int )> callback;", Spaces);
+  verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
+               Spaces);
+  verifyFormat("while ( (bool)1 )\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("for ( ;; )\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("if ( true )\n"
+               "  f();\n"
+               "else if ( true )\n"
+               "  f();",
+               Spaces);
+  verifyFormat("do {\n"
+               "  do_something( (int)i );\n"
+               "} while ( something() );",
+               Spaces);
+  verifyFormat("switch ( x ) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               Spaces);
+
+  Spaces.SpacesInParentheses = false;
+  Spaces.SpacesInCStyleCastParentheses = true;
+  verifyFormat("Type *A = ( Type * )P;", Spaces);
+  verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
+  verifyFormat("x = ( int32 )y;", Spaces);
+  verifyFormat("int a = ( int )(2.0f);", Spaces);
+  verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
+  verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
+  verifyFormat("#define x (( int )-1)", Spaces);
+
+  // Run the first set of tests again with:
+  Spaces.SpacesInParentheses = false;
+  Spaces.SpaceInEmptyParentheses = true;
+  Spaces.SpacesInCStyleCastParentheses = true;
+  verifyFormat("call(x, y, z);", Spaces);
+  verifyFormat("call( );", Spaces);
+  verifyFormat("std::function<void(int, int)> callback;", Spaces);
+  verifyFormat("while (( bool )1)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("for (;;)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("if (true)\n"
+               "  f( );\n"
+               "else if (true)\n"
+               "  f( );",
+               Spaces);
+  verifyFormat("do {\n"
+               "  do_something(( int )i);\n"
+               "} while (something( ));",
+               Spaces);
+  verifyFormat("switch (x) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               Spaces);
+
+  // Run the first set of tests again with:
+  Spaces.SpaceAfterCStyleCast = true;
+  verifyFormat("call(x, y, z);", Spaces);
+  verifyFormat("call( );", Spaces);
+  verifyFormat("std::function<void(int, int)> callback;", Spaces);
+  verifyFormat("while (( bool ) 1)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("for (;;)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("if (true)\n"
+               "  f( );\n"
+               "else if (true)\n"
+               "  f( );",
+               Spaces);
+  verifyFormat("do {\n"
+               "  do_something(( int ) i);\n"
+               "} while (something( ));",
+               Spaces);
+  verifyFormat("switch (x) {\n"
+               "default:\n"
+               "  break;\n"
+               "}",
+               Spaces);
+
+  // Run subset of tests again with:
+  Spaces.SpacesInCStyleCastParentheses = false;
+  Spaces.SpaceAfterCStyleCast = true;
+  verifyFormat("while ((bool) 1)\n"
+               "  continue;",
+               Spaces);
+  verifyFormat("do {\n"
+               "  do_something((int) i);\n"
+               "} while (something( ));",
+               Spaces);
+}
+
+TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
+  verifyFormat("int a[5];");
+  verifyFormat("a[3] += 42;");
+
+  FormatStyle Spaces = getLLVMStyle();
+  Spaces.SpacesInSquareBrackets = true;
+  // Lambdas unchanged.
+  verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
+  verifyFormat("return [i, args...] {};", Spaces);
+
+  // Not lambdas.
+  verifyFormat("int a[ 5 ];", Spaces);
+  verifyFormat("a[ 3 ] += 42;", Spaces);
+  verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
+  verifyFormat("double &operator[](int i) { return 0; }\n"
+               "int i;",
+               Spaces);
+  verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
+  verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
+  verifyFormat("int i = (*b)[ a ]->f();", Spaces);
+}
+
+TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
+  verifyFormat("int a = 5;");
+  verifyFormat("a += 42;");
+  verifyFormat("a or_eq 8;");
+
+  FormatStyle Spaces = getLLVMStyle();
+  Spaces.SpaceBeforeAssignmentOperators = false;
+  verifyFormat("int a= 5;", Spaces);
+  verifyFormat("a+= 42;", Spaces);
+  verifyFormat("a or_eq 8;", Spaces);
+}
+
+TEST_F(FormatTest, AlignConsecutiveAssignments) {
+  FormatStyle Alignment = getLLVMStyle();
+  Alignment.AlignConsecutiveAssignments = false;
+  verifyFormat("int a = 5;\n"
+               "int oneTwoThree = 123;",
+               Alignment);
+  verifyFormat("int a = 5;\n"
+               "int oneTwoThree = 123;",
+               Alignment);
+
+  Alignment.AlignConsecutiveAssignments = true;
+  verifyFormat("int a           = 5;\n"
+               "int oneTwoThree = 123;",
+               Alignment);
+  verifyFormat("int a           = method();\n"
+               "int oneTwoThree = 133;",
+               Alignment);
+  verifyFormat("a &= 5;\n"
+               "bcd *= 5;\n"
+               "ghtyf += 5;\n"
+               "dvfvdb -= 5;\n"
+               "a /= 5;\n"
+               "vdsvsv %= 5;\n"
+               "sfdbddfbdfbb ^= 5;\n"
+               "dvsdsv |= 5;\n"
+               "int dsvvdvsdvvv = 123;",
+               Alignment);
+  verifyFormat("int i = 1, j = 10;\n"
+               "something = 2000;",
+               Alignment);
+  verifyFormat("something = 2000;\n"
+               "int i = 1, j = 10;\n",
+               Alignment);
+  verifyFormat("something = 2000;\n"
+               "another   = 911;\n"
+               "int i = 1, j = 10;\n"
+               "oneMore = 1;\n"
+               "i       = 2;",
+               Alignment);
+  verifyFormat("int a   = 5;\n"
+               "int one = 1;\n"
+               "method();\n"
+               "int oneTwoThree = 123;\n"
+               "int oneTwo      = 12;",
+               Alignment);
+  verifyFormat("int oneTwoThree = 123;\n"
+               "int oneTwo      = 12;\n"
+               "method();\n",
+               Alignment);
+  verifyFormat("int oneTwoThree = 123; // comment\n"
+               "int oneTwo      = 12;  // comment",
+               Alignment);
+  EXPECT_EQ("int a = 5;\n"
+            "\n"
+            "int oneTwoThree = 123;",
+            format("int a       = 5;\n"
+                   "\n"
+                   "int oneTwoThree= 123;",
+                   Alignment));
+  EXPECT_EQ("int a   = 5;\n"
+            "int one = 1;\n"
+            "\n"
+            "int oneTwoThree = 123;",
+            format("int a = 5;\n"
+                   "int one = 1;\n"
+                   "\n"
+                   "int oneTwoThree = 123;",
+                   Alignment));
+  EXPECT_EQ("int a   = 5;\n"
+            "int one = 1;\n"
+            "\n"
+            "int oneTwoThree = 123;\n"
+            "int oneTwo      = 12;",
+            format("int a = 5;\n"
+                   "int one = 1;\n"
+                   "\n"
+                   "int oneTwoThree = 123;\n"
+                   "int oneTwo = 12;",
+                   Alignment));
+  Alignment.AlignEscapedNewlinesLeft = true;
+  verifyFormat("#define A               \\\n"
+               "  int aaaa       = 12;  \\\n"
+               "  int b          = 23;  \\\n"
+               "  int ccc        = 234; \\\n"
+               "  int dddddddddd = 2345;",
+               Alignment);
+  Alignment.AlignEscapedNewlinesLeft = false;
+  verifyFormat("#define A                                                      "
+               "                \\\n"
+               "  int aaaa       = 12;                                         "
+               "                \\\n"
+               "  int b          = 23;                                         "
+               "                \\\n"
+               "  int ccc        = 234;                                        "
+               "                \\\n"
+               "  int dddddddddd = 2345;",
+               Alignment);
+  verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
+               "k = 4, int l = 5,\n"
+               "                  int m = 6) {\n"
+               "  int j      = 10;\n"
+               "  otherThing = 1;\n"
+               "}",
+               Alignment);
+  verifyFormat("void SomeFunction(int parameter = 0) {\n"
+               "  int i   = 1;\n"
+               "  int j   = 2;\n"
+               "  int big = 10000;\n"
+               "}",
+               Alignment);
+  verifyFormat("class C {\n"
+               "public:\n"
+               "  int i            = 1;\n"
+               "  virtual void f() = 0;\n"
+               "};",
+               Alignment);
+  verifyFormat("int i = 1;\n"
+               "if (SomeType t = getSomething()) {\n"
+               "}\n"
+               "int j   = 2;\n"
+               "int big = 10000;",
+               Alignment);
+  verifyFormat("int j = 7;\n"
+               "for (int k = 0; k < N; ++k) {\n"
+               "}\n"
+               "int j   = 2;\n"
+               "int big = 10000;\n"
+               "}",
+               Alignment);
+  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  verifyFormat("int i = 1;\n"
+               "LooooooooooongType loooooooooooooooooooooongVariable\n"
+               "    = someLooooooooooooooooongFunction();\n"
+               "int j = 2;",
+               Alignment);
+  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
+  verifyFormat("int i = 1;\n"
+               "LooooooooooongType loooooooooooooooooooooongVariable =\n"
+               "    someLooooooooooooooooongFunction();\n"
+               "int j = 2;",
+               Alignment);
+
+  verifyFormat("auto lambda = []() {\n"
+               "  auto i = 0;\n"
+               "  return 0;\n"
+               "};\n"
+               "int i  = 0;\n"
+               "auto v = type{\n"
+               "    i = 1,   //\n"
+               "    (i = 2), //\n"
+               "    i = 3    //\n"
+               "};",
+               Alignment);
+
+  verifyFormat(
+      "int i      = 1;\n"
+      "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
+      "                          loooooooooooooooooooooongParameterB);\n"
+      "int j      = 2;",
+      Alignment);
+
+  verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
+               "          typename B   = very_long_type_name_1,\n"
+               "          typename T_2 = very_long_type_name_2>\n"
+               "auto foo() {}\n",
+               Alignment);
+  verifyFormat("int a, b = 1;\n"
+               "int c  = 2;\n"
+               "int dd = 3;\n",
+               Alignment);
+  verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
+               "float b[1][] = {{3.f}};\n",
+               Alignment);
+  verifyFormat("for (int i = 0; i < 1; i++)\n"
+               "  int x = 1;\n",
+               Alignment);
+  verifyFormat("for (i = 0; i < 1; i++)\n"
+               "  x = 1;\n"
+               "y = 1;\n",
+               Alignment);
+}
+
+TEST_F(FormatTest, AlignConsecutiveDeclarations) {
+  FormatStyle Alignment = getLLVMStyle();
+  Alignment.AlignConsecutiveDeclarations = false;
+  verifyFormat("float const a = 5;\n"
+               "int oneTwoThree = 123;",
+               Alignment);
+  verifyFormat("int a = 5;\n"
+               "float const oneTwoThree = 123;",
+               Alignment);
+
+  Alignment.AlignConsecutiveDeclarations = true;
+  verifyFormat("float const a = 5;\n"
+               "int         oneTwoThree = 123;",
+               Alignment);
+  verifyFormat("int         a = method();\n"
+               "float const oneTwoThree = 133;",
+               Alignment);
+  verifyFormat("int i = 1, j = 10;\n"
+               "something = 2000;",
+               Alignment);
+  verifyFormat("something = 2000;\n"
+               "int i = 1, j = 10;\n",
+               Alignment);
+  verifyFormat("float      something = 2000;\n"
+               "double     another = 911;\n"
+               "int        i = 1, j = 10;\n"
+               "const int *oneMore = 1;\n"
+               "unsigned   i = 2;",
+               Alignment);
+  verifyFormat("float a = 5;\n"
+               "int   one = 1;\n"
+               "method();\n"
+               "const double       oneTwoThree = 123;\n"
+               "const unsigned int oneTwo = 12;",
+               Alignment);
+  verifyFormat("int      oneTwoThree{0}; // comment\n"
+               "unsigned oneTwo;         // comment",
+               Alignment);
+  EXPECT_EQ("float const a = 5;\n"
+            "\n"
+            "int oneTwoThree = 123;",
+            format("float const   a = 5;\n"
+                   "\n"
+                   "int           oneTwoThree= 123;",
+                   Alignment));
+  EXPECT_EQ("float a = 5;\n"
+            "int   one = 1;\n"
+            "\n"
+            "unsigned oneTwoThree = 123;",
+            format("float    a = 5;\n"
+                   "int      one = 1;\n"
+                   "\n"
+                   "unsigned oneTwoThree = 123;",
+                   Alignment));
+  EXPECT_EQ("float a = 5;\n"
+            "int   one = 1;\n"
+            "\n"
+            "unsigned oneTwoThree = 123;\n"
+            "int      oneTwo = 12;",
+            format("float    a = 5;\n"
+                   "int one = 1;\n"
+                   "\n"
+                   "unsigned oneTwoThree = 123;\n"
+                   "int oneTwo = 12;",
+                   Alignment));
+  // Function prototype alignment
+  verifyFormat("int    a();\n"
+               "double b();",
+               Alignment);
+  verifyFormat("int    a(int x);\n"
+               "double b();",
+               Alignment);
+  unsigned OldColumnLimit = Alignment.ColumnLimit;
+  // We need to set ColumnLimit to zero, in order to stress nested alignments,
+  // otherwise the function parameters will be re-flowed onto a single line.
+  Alignment.ColumnLimit = 0;
+  EXPECT_EQ("int    a(int   x,\n"
+            "         float y);\n"
+            "double b(int    x,\n"
+            "         double y);",
+            format("int a(int x,\n"
+                   " float y);\n"
+                   "double b(int x,\n"
+                   " double y);",
+                   Alignment));
+  // This ensures that function parameters of function declarations are
+  // correctly indented when their owning functions are indented.
+  // The failure case here is for 'double y' to not be indented enough.
+  EXPECT_EQ("double a(int x);\n"
+            "int    b(int    y,\n"
+            "         double z);",
+            format("double a(int x);\n"
+                   "int b(int y,\n"
+                   " double z);",
+                   Alignment));
+  // Set ColumnLimit low so that we induce wrapping immediately after
+  // the function name and opening paren.
+  Alignment.ColumnLimit = 13;
+  verifyFormat("int function(\n"
+               "    int  x,\n"
+               "    bool y);",
+               Alignment);
+  Alignment.ColumnLimit = OldColumnLimit;
+  // Ensure function pointers don't screw up recursive alignment
+  verifyFormat("int    a(int x, void (*fp)(int y));\n"
+               "double b();",
+               Alignment);
+  Alignment.AlignConsecutiveAssignments = true;
+  // Ensure recursive alignment is broken by function braces, so that the
+  // "a = 1" does not align with subsequent assignments inside the function
+  // body.
+  verifyFormat("int func(int a = 1) {\n"
+               "  int b  = 2;\n"
+               "  int cc = 3;\n"
+               "}",
+               Alignment);
+  verifyFormat("float      something = 2000;\n"
+               "double     another   = 911;\n"
+               "int        i = 1, j = 10;\n"
+               "const int *oneMore = 1;\n"
+               "unsigned   i       = 2;",
+               Alignment);
+  verifyFormat("int      oneTwoThree = {0}; // comment\n"
+               "unsigned oneTwo      = 0;   // comment",
+               Alignment);
+  // Make sure that scope is correctly tracked, in the absence of braces
+  verifyFormat("for (int i = 0; i < n; i++)\n"
+               "  j = i;\n"
+               "double x = 1;\n",
+               Alignment);
+  verifyFormat("if (int i = 0)\n"
+               "  j = i;\n"
+               "double x = 1;\n",
+               Alignment);
+  // Ensure operator[] and operator() are comprehended
+  verifyFormat("struct test {\n"
+               "  long long int foo();\n"
+               "  int           operator[](int a);\n"
+               "  double        bar();\n"
+               "};\n",
+               Alignment);
+  verifyFormat("struct test {\n"
+               "  long long int foo();\n"
+               "  int           operator()(int a);\n"
+               "  double        bar();\n"
+               "};\n",
+               Alignment);
+  EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
+            "  int const i   = 1;\n"
+            "  int *     j   = 2;\n"
+            "  int       big = 10000;\n"
+            "\n"
+            "  unsigned oneTwoThree = 123;\n"
+            "  int      oneTwo      = 12;\n"
+            "  method();\n"
+            "  float k  = 2;\n"
+            "  int   ll = 10000;\n"
+            "}",
+            format("void SomeFunction(int parameter= 0) {\n"
+                   " int const  i= 1;\n"
+                   "  int *j=2;\n"
+                   " int big  =  10000;\n"
+                   "\n"
+                   "unsigned oneTwoThree  =123;\n"
+                   "int oneTwo = 12;\n"
+                   "  method();\n"
+                   "float k= 2;\n"
+                   "int ll=10000;\n"
+                   "}",
+                   Alignment));
+  Alignment.AlignConsecutiveAssignments = false;
+  Alignment.AlignEscapedNewlinesLeft = true;
+  verifyFormat("#define A              \\\n"
+               "  int       aaaa = 12; \\\n"
+               "  float     b = 23;    \\\n"
+               "  const int ccc = 234; \\\n"
+               "  unsigned  dddddddddd = 2345;",
+               Alignment);
+  Alignment.AlignEscapedNewlinesLeft = false;
+  Alignment.ColumnLimit = 30;
+  verifyFormat("#define A                    \\\n"
+               "  int       aaaa = 12;       \\\n"
+               "  float     b = 23;          \\\n"
+               "  const int ccc = 234;       \\\n"
+               "  int       dddddddddd = 2345;",
+               Alignment);
+  Alignment.ColumnLimit = 80;
+  verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
+               "k = 4, int l = 5,\n"
+               "                  int m = 6) {\n"
+               "  const int j = 10;\n"
+               "  otherThing = 1;\n"
+               "}",
+               Alignment);
+  verifyFormat("void SomeFunction(int parameter = 0) {\n"
+               "  int const i = 1;\n"
+               "  int *     j = 2;\n"
+               "  int       big = 10000;\n"
+               "}",
+               Alignment);
+  verifyFormat("class C {\n"
+               "public:\n"
+               "  int          i = 1;\n"
+               "  virtual void f() = 0;\n"
+               "};",
+               Alignment);
+  verifyFormat("float i = 1;\n"
+               "if (SomeType t = getSomething()) {\n"
+               "}\n"
+               "const unsigned j = 2;\n"
+               "int            big = 10000;",
+               Alignment);
+  verifyFormat("float j = 7;\n"
+               "for (int k = 0; k < N; ++k) {\n"
+               "}\n"
+               "unsigned j = 2;\n"
+               "int      big = 10000;\n"
+               "}",
+               Alignment);
+  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  verifyFormat("float              i = 1;\n"
+               "LooooooooooongType loooooooooooooooooooooongVariable\n"
+               "    = someLooooooooooooooooongFunction();\n"
+               "int j = 2;",
+               Alignment);
+  Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
+  verifyFormat("int                i = 1;\n"
+               "LooooooooooongType loooooooooooooooooooooongVariable =\n"
+               "    someLooooooooooooooooongFunction();\n"
+               "int j = 2;",
+               Alignment);
+
+  Alignment.AlignConsecutiveAssignments = true;
+  verifyFormat("auto lambda = []() {\n"
+               "  auto  ii = 0;\n"
+               "  float j  = 0;\n"
+               "  return 0;\n"
+               "};\n"
+               "int   i  = 0;\n"
+               "float i2 = 0;\n"
+               "auto  v  = type{\n"
+               "    i = 1,   //\n"
+               "    (i = 2), //\n"
+               "    i = 3    //\n"
+               "};",
+               Alignment);
+  Alignment.AlignConsecutiveAssignments = false;
+
+  verifyFormat(
+      "int      i = 1;\n"
+      "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
+      "                          loooooooooooooooooooooongParameterB);\n"
+      "int      j = 2;",
+      Alignment);
+
+  // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
+  // We expect declarations and assignments to align, as long as it doesn't
+  // exceed the column limit, starting a new alignment sequence whenever it
+  // happens.
+  Alignment.AlignConsecutiveAssignments = true;
+  Alignment.ColumnLimit = 30;
+  verifyFormat("float    ii              = 1;\n"
+               "unsigned j               = 2;\n"
+               "int someVerylongVariable = 1;\n"
+               "AnotherLongType  ll = 123456;\n"
+               "VeryVeryLongType k  = 2;\n"
+               "int              myvar = 1;",
+               Alignment);
+  Alignment.ColumnLimit = 80;
+  Alignment.AlignConsecutiveAssignments = false;
+
+  verifyFormat(
+      "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
+      "          typename LongType, typename B>\n"
+      "auto foo() {}\n",
+      Alignment);
+  verifyFormat("float a, b = 1;\n"
+               "int   c = 2;\n"
+               "int   dd = 3;\n",
+               Alignment);
+  verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
+               "float b[1][] = {{3.f}};\n",
+               Alignment);
+  Alignment.AlignConsecutiveAssignments = true;
+  verifyFormat("float a, b = 1;\n"
+               "int   c  = 2;\n"
+               "int   dd = 3;\n",
+               Alignment);
+  verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
+               "float b[1][] = {{3.f}};\n",
+               Alignment);
+  Alignment.AlignConsecutiveAssignments = false;
+
+  Alignment.ColumnLimit = 30;
+  Alignment.BinPackParameters = false;
+  verifyFormat("void foo(float     a,\n"
+               "         float     b,\n"
+               "         int       c,\n"
+               "         uint32_t *d) {\n"
+               "  int *  e = 0;\n"
+               "  float  f = 0;\n"
+               "  double g = 0;\n"
+               "}\n"
+               "void bar(ino_t     a,\n"
+               "         int       b,\n"
+               "         uint32_t *c,\n"
+               "         bool      d) {}\n",
+               Alignment);
+  Alignment.BinPackParameters = true;
+  Alignment.ColumnLimit = 80;
+}
+
+TEST_F(FormatTest, LinuxBraceBreaking) {
+  FormatStyle LinuxBraceStyle = getLLVMStyle();
+  LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
+  verifyFormat("namespace a\n"
+               "{\n"
+               "class A\n"
+               "{\n"
+               "  void f()\n"
+               "  {\n"
+               "    if (true) {\n"
+               "      a();\n"
+               "      b();\n"
+               "    } else {\n"
+               "      a();\n"
+               "    }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "};\n"
+               "struct B {\n"
+               "  int x;\n"
+               "};\n"
+               "}\n",
+               LinuxBraceStyle);
+  verifyFormat("enum X {\n"
+               "  Y = 0,\n"
+               "}\n",
+               LinuxBraceStyle);
+  verifyFormat("struct S {\n"
+               "  int Type;\n"
+               "  union {\n"
+               "    int x;\n"
+               "    double y;\n"
+               "  } Value;\n"
+               "  class C\n"
+               "  {\n"
+               "    MyFavoriteType Value;\n"
+               "  } Class;\n"
+               "}\n",
+               LinuxBraceStyle);
+}
+
+TEST_F(FormatTest, MozillaBraceBreaking) {
+  FormatStyle MozillaBraceStyle = getLLVMStyle();
+  MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
+  MozillaBraceStyle.FixNamespaceComments = false;
+  verifyFormat("namespace a {\n"
+               "class A\n"
+               "{\n"
+               "  void f()\n"
+               "  {\n"
+               "    if (true) {\n"
+               "      a();\n"
+               "      b();\n"
+               "    }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "};\n"
+               "enum E\n"
+               "{\n"
+               "  A,\n"
+               "  // foo\n"
+               "  B,\n"
+               "  C\n"
+               "};\n"
+               "struct B\n"
+               "{\n"
+               "  int x;\n"
+               "};\n"
+               "}\n",
+               MozillaBraceStyle);
+  verifyFormat("struct S\n"
+               "{\n"
+               "  int Type;\n"
+               "  union\n"
+               "  {\n"
+               "    int x;\n"
+               "    double y;\n"
+               "  } Value;\n"
+               "  class C\n"
+               "  {\n"
+               "    MyFavoriteType Value;\n"
+               "  } Class;\n"
+               "}\n",
+               MozillaBraceStyle);
+}
+
+TEST_F(FormatTest, StroustrupBraceBreaking) {
+  FormatStyle StroustrupBraceStyle = getLLVMStyle();
+  StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
+  verifyFormat("namespace a {\n"
+               "class A {\n"
+               "  void f()\n"
+               "  {\n"
+               "    if (true) {\n"
+               "      a();\n"
+               "      b();\n"
+               "    }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "};\n"
+               "struct B {\n"
+               "  int x;\n"
+               "};\n"
+               "} // namespace a\n",
+               StroustrupBraceStyle);
+
+  verifyFormat("void foo()\n"
+               "{\n"
+               "  if (a) {\n"
+               "    a();\n"
+               "  }\n"
+               "  else {\n"
+               "    b();\n"
+               "  }\n"
+               "}\n",
+               StroustrupBraceStyle);
+
+  verifyFormat("#ifdef _DEBUG\n"
+               "int foo(int i = 0)\n"
+               "#else\n"
+               "int foo(int i = 5)\n"
+               "#endif\n"
+               "{\n"
+               "  return i;\n"
+               "}",
+               StroustrupBraceStyle);
+
+  verifyFormat("void foo() {}\n"
+               "void bar()\n"
+               "#ifdef _DEBUG\n"
+               "{\n"
+               "  foo();\n"
+               "}\n"
+               "#else\n"
+               "{\n"
+               "}\n"
+               "#endif",
+               StroustrupBraceStyle);
+
+  verifyFormat("void foobar() { int i = 5; }\n"
+               "#ifdef _DEBUG\n"
+               "void bar() {}\n"
+               "#else\n"
+               "void bar() { foobar(); }\n"
+               "#endif",
+               StroustrupBraceStyle);
+}
+
+TEST_F(FormatTest, AllmanBraceBreaking) {
+  FormatStyle AllmanBraceStyle = getLLVMStyle();
+  AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
+  verifyFormat("namespace a\n"
+               "{\n"
+               "class A\n"
+               "{\n"
+               "  void f()\n"
+               "  {\n"
+               "    if (true)\n"
+               "    {\n"
+               "      a();\n"
+               "      b();\n"
+               "    }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "};\n"
+               "struct B\n"
+               "{\n"
+               "  int x;\n"
+               "};\n"
+               "}",
+               AllmanBraceStyle);
+
+  verifyFormat("void f()\n"
+               "{\n"
+               "  if (true)\n"
+               "  {\n"
+               "    a();\n"
+               "  }\n"
+               "  else if (false)\n"
+               "  {\n"
+               "    b();\n"
+               "  }\n"
+               "  else\n"
+               "  {\n"
+               "    c();\n"
+               "  }\n"
+               "}\n",
+               AllmanBraceStyle);
+
+  verifyFormat("void f()\n"
+               "{\n"
+               "  for (int i = 0; i < 10; ++i)\n"
+               "  {\n"
+               "    a();\n"
+               "  }\n"
+               "  while (false)\n"
+               "  {\n"
+               "    b();\n"
+               "  }\n"
+               "  do\n"
+               "  {\n"
+               "    c();\n"
+               "  } while (false)\n"
+               "}\n",
+               AllmanBraceStyle);
+
+  verifyFormat("void f(int a)\n"
+               "{\n"
+               "  switch (a)\n"
+               "  {\n"
+               "  case 0:\n"
+               "    break;\n"
+               "  case 1:\n"
+               "  {\n"
+               "    break;\n"
+               "  }\n"
+               "  case 2:\n"
+               "  {\n"
+               "  }\n"
+               "  break;\n"
+               "  default:\n"
+               "    break;\n"
+               "  }\n"
+               "}\n",
+               AllmanBraceStyle);
+
+  verifyFormat("enum X\n"
+               "{\n"
+               "  Y = 0,\n"
+               "}\n",
+               AllmanBraceStyle);
+  verifyFormat("enum X\n"
+               "{\n"
+               "  Y = 0\n"
+               "}\n",
+               AllmanBraceStyle);
+
+  verifyFormat("@interface BSApplicationController ()\n"
+               "{\n"
+               "@private\n"
+               "  id _extraIvar;\n"
+               "}\n"
+               "@end\n",
+               AllmanBraceStyle);
+
+  verifyFormat("#ifdef _DEBUG\n"
+               "int foo(int i = 0)\n"
+               "#else\n"
+               "int foo(int i = 5)\n"
+               "#endif\n"
+               "{\n"
+               "  return i;\n"
+               "}",
+               AllmanBraceStyle);
+
+  verifyFormat("void foo() {}\n"
+               "void bar()\n"
+               "#ifdef _DEBUG\n"
+               "{\n"
+               "  foo();\n"
+               "}\n"
+               "#else\n"
+               "{\n"
+               "}\n"
+               "#endif",
+               AllmanBraceStyle);
+
+  verifyFormat("void foobar() { int i = 5; }\n"
+               "#ifdef _DEBUG\n"
+               "void bar() {}\n"
+               "#else\n"
+               "void bar() { foobar(); }\n"
+               "#endif",
+               AllmanBraceStyle);
+
+  // This shouldn't affect ObjC blocks..
+  verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
+               "  // ...\n"
+               "  int i;\n"
+               "}];",
+               AllmanBraceStyle);
+  verifyFormat("void (^block)(void) = ^{\n"
+               "  // ...\n"
+               "  int i;\n"
+               "};",
+               AllmanBraceStyle);
+  // .. or dict literals.
+  verifyFormat("void f()\n"
+               "{\n"
+               "  [object someMethod:@{ @\"a\" : @\"b\" }];\n"
+               "}",
+               AllmanBraceStyle);
+  verifyFormat("int f()\n"
+               "{ // comment\n"
+               "  return 42;\n"
+               "}",
+               AllmanBraceStyle);
+
+  AllmanBraceStyle.ColumnLimit = 19;
+  verifyFormat("void f() { int i; }", AllmanBraceStyle);
+  AllmanBraceStyle.ColumnLimit = 18;
+  verifyFormat("void f()\n"
+               "{\n"
+               "  int i;\n"
+               "}",
+               AllmanBraceStyle);
+  AllmanBraceStyle.ColumnLimit = 80;
+
+  FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
+  BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true;
+  BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
+  verifyFormat("void f(bool b)\n"
+               "{\n"
+               "  if (b)\n"
+               "  {\n"
+               "    return;\n"
+               "  }\n"
+               "}\n",
+               BreakBeforeBraceShortIfs);
+  verifyFormat("void f(bool b)\n"
+               "{\n"
+               "  if (b) return;\n"
+               "}\n",
+               BreakBeforeBraceShortIfs);
+  verifyFormat("void f(bool b)\n"
+               "{\n"
+               "  while (b)\n"
+               "  {\n"
+               "    return;\n"
+               "  }\n"
+               "}\n",
+               BreakBeforeBraceShortIfs);
+}
+
+TEST_F(FormatTest, GNUBraceBreaking) {
+  FormatStyle GNUBraceStyle = getLLVMStyle();
+  GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
+  verifyFormat("namespace a\n"
+               "{\n"
+               "class A\n"
+               "{\n"
+               "  void f()\n"
+               "  {\n"
+               "    int a;\n"
+               "    {\n"
+               "      int b;\n"
+               "    }\n"
+               "    if (true)\n"
+               "      {\n"
+               "        a();\n"
+               "        b();\n"
+               "      }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "}\n"
+               "}",
+               GNUBraceStyle);
+
+  verifyFormat("void f()\n"
+               "{\n"
+               "  if (true)\n"
+               "    {\n"
+               "      a();\n"
+               "    }\n"
+               "  else if (false)\n"
+               "    {\n"
+               "      b();\n"
+               "    }\n"
+               "  else\n"
+               "    {\n"
+               "      c();\n"
+               "    }\n"
+               "}\n",
+               GNUBraceStyle);
+
+  verifyFormat("void f()\n"
+               "{\n"
+               "  for (int i = 0; i < 10; ++i)\n"
+               "    {\n"
+               "      a();\n"
+               "    }\n"
+               "  while (false)\n"
+               "    {\n"
+               "      b();\n"
+               "    }\n"
+               "  do\n"
+               "    {\n"
+               "      c();\n"
+               "    }\n"
+               "  while (false);\n"
+               "}\n",
+               GNUBraceStyle);
+
+  verifyFormat("void f(int a)\n"
+               "{\n"
+               "  switch (a)\n"
+               "    {\n"
+               "    case 0:\n"
+               "      break;\n"
+               "    case 1:\n"
+               "      {\n"
+               "        break;\n"
+               "      }\n"
+               "    case 2:\n"
+               "      {\n"
+               "      }\n"
+               "      break;\n"
+               "    default:\n"
+               "      break;\n"
+               "    }\n"
+               "}\n",
+               GNUBraceStyle);
+
+  verifyFormat("enum X\n"
+               "{\n"
+               "  Y = 0,\n"
+               "}\n",
+               GNUBraceStyle);
+
+  verifyFormat("@interface BSApplicationController ()\n"
+               "{\n"
+               "@private\n"
+               "  id _extraIvar;\n"
+               "}\n"
+               "@end\n",
+               GNUBraceStyle);
+
+  verifyFormat("#ifdef _DEBUG\n"
+               "int foo(int i = 0)\n"
+               "#else\n"
+               "int foo(int i = 5)\n"
+               "#endif\n"
+               "{\n"
+               "  return i;\n"
+               "}",
+               GNUBraceStyle);
+
+  verifyFormat("void foo() {}\n"
+               "void bar()\n"
+               "#ifdef _DEBUG\n"
+               "{\n"
+               "  foo();\n"
+               "}\n"
+               "#else\n"
+               "{\n"
+               "}\n"
+               "#endif",
+               GNUBraceStyle);
+
+  verifyFormat("void foobar() { int i = 5; }\n"
+               "#ifdef _DEBUG\n"
+               "void bar() {}\n"
+               "#else\n"
+               "void bar() { foobar(); }\n"
+               "#endif",
+               GNUBraceStyle);
+}
+
+TEST_F(FormatTest, WebKitBraceBreaking) {
+  FormatStyle WebKitBraceStyle = getLLVMStyle();
+  WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
+  WebKitBraceStyle.FixNamespaceComments = false;
+  verifyFormat("namespace a {\n"
+               "class A {\n"
+               "  void f()\n"
+               "  {\n"
+               "    if (true) {\n"
+               "      a();\n"
+               "      b();\n"
+               "    }\n"
+               "  }\n"
+               "  void g() { return; }\n"
+               "};\n"
+               "enum E {\n"
+               "  A,\n"
+               "  // foo\n"
+               "  B,\n"
+               "  C\n"
+               "};\n"
+               "struct B {\n"
+               "  int x;\n"
+               "};\n"
+               "}\n",
+               WebKitBraceStyle);
+  verifyFormat("struct S {\n"
+               "  int Type;\n"
+               "  union {\n"
+               "    int x;\n"
+               "    double y;\n"
+               "  } Value;\n"
+               "  class C {\n"
+               "    MyFavoriteType Value;\n"
+               "  } Class;\n"
+               "};\n",
+               WebKitBraceStyle);
+}
+
+TEST_F(FormatTest, CatchExceptionReferenceBinding) {
+  verifyFormat("void f() {\n"
+               "  try {\n"
+               "  } catch (const Exception &e) {\n"
+               "  }\n"
+               "}\n",
+               getLLVMStyle());
+}
+
+TEST_F(FormatTest, UnderstandsPragmas) {
+  verifyFormat("#pragma omp reduction(| : var)");
+  verifyFormat("#pragma omp reduction(+ : var)");
+
+  EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
+            "(including parentheses).",
+            format("#pragma    mark   Any non-hyphenated or hyphenated string "
+                   "(including parentheses)."));
+}
+
+TEST_F(FormatTest, UnderstandPragmaOption) {
+  verifyFormat("#pragma option -C -A");
+
+  EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
+}
+
+#define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
+  for (size_t i = 1; i < Styles.size(); ++i)                                   \
+  EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \
+                                  << " differs from Style #0"
+
+TEST_F(FormatTest, GetsPredefinedStyleByName) {
+  SmallVector<FormatStyle, 3> Styles;
+  Styles.resize(3);
+
+  Styles[0] = getLLVMStyle();
+  EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
+  EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles[0] = getGoogleStyle();
+  EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
+  EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
+  EXPECT_TRUE(
+      getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
+  EXPECT_TRUE(
+      getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
+  EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
+  EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles[0] = getMozillaStyle();
+  EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
+  EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles[0] = getWebKitStyle();
+  EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
+  EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles[0] = getGNUStyle();
+  EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
+  EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
+}
+
+TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
+  SmallVector<FormatStyle, 8> Styles;
+  Styles.resize(2);
+
+  Styles[0] = getGoogleStyle();
+  Styles[1] = getLLVMStyle();
+  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+
+  Styles.resize(5);
+  Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
+  Styles[1] = getLLVMStyle();
+  Styles[1].Language = FormatStyle::LK_JavaScript;
+  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
+
+  Styles[2] = getLLVMStyle();
+  Styles[2].Language = FormatStyle::LK_JavaScript;
+  EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
+                                  "BasedOnStyle: Google",
+                                  &Styles[2])
+                   .value());
+
+  Styles[3] = getLLVMStyle();
+  Styles[3].Language = FormatStyle::LK_JavaScript;
+  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
+                                  "Language: JavaScript",
+                                  &Styles[3])
+                   .value());
+
+  Styles[4] = getLLVMStyle();
+  Styles[4].Language = FormatStyle::LK_JavaScript;
+  EXPECT_EQ(0, parseConfiguration("---\n"
+                                  "BasedOnStyle: LLVM\n"
+                                  "IndentWidth: 123\n"
+                                  "---\n"
+                                  "BasedOnStyle: Google\n"
+                                  "Language: JavaScript",
+                                  &Styles[4])
+                   .value());
+  EXPECT_ALL_STYLES_EQUAL(Styles);
+}
+
+#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
+  Style.FIELD = false;                                                         \
+  EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
+  EXPECT_TRUE(Style.FIELD);                                                    \
+  EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
+  EXPECT_FALSE(Style.FIELD);
+
+#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
+
+#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
+  Style.STRUCT.FIELD = false;                                                  \
+  EXPECT_EQ(0,                                                                 \
+            parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
+                .value());                                                     \
+  EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
+  EXPECT_EQ(0,                                                                 \
+            parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
+                .value());                                                     \
+  EXPECT_FALSE(Style.STRUCT.FIELD);
+
+#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
+  CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
+
+#define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
+  EXPECT_NE(VALUE, Style.FIELD);                                               \
+  EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
+  EXPECT_EQ(VALUE, Style.FIELD)
+
+TEST_F(FormatTest, ParsesConfigurationBools) {
+  FormatStyle Style = {};
+  Style.Language = FormatStyle::LK_Cpp;
+  CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft);
+  CHECK_PARSE_BOOL(AlignOperands);
+  CHECK_PARSE_BOOL(AlignTrailingComments);
+  CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
+  CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
+  CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
+  CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine);
+  CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
+  CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine);
+  CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
+  CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations);
+  CHECK_PARSE_BOOL(BinPackArguments);
+  CHECK_PARSE_BOOL(BinPackParameters);
+  CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
+  CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
+  CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma);
+  CHECK_PARSE_BOOL(BreakStringLiterals);
+  CHECK_PARSE_BOOL(BreakBeforeInheritanceComma)
+  CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
+  CHECK_PARSE_BOOL(DerivePointerAlignment);
+  CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
+  CHECK_PARSE_BOOL(DisableFormat);
+  CHECK_PARSE_BOOL(IndentCaseLabels);
+  CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
+  CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
+  CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
+  CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
+  CHECK_PARSE_BOOL(Cpp11BracedListStyle);
+  CHECK_PARSE_BOOL(ReflowComments);
+  CHECK_PARSE_BOOL(SortIncludes);
+  CHECK_PARSE_BOOL(SpacesInParentheses);
+  CHECK_PARSE_BOOL(SpacesInSquareBrackets);
+  CHECK_PARSE_BOOL(SpacesInAngles);
+  CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
+  CHECK_PARSE_BOOL(SpacesInContainerLiterals);
+  CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
+  CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
+  CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
+  CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
+
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
+  CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
+}
+
+#undef CHECK_PARSE_BOOL
+
+TEST_F(FormatTest, ParsesConfiguration) {
+  FormatStyle Style = {};
+  Style.Language = FormatStyle::LK_Cpp;
+  CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
+  CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
+              ConstructorInitializerIndentWidth, 1234u);
+  CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
+  CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
+  CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
+  CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
+              PenaltyBreakBeforeFirstCallParameter, 1234u);
+  CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
+  CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
+              PenaltyReturnTypeOnItsOwnLine, 1234u);
+  CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
+              SpacesBeforeTrailingComments, 1234u);
+  CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
+  CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
+  CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
+
+  Style.PointerAlignment = FormatStyle::PAS_Middle;
+  CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
+              FormatStyle::PAS_Left);
+  CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
+              FormatStyle::PAS_Right);
+  CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
+              FormatStyle::PAS_Middle);
+  // For backward compatibility:
+  CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
+              FormatStyle::PAS_Left);
+  CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
+              FormatStyle::PAS_Right);
+  CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
+              FormatStyle::PAS_Middle);
+
+  Style.Standard = FormatStyle::LS_Auto;
+  CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
+  CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11);
+  CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
+  CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
+  CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
+
+  Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+  CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
+              BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
+  CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
+              FormatStyle::BOS_None);
+  CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
+              FormatStyle::BOS_All);
+  // For backward compatibility:
+  CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
+              FormatStyle::BOS_None);
+  CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
+              FormatStyle::BOS_All);
+
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+  CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
+              FormatStyle::BAS_Align);
+  CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
+              FormatStyle::BAS_DontAlign);
+  CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
+              FormatStyle::BAS_AlwaysBreak);
+  // For backward compatibility:
+  CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
+              FormatStyle::BAS_DontAlign);
+  CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
+              FormatStyle::BAS_Align);
+
+  Style.UseTab = FormatStyle::UT_ForIndentation;
+  CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
+  CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
+  CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
+  CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
+              FormatStyle::UT_ForContinuationAndIndentation);
+  // For backward compatibility:
+  CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
+  CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
+
+  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
+  CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
+              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
+  CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
+              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
+  CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
+              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
+  CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
+              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
+  // For backward compatibility:
+  CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
+              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
+  CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
+              AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
+
+  Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
+  CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
+              FormatStyle::SBPO_Never);
+  CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
+              FormatStyle::SBPO_Always);
+  CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
+              FormatStyle::SBPO_ControlStatements);
+  // For backward compatibility:
+  CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
+              FormatStyle::SBPO_Never);
+  CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
+              FormatStyle::SBPO_ControlStatements);
+
+  Style.ColumnLimit = 123;
+  FormatStyle BaseStyle = getLLVMStyle();
+  CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
+  CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
+
+  Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
+  CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
+              FormatStyle::BS_Attach);
+  CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
+              FormatStyle::BS_Linux);
+  CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
+              FormatStyle::BS_Mozilla);
+  CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
+              FormatStyle::BS_Stroustrup);
+  CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
+              FormatStyle::BS_Allman);
+  CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
+  CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
+              FormatStyle::BS_WebKit);
+  CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
+              FormatStyle::BS_Custom);
+
+  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
+  CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
+              FormatStyle::RTBS_None);
+  CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
+              FormatStyle::RTBS_All);
+  CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
+              AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
+  CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
+              AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
+  CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
+              AlwaysBreakAfterReturnType,
+              FormatStyle::RTBS_TopLevelDefinitions);
+
+  Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
+  CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
+              AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
+  CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
+              AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
+  CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
+              AlwaysBreakAfterDefinitionReturnType,
+              FormatStyle::DRTBS_TopLevel);
+
+  Style.NamespaceIndentation = FormatStyle::NI_All;
+  CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
+              FormatStyle::NI_None);
+  CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
+              FormatStyle::NI_Inner);
+  CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
+              FormatStyle::NI_All);
+
+  Style.PPDirectiveIndentation = FormatStyle::PPDI_All;
+  CHECK_PARSE("PPDirectiveIndentation: None", PPDirectiveIndentation,
+              FormatStyle::PPDI_None);
+  CHECK_PARSE("PPDirectiveIndentation: Inner", PPDirectiveIndentation,
+              FormatStyle::PPDI_Inner);
+  CHECK_PARSE("PPDirectiveIndentation: All", PPDirectiveIndentation,
+              FormatStyle::PPDI_All);
+
+  Style.PPDirectiveIndentationStyle = FormatStyle::PPDIS_BeforeHash;
+  CHECK_PARSE("PPDirectiveIndentationStyle: AfterHash",
+              PPDirectiveIndentationStyle, FormatStyle::PPDIS_AfterHash);
+  CHECK_PARSE("PPDirectiveIndentationStyle: BeforeHash",
+              PPDirectiveIndentationStyle, FormatStyle::PPDIS_BeforeHash);
+
+  // FIXME: This is required because parsing a configuration simply overwrites
+  // the first N elements of the list instead of resetting it.
+  Style.ForEachMacros.clear();
+  std::vector<std::string> BoostForeach;
+  BoostForeach.push_back("BOOST_FOREACH");
+  CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
+  std::vector<std::string> BoostAndQForeach;
+  BoostAndQForeach.push_back("BOOST_FOREACH");
+  BoostAndQForeach.push_back("Q_FOREACH");
+  CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
+              BoostAndQForeach);
+
+  Style.IncludeCategories.clear();
+  std::vector<FormatStyle::IncludeCategory> ExpectedCategories = {{"abc/.*", 2},
+                                                                  {".*", 1}};
+  CHECK_PARSE("IncludeCategories:\n"
+              "  - Regex: abc/.*\n"
+              "    Priority: 2\n"
+              "  - Regex: .*\n"
+              "    Priority: 1",
+              IncludeCategories, ExpectedCategories);
+  CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeIsMainRegex, "abc$");
+}
+
+TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
+  FormatStyle Style = {};
+  Style.Language = FormatStyle::LK_Cpp;
+  CHECK_PARSE("Language: Cpp\n"
+              "IndentWidth: 12",
+              IndentWidth, 12u);
+  EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
+                               "IndentWidth: 34",
+                               &Style),
+            ParseError::Unsuitable);
+  EXPECT_EQ(12u, Style.IndentWidth);
+  CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
+  EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
+
+  Style.Language = FormatStyle::LK_JavaScript;
+  CHECK_PARSE("Language: JavaScript\n"
+              "IndentWidth: 12",
+              IndentWidth, 12u);
+  CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
+  EXPECT_EQ(parseConfiguration("Language: Cpp\n"
+                               "IndentWidth: 34",
+                               &Style),
+            ParseError::Unsuitable);
+  EXPECT_EQ(23u, Style.IndentWidth);
+  CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
+  EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
+
+  CHECK_PARSE("BasedOnStyle: LLVM\n"
+              "IndentWidth: 67",
+              IndentWidth, 67u);
+
+  CHECK_PARSE("---\n"
+              "Language: JavaScript\n"
+              "IndentWidth: 12\n"
+              "---\n"
+              "Language: Cpp\n"
+              "IndentWidth: 34\n"
+              "...\n",
+              IndentWidth, 12u);
+
+  Style.Language = FormatStyle::LK_Cpp;
+  CHECK_PARSE("---\n"
+              "Language: JavaScript\n"
+              "IndentWidth: 12\n"
+              "---\n"
+              "Language: Cpp\n"
+              "IndentWidth: 34\n"
+              "...\n",
+              IndentWidth, 34u);
+  CHECK_PARSE("---\n"
+              "IndentWidth: 78\n"
+              "---\n"
+              "Language: JavaScript\n"
+              "IndentWidth: 56\n"
+              "...\n",
+              IndentWidth, 78u);
+
+  Style.ColumnLimit = 123;
+  Style.IndentWidth = 234;
+  Style.BreakBeforeBraces = FormatStyle::BS_Linux;
+  Style.TabWidth = 345;
+  EXPECT_FALSE(parseConfiguration("---\n"
+                                  "IndentWidth: 456\n"
+                                  "BreakBeforeBraces: Allman\n"
+                                  "---\n"
+                                  "Language: JavaScript\n"
+                                  "IndentWidth: 111\n"
+                                  "TabWidth: 111\n"
+                                  "---\n"
+                                  "Language: Cpp\n"
+                                  "BreakBeforeBraces: Stroustrup\n"
+                                  "TabWidth: 789\n"
+                                  "...\n",
+                                  &Style));
+  EXPECT_EQ(123u, Style.ColumnLimit);
+  EXPECT_EQ(456u, Style.IndentWidth);
+  EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
+  EXPECT_EQ(789u, Style.TabWidth);
+
+  EXPECT_EQ(parseConfiguration("---\n"
+                               "Language: JavaScript\n"
+                               "IndentWidth: 56\n"
+                               "---\n"
+                               "IndentWidth: 78\n"
+                               "...\n",
+                               &Style),
+            ParseError::Error);
+  EXPECT_EQ(parseConfiguration("---\n"
+                               "Language: JavaScript\n"
+                               "IndentWidth: 56\n"
+                               "---\n"
+                               "Language: JavaScript\n"
+                               "IndentWidth: 78\n"
+                               "...\n",
+                               &Style),
+            ParseError::Error);
+
+  EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
+}
+
+#undef CHECK_PARSE
+
+TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
+  FormatStyle Style = {};
+  Style.Language = FormatStyle::LK_JavaScript;
+  Style.BreakBeforeTernaryOperators = true;
+  EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
+  EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
+
+  Style.BreakBeforeTernaryOperators = true;
+  EXPECT_EQ(0, parseConfiguration("---\n"
+                                  "BasedOnStyle: Google\n"
+                                  "---\n"
+                                  "Language: JavaScript\n"
+                                  "IndentWidth: 76\n"
+                                  "...\n",
+                                  &Style)
+                   .value());
+  EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
+  EXPECT_EQ(76u, Style.IndentWidth);
+  EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
+}
+
+TEST_F(FormatTest, ConfigurationRoundTripTest) {
+  FormatStyle Style = getLLVMStyle();
+  std::string YAML = configurationAsText(Style);
+  FormatStyle ParsedStyle = {};
+  ParsedStyle.Language = FormatStyle::LK_Cpp;
+  EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
+  EXPECT_EQ(Style, ParsedStyle);
+}
+
+TEST_F(FormatTest, WorksFor8bitEncodings) {
+  EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
+            "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
+            "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
+            "\"\xef\xee\xf0\xf3...\"",
+            format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
+                   "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
+                   "\xef\xee\xf0\xf3...\"",
+                   getLLVMStyleWithColumns(12)));
+}
+
+TEST_F(FormatTest, HandlesUTF8BOM) {
+  EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
+  EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
+            format("\xef\xbb\xbf#include <iostream>"));
+  EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
+            format("\xef\xbb\xbf\n#include <iostream>"));
+}
+
+// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
+#if !defined(_MSC_VER)
+
+TEST_F(FormatTest, CountsUTF8CharactersProperly) {
+  verifyFormat("\"Однажды в студёную зимнюю пору...\"",
+               getLLVMStyleWithColumns(35));
+  verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
+               getLLVMStyleWithColumns(31));
+  verifyFormat("// Однажды в студёную зимнюю пору...",
+               getLLVMStyleWithColumns(36));
+  verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
+  verifyFormat("/* Однажды в студёную зимнюю пору... */",
+               getLLVMStyleWithColumns(39));
+  verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
+               getLLVMStyleWithColumns(35));
+}
+
+TEST_F(FormatTest, SplitsUTF8Strings) {
+  // Non-printable characters' width is currently considered to be the length in
+  // bytes in UTF8. The characters can be displayed in very different manner
+  // (zero-width, single width with a substitution glyph, expanded to their code
+  // (e.g. "<8d>"), so there's no single correct way to handle them.
+  EXPECT_EQ("\"aaaaÄ\"\n"
+            "\"\xc2\x8d\";",
+            format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
+  EXPECT_EQ("\"aaaaaaaÄ\"\n"
+            "\"\xc2\x8d\";",
+            format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
+  EXPECT_EQ("\"Однажды, в \"\n"
+            "\"студёную \"\n"
+            "\"зимнюю \"\n"
+            "\"пору,\"",
+            format("\"Однажды, в студёную зимнюю пору,\"",
+                   getLLVMStyleWithColumns(13)));
+  EXPECT_EQ(
+      "\"一 二 三 \"\n"
+      "\"四 五六 \"\n"
+      "\"七 八 九 \"\n"
+      "\"十\"",
+      format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
+  EXPECT_EQ("\"一\t二 \"\n"
+            "\"\t三 \"\n"
+            "\"四 五\t六 \"\n"
+            "\"\t七 \"\n"
+            "\"八九十\tqq\"",
+            format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
+                   getLLVMStyleWithColumns(11)));
+
+  // UTF8 character in an escape sequence.
+  EXPECT_EQ("\"aaaaaa\"\n"
+            "\"\\\xC2\x8D\"",
+            format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
+}
+
+TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
+  EXPECT_EQ("const char *sssss =\n"
+            "    \"一二三四五六七八\\\n"
+            " 九 十\";",
+            format("const char *sssss = \"一二三四五六七八\\\n"
+                   " 九 十\";",
+                   getLLVMStyleWithColumns(30)));
+}
+
+TEST_F(FormatTest, SplitsUTF8LineComments) {
+  EXPECT_EQ("// aaaaÄ\xc2\x8d",
+            format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
+  EXPECT_EQ("// Я из лесу\n"
+            "// вышел; был\n"
+            "// сильный\n"
+            "// мороз.",
+            format("// Я из лесу вышел; был сильный мороз.",
+                   getLLVMStyleWithColumns(13)));
+  EXPECT_EQ("// 一二三\n"
+            "// 四五六七\n"
+            "// 八  九\n"
+            "// 十",
+            format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
+}
+
+TEST_F(FormatTest, SplitsUTF8BlockComments) {
+  EXPECT_EQ("/* Гляжу,\n"
+            " * поднимается\n"
+            " * медленно в\n"
+            " * гору\n"
+            " * Лошадка,\n"
+            " * везущая\n"
+            " * хворосту\n"
+            " * воз. */",
+            format("/* Гляжу, поднимается медленно в гору\n"
+                   " * Лошадка, везущая хворосту воз. */",
+                   getLLVMStyleWithColumns(13)));
+  EXPECT_EQ(
+      "/* 一二三\n"
+      " * 四五六七\n"
+      " * 八  九\n"
+      " * 十  */",
+      format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
+  EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
+            " * 𝕓𝕪𝕥𝕖\n"
+            " * 𝖀𝕿𝕱-𝟠 */",
+            format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
+}
+
+#endif // _MSC_VER
+
+TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
+  FormatStyle Style = getLLVMStyle();
+
+  Style.ConstructorInitializerIndentWidth = 4;
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+      "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
+      Style);
+
+  Style.ConstructorInitializerIndentWidth = 2;
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+      "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
+      Style);
+
+  Style.ConstructorInitializerIndentWidth = 0;
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
+      "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
+      Style);
+  Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+  verifyFormat(
+      "SomeLongTemplateVariableName<\n"
+      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
+      Style);
+  verifyFormat(
+      "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
+      "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+      Style);
+}
+
+TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
+  FormatStyle Style = getLLVMStyle();
+  Style.BreakConstructorInitializersBeforeComma = true;
+  Style.ConstructorInitializerIndentWidth = 4;
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a)\n"
+               "    , b(b)\n"
+               "    , c(c) {}",
+               Style);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a) {}",
+               Style);
+
+  Style.ColumnLimit = 0;
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a) {}",
+               Style);
+  verifyFormat("SomeClass::Constructor() noexcept\n"
+               "    : a(a) {}",
+               Style);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a)\n"
+               "    , b(b)\n"
+               "    , c(c) {}",
+               Style);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a) {\n"
+               "  foo();\n"
+               "  bar();\n"
+               "}",
+               Style);
+
+  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a)\n"
+               "    , b(b)\n"
+               "    , c(c) {\n}",
+               Style);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a) {\n}",
+               Style);
+
+  Style.ColumnLimit = 80;
+  Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
+  Style.ConstructorInitializerIndentWidth = 2;
+  verifyFormat("SomeClass::Constructor()\n"
+               "  : a(a)\n"
+               "  , b(b)\n"
+               "  , c(c) {}",
+               Style);
+
+  Style.ConstructorInitializerIndentWidth = 0;
+  verifyFormat("SomeClass::Constructor()\n"
+               ": a(a)\n"
+               ", b(b)\n"
+               ", c(c) {}",
+               Style);
+
+  Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
+  Style.ConstructorInitializerIndentWidth = 4;
+  verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
+  verifyFormat(
+      "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
+      Style);
+  verifyFormat(
+      "SomeClass::Constructor()\n"
+      "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
+      Style);
+  Style.ConstructorInitializerIndentWidth = 4;
+  Style.ColumnLimit = 60;
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : aaaaaaaa(aaaaaaaa)\n"
+               "    , aaaaaaaa(aaaaaaaa)\n"
+               "    , aaaaaaaa(aaaaaaaa) {}",
+               Style);
+}
+
+TEST_F(FormatTest, Destructors) {
+  verifyFormat("void F(int &i) { i.~int(); }");
+  verifyFormat("void F(int &i) { i->~int(); }");
+}
+
+TEST_F(FormatTest, FormatsWithWebKitStyle) {
+  FormatStyle Style = getWebKitStyle();
+
+  // Don't indent in outer namespaces.
+  verifyFormat("namespace outer {\n"
+               "int i;\n"
+               "namespace inner {\n"
+               "    int i;\n"
+               "} // namespace inner\n"
+               "} // namespace outer\n"
+               "namespace other_outer {\n"
+               "int i;\n"
+               "}",
+               Style);
+
+  // Don't indent case labels.
+  verifyFormat("switch (variable) {\n"
+               "case 1:\n"
+               "case 2:\n"
+               "    doSomething();\n"
+               "    break;\n"
+               "default:\n"
+               "    ++variable;\n"
+               "}",
+               Style);
+
+  // Wrap before binary operators.
+  EXPECT_EQ("void f()\n"
+            "{\n"
+            "    if (aaaaaaaaaaaaaaaa\n"
+            "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
+            "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
+            "        return;\n"
+            "}",
+            format("void f() {\n"
+                   "if (aaaaaaaaaaaaaaaa\n"
+                   "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
+                   "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
+                   "return;\n"
+                   "}",
+                   Style));
+
+  // Allow functions on a single line.
+  verifyFormat("void f() { return; }", Style);
+
+  // Constructor initializers are formatted one per line with the "," on the
+  // new line.
+  verifyFormat("Constructor()\n"
+               "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+               "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
+               "          aaaaaaaaaaaaaa)\n"
+               "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
+               "{\n"
+               "}",
+               Style);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a)\n"
+               "{\n"
+               "}",
+               Style);
+  EXPECT_EQ("SomeClass::Constructor()\n"
+            "    : a(a)\n"
+            "{\n"
+            "}",
+            format("SomeClass::Constructor():a(a){}", Style));
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a)\n"
+               "    , b(b)\n"
+               "    , c(c)\n"
+               "{\n"
+               "}",
+               Style);
+  verifyFormat("SomeClass::Constructor()\n"
+               "    : a(a)\n"
+               "{\n"
+               "    foo();\n"
+               "    bar();\n"
+               "}",
+               Style);
+
+  // Access specifiers should be aligned left.
+  verifyFormat("class C {\n"
+               "public:\n"
+               "    int i;\n"
+               "};",
+               Style);
+
+  // Do not align comments.
+  verifyFormat("int a; // Do not\n"
+               "double b; // align comments.",
+               Style);
+
+  // Do not align operands.
+  EXPECT_EQ("ASSERT(aaaa\n"
+            "    || bbbb);",
+            format("ASSERT ( aaaa\n||bbbb);", Style));
+
+  // Accept input's line breaks.
+  EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
+            "    || bbbbbbbbbbbbbbb) {\n"
+            "    i++;\n"
+            "}",
+            format("if (aaaaaaaaaaaaaaa\n"
+                   "|| bbbbbbbbbbbbbbb) { i++; }",
+                   Style));
+  EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
+            "    i++;\n"
+            "}",
+            format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
+
+  // Don't automatically break all macro definitions (llvm.org/PR17842).
+  verifyFormat("#define aNumber 10", Style);
+  // However, generally keep the line breaks that the user authored.
+  EXPECT_EQ("#define aNumber \\\n"
+            "    10",
+            format("#define aNumber \\\n"
+                   " 10",
+                   Style));
+
+  // Keep empty and one-element array literals on a single line.
+  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
+            "                                  copyItems:YES];",
+            format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
+                   "copyItems:YES];",
+                   Style));
+  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
+            "                                  copyItems:YES];",
+            format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
+                   "             copyItems:YES];",
+                   Style));
+  // FIXME: This does not seem right, there should be more indentation before
+  // the array literal's entries. Nested blocks have the same problem.
+  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
+            "    @\"a\",\n"
+            "    @\"a\"\n"
+            "]\n"
+            "                                  copyItems:YES];",
+            format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
+                   "     @\"a\",\n"
+                   "     @\"a\"\n"
+                   "     ]\n"
+                   "       copyItems:YES];",
+                   Style));
+  EXPECT_EQ(
+      "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
+      "                                  copyItems:YES];",
+      format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
+             "   copyItems:YES];",
+             Style));
+
+  verifyFormat("[self.a b:c c:d];", Style);
+  EXPECT_EQ("[self.a b:c\n"
+            "        c:d];",
+            format("[self.a b:c\n"
+                   "c:d];",
+                   Style));
+}
+
+TEST_F(FormatTest, FormatsLambdas) {
+  verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
+  verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
+  verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
+  verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
+  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
+  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
+  verifyFormat("int x = f(*+[] {});");
+  verifyFormat("void f() {\n"
+               "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
+               "}\n");
+  verifyFormat("void f() {\n"
+               "  other(x.begin(), //\n"
+               "        x.end(),   //\n"
+               "        [&](int, int) { return 1; });\n"
+               "}\n");
+  verifyFormat("SomeFunction([]() { // A cool function...\n"
+               "  return 43;\n"
+               "});");
+  EXPECT_EQ("SomeFunction([]() {\n"
+            "#define A a\n"
+            "  return 43;\n"
+            "});",
+            format("SomeFunction([](){\n"
+                   "#define A a\n"
+                   "return 43;\n"
+                   "});"));
+  verifyFormat("void f() {\n"
+               "  SomeFunction([](decltype(x), A *a) {});\n"
+               "}");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    [](const aaaaaaaaaa &a) { return a; });");
+  verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
+               "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
+               "});");
+  verifyFormat("Constructor()\n"
+               "    : Field([] { // comment\n"
+               "        int i;\n"
+               "      }) {}");
+  verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
+               "  return some_parameter.size();\n"
+               "};");
+  verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
+               "    [](const string &s) { return s; };");
+  verifyFormat("int i = aaaaaa ? 1 //\n"
+               "               : [] {\n"
+               "                   return 2; //\n"
+               "                 }();");
+  verifyFormat("llvm::errs() << \"number of twos is \"\n"
+               "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
+               "                  return x == 2; // force break\n"
+               "                });");
+  verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+               "    [=](int iiiiiiiiiiii) {\n"
+               "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
+               "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
+               "    });",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("SomeFunction({[&] {\n"
+               "                // comment\n"
+               "              },\n"
+               "              [&] {\n"
+               "                // comment\n"
+               "              }});");
+  verifyFormat("SomeFunction({[&] {\n"
+               "  // comment\n"
+               "}});");
+  verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
+               "                             [&]() { return true; },\n"
+               "                         aaaaa aaaaaaaaa);");
+
+  // Lambdas with return types.
+  verifyFormat("int c = []() -> int { return 2; }();\n");
+  verifyFormat("int c = []() -> int * { return 2; }();\n");
+  verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
+  verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
+  verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
+  verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
+  verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
+  verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
+  verifyFormat("[a, a]() -> a<1> {};");
+  verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
+               "                   int j) -> int {\n"
+               "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
+               "};");
+  verifyFormat(
+      "aaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
+      "      return aaaaaaaaaaaaaaaaa;\n"
+      "    });",
+      getLLVMStyleWithColumns(70));
+  verifyFormat("[]() //\n"
+               "    -> int {\n"
+               "  return 1; //\n"
+               "};");
+
+  // Multiple lambdas in the same parentheses change indentation rules.
+  verifyFormat("SomeFunction(\n"
+               "    []() {\n"
+               "      int i = 42;\n"
+               "      return i;\n"
+               "    },\n"
+               "    []() {\n"
+               "      int j = 43;\n"
+               "      return j;\n"
+               "    });");
+
+  // More complex introducers.
+  verifyFormat("return [i, args...] {};");
+
+  // Not lambdas.
+  verifyFormat("constexpr char hello[]{\"hello\"};");
+  verifyFormat("double &operator[](int i) { return 0; }\n"
+               "int i;");
+  verifyFormat("std::unique_ptr<int[]> foo() {}");
+  verifyFormat("int i = a[a][a]->f();");
+  verifyFormat("int i = (*b)[a]->f();");
+
+  // Other corner cases.
+  verifyFormat("void f() {\n"
+               "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
+               "      );\n"
+               "}");
+
+  // Lambdas created through weird macros.
+  verifyFormat("void f() {\n"
+               "  MACRO((const AA &a) { return 1; });\n"
+               "  MACRO((AA &a) { return 1; });\n"
+               "}");
+
+  verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
+               "      doo_dah();\n"
+               "      doo_dah();\n"
+               "    })) {\n"
+               "}");
+  verifyFormat("auto lambda = []() {\n"
+               "  int a = 2\n"
+               "#if A\n"
+               "          + 2\n"
+               "#endif\n"
+               "      ;\n"
+               "};");
+
+  // Lambdas with complex multiline introducers.
+  verifyFormat(
+      "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+      "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
+      "        -> ::std::unordered_set<\n"
+      "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
+      "      //\n"
+      "    });");
+}
+
+TEST_F(FormatTest, FormatsBlocks) {
+  FormatStyle ShortBlocks = getLLVMStyle();
+  ShortBlocks.AllowShortBlocksOnASingleLine = true;
+  verifyFormat("int (^Block)(int, int);", ShortBlocks);
+  verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
+
+  verifyFormat("foo(^{ bar(); });", ShortBlocks);
+  verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
+  verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
+
+  verifyFormat("[operation setCompletionBlock:^{\n"
+               "  [self onOperationDone];\n"
+               "}];");
+  verifyFormat("int i = {[operation setCompletionBlock:^{\n"
+               "  [self onOperationDone];\n"
+               "}]};");
+  verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
+               "  f();\n"
+               "}];");
+  verifyFormat("int a = [operation block:^int(int *i) {\n"
+               "  return 1;\n"
+               "}];");
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "                      aaa:^int(int *a) {\n"
+               "                        return 1;\n"
+               "                      }\n"
+               "                      bbb:f(a * bbbbbbbb)];");
+
+  verifyFormat("[operation setCompletionBlock:^{\n"
+               "  [self.delegate newDataAvailable];\n"
+               "}];",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
+               "  NSString *path = [self sessionFilePath];\n"
+               "  if (path) {\n"
+               "    // ...\n"
+               "  }\n"
+               "});");
+  verifyFormat("[[SessionService sharedService]\n"
+               "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
+               "      if (window) {\n"
+               "        [self windowDidLoad:window];\n"
+               "      } else {\n"
+               "        [self errorLoadingWindow];\n"
+               "      }\n"
+               "    }];");
+  verifyFormat("void (^largeBlock)(void) = ^{\n"
+               "  // ...\n"
+               "};\n",
+               getLLVMStyleWithColumns(40));
+  verifyFormat("[[SessionService sharedService]\n"
+               "    loadWindowWithCompletionBlock: //\n"
+               "        ^(SessionWindow *window) {\n"
+               "          if (window) {\n"
+               "            [self windowDidLoad:window];\n"
+               "          } else {\n"
+               "            [self errorLoadingWindow];\n"
+               "          }\n"
+               "        }];",
+               getLLVMStyleWithColumns(60));
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "    firstBlock:^(Foo *a) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }\n"
+               "    secondBlock:^(Bar *b) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }\n"
+               "    thirdBlock:^Foo(Bar *b) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }];");
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "               firstBlock:-1\n"
+               "              secondBlock:^(Bar *b) {\n"
+               "                // ...\n"
+               "                int i;\n"
+               "              }];");
+
+  verifyFormat("f(^{\n"
+               "  @autoreleasepool {\n"
+               "    if (a) {\n"
+               "      g();\n"
+               "    }\n"
+               "  }\n"
+               "});");
+  verifyFormat("Block b = ^int *(A *a, B *b) {}");
+  verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
+               "};");
+
+  FormatStyle FourIndent = getLLVMStyle();
+  FourIndent.ObjCBlockIndentWidth = 4;
+  verifyFormat("[operation setCompletionBlock:^{\n"
+               "    [self onOperationDone];\n"
+               "}];",
+               FourIndent);
+}
+
+TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
+  FormatStyle ZeroColumn = getLLVMStyle();
+  ZeroColumn.ColumnLimit = 0;
+
+  verifyFormat("[[SessionService sharedService] "
+               "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
+               "  if (window) {\n"
+               "    [self windowDidLoad:window];\n"
+               "  } else {\n"
+               "    [self errorLoadingWindow];\n"
+               "  }\n"
+               "}];",
+               ZeroColumn);
+  EXPECT_EQ("[[SessionService sharedService]\n"
+            "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
+            "      if (window) {\n"
+            "        [self windowDidLoad:window];\n"
+            "      } else {\n"
+            "        [self errorLoadingWindow];\n"
+            "      }\n"
+            "    }];",
+            format("[[SessionService sharedService]\n"
+                   "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
+                   "                if (window) {\n"
+                   "    [self windowDidLoad:window];\n"
+                   "  } else {\n"
+                   "    [self errorLoadingWindow];\n"
+                   "  }\n"
+                   "}];",
+                   ZeroColumn));
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "    firstBlock:^(Foo *a) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }\n"
+               "    secondBlock:^(Bar *b) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }\n"
+               "    thirdBlock:^Foo(Bar *b) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }];",
+               ZeroColumn);
+  verifyFormat("f(^{\n"
+               "  @autoreleasepool {\n"
+               "    if (a) {\n"
+               "      g();\n"
+               "    }\n"
+               "  }\n"
+               "});",
+               ZeroColumn);
+  verifyFormat("void (^largeBlock)(void) = ^{\n"
+               "  // ...\n"
+               "};",
+               ZeroColumn);
+
+  ZeroColumn.AllowShortBlocksOnASingleLine = true;
+  EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
+            format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
+  ZeroColumn.AllowShortBlocksOnASingleLine = false;
+  EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
+            "  int i;\n"
+            "};",
+            format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
+}
+
+TEST_F(FormatTest, SupportsCRLF) {
+  EXPECT_EQ("int a;\r\n"
+            "int b;\r\n"
+            "int c;\r\n",
+            format("int a;\r\n"
+                   "  int b;\r\n"
+                   "    int c;\r\n",
+                   getLLVMStyle()));
+  EXPECT_EQ("int a;\r\n"
+            "int b;\r\n"
+            "int c;\r\n",
+            format("int a;\r\n"
+                   "  int b;\n"
+                   "    int c;\r\n",
+                   getLLVMStyle()));
+  EXPECT_EQ("int a;\n"
+            "int b;\n"
+            "int c;\n",
+            format("int a;\r\n"
+                   "  int b;\n"
+                   "    int c;\n",
+                   getLLVMStyle()));
+  EXPECT_EQ("\"aaaaaaa \"\r\n"
+            "\"bbbbbbb\";\r\n",
+            format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
+  EXPECT_EQ("#define A \\\r\n"
+            "  b;      \\\r\n"
+            "  c;      \\\r\n"
+            "  d;\r\n",
+            format("#define A \\\r\n"
+                   "  b; \\\r\n"
+                   "  c; d; \r\n",
+                   getGoogleStyle()));
+
+  EXPECT_EQ("/*\r\n"
+            "multi line block comments\r\n"
+            "should not introduce\r\n"
+            "an extra carriage return\r\n"
+            "*/\r\n",
+            format("/*\r\n"
+                   "multi line block comments\r\n"
+                   "should not introduce\r\n"
+                   "an extra carriage return\r\n"
+                   "*/\r\n"));
+}
+
+TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
+  verifyFormat("MY_CLASS(C) {\n"
+               "  int i;\n"
+               "  int j;\n"
+               "};");
+}
+
+TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
+  FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
+  TwoIndent.ContinuationIndentWidth = 2;
+
+  EXPECT_EQ("int i =\n"
+            "  longFunction(\n"
+            "    arg);",
+            format("int i = longFunction(arg);", TwoIndent));
+
+  FormatStyle SixIndent = getLLVMStyleWithColumns(20);
+  SixIndent.ContinuationIndentWidth = 6;
+
+  EXPECT_EQ("int i =\n"
+            "      longFunction(\n"
+            "            arg);",
+            format("int i = longFunction(arg);", SixIndent));
+}
+
+TEST_F(FormatTest, SpacesInAngles) {
+  FormatStyle Spaces = getLLVMStyle();
+  Spaces.SpacesInAngles = true;
+
+  verifyFormat("static_cast< int >(arg);", Spaces);
+  verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
+  verifyFormat("f< int, float >();", Spaces);
+  verifyFormat("template <> g() {}", Spaces);
+  verifyFormat("template < std::vector< int > > f() {}", Spaces);
+  verifyFormat("std::function< void(int, int) > fct;", Spaces);
+  verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
+               Spaces);
+
+  Spaces.Standard = FormatStyle::LS_Cpp03;
+  Spaces.SpacesInAngles = true;
+  verifyFormat("A< A< int > >();", Spaces);
+
+  Spaces.SpacesInAngles = false;
+  verifyFormat("A<A<int> >();", Spaces);
+
+  Spaces.Standard = FormatStyle::LS_Cpp11;
+  Spaces.SpacesInAngles = true;
+  verifyFormat("A< A< int > >();", Spaces);
+
+  Spaces.SpacesInAngles = false;
+  verifyFormat("A<A<int>>();", Spaces);
+}
+
+TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
+  FormatStyle Style = getLLVMStyle();
+  Style.SpaceAfterTemplateKeyword = false;
+  verifyFormat("template<int> void foo();", Style);
+}
+
+TEST_F(FormatTest, TripleAngleBrackets) {
+  verifyFormat("f<<<1, 1>>>();");
+  verifyFormat("f<<<1, 1, 1, s>>>();");
+  verifyFormat("f<<<a, b, c, d>>>();");
+  EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
+  verifyFormat("f<param><<<1, 1>>>();");
+  verifyFormat("f<1><<<1, 1>>>();");
+  EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+               "aaaaaaaaaaa<<<\n    1, 1>>>();");
+  verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
+               "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
+}
+
+TEST_F(FormatTest, MergeLessLessAtEnd) {
+  verifyFormat("<<");
+  EXPECT_EQ("< < <", format("\\\n<<<"));
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+               "aaallvm::outs() <<");
+  verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+               "aaaallvm::outs()\n    <<");
+}
+
+TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
+  std::string code = "#if A\n"
+                     "#if B\n"
+                     "a.\n"
+                     "#endif\n"
+                     "    a = 1;\n"
+                     "#else\n"
+                     "#endif\n"
+                     "#if C\n"
+                     "#else\n"
+                     "#endif\n";
+  EXPECT_EQ(code, format(code));
+}
+
+TEST_F(FormatTest, HandleConflictMarkers) {
+  // Git/SVN conflict markers.
+  EXPECT_EQ("int a;\n"
+            "void f() {\n"
+            "  callme(some(parameter1,\n"
+            "<<<<<<< text by the vcs\n"
+            "              parameter2),\n"
+            "||||||| text by the vcs\n"
+            "              parameter2),\n"
+            "         parameter3,\n"
+            "======= text by the vcs\n"
+            "              parameter2, parameter3),\n"
+            ">>>>>>> text by the vcs\n"
+            "         otherparameter);\n",
+            format("int a;\n"
+                   "void f() {\n"
+                   "  callme(some(parameter1,\n"
+                   "<<<<<<< text by the vcs\n"
+                   "  parameter2),\n"
+                   "||||||| text by the vcs\n"
+                   "  parameter2),\n"
+                   "  parameter3,\n"
+                   "======= text by the vcs\n"
+                   "  parameter2,\n"
+                   "  parameter3),\n"
+                   ">>>>>>> text by the vcs\n"
+                   "  otherparameter);\n"));
+
+  // Perforce markers.
+  EXPECT_EQ("void f() {\n"
+            "  function(\n"
+            ">>>> text by the vcs\n"
+            "      parameter,\n"
+            "==== text by the vcs\n"
+            "      parameter,\n"
+            "==== text by the vcs\n"
+            "      parameter,\n"
+            "<<<< text by the vcs\n"
+            "      parameter);\n",
+            format("void f() {\n"
+                   "  function(\n"
+                   ">>>> text by the vcs\n"
+                   "  parameter,\n"
+                   "==== text by the vcs\n"
+                   "  parameter,\n"
+                   "==== text by the vcs\n"
+                   "  parameter,\n"
+                   "<<<< text by the vcs\n"
+                   "  parameter);\n"));
+
+  EXPECT_EQ("<<<<<<<\n"
+            "|||||||\n"
+            "=======\n"
+            ">>>>>>>",
+            format("<<<<<<<\n"
+                   "|||||||\n"
+                   "=======\n"
+                   ">>>>>>>"));
+
+  EXPECT_EQ("<<<<<<<\n"
+            "|||||||\n"
+            "int i;\n"
+            "=======\n"
+            ">>>>>>>",
+            format("<<<<<<<\n"
+                   "|||||||\n"
+                   "int i;\n"
+                   "=======\n"
+                   ">>>>>>>"));
+
+  // FIXME: Handle parsing of macros around conflict markers correctly:
+  EXPECT_EQ("#define Macro \\\n"
+            "<<<<<<<\n"
+            "Something \\\n"
+            "|||||||\n"
+            "Else \\\n"
+            "=======\n"
+            "Other \\\n"
+            ">>>>>>>\n"
+            "    End int i;\n",
+            format("#define Macro \\\n"
+                   "<<<<<<<\n"
+                   "  Something \\\n"
+                   "|||||||\n"
+                   "  Else \\\n"
+                   "=======\n"
+                   "  Other \\\n"
+                   ">>>>>>>\n"
+                   "  End\n"
+                   "int i;\n"));
+}
+
+TEST_F(FormatTest, DisableRegions) {
+  EXPECT_EQ("int i;\n"
+            "// clang-format off\n"
+            "  int j;\n"
+            "// clang-format on\n"
+            "int k;",
+            format(" int  i;\n"
+                   "   // clang-format off\n"
+                   "  int j;\n"
+                   " // clang-format on\n"
+                   "   int   k;"));
+  EXPECT_EQ("int i;\n"
+            "/* clang-format off */\n"
+            "  int j;\n"
+            "/* clang-format on */\n"
+            "int k;",
+            format(" int  i;\n"
+                   "   /* clang-format off */\n"
+                   "  int j;\n"
+                   " /* clang-format on */\n"
+                   "   int   k;"));
+
+  // Don't reflow comments within disabled regions.
+  EXPECT_EQ(
+      "// clang-format off\n"
+      "// long long long long long long line\n"
+      "/* clang-format on */\n"
+      "/* long long long\n"
+      " * long long long\n"
+      " * line */\n"
+      "int i;\n"
+      "/* clang-format off */\n"
+      "/* long long long long long long line */\n",
+      format("// clang-format off\n"
+             "// long long long long long long line\n"
+             "/* clang-format on */\n"
+             "/* long long long long long long line */\n"
+             "int i;\n"
+             "/* clang-format off */\n"
+             "/* long long long long long long line */\n",
+             getLLVMStyleWithColumns(20)));
+}
+
+TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
+  format("? ) =");
+  verifyNoCrash("#define a\\\n /**/}");
+}
+
+TEST_F(FormatTest, FormatsTableGenCode) {
+  FormatStyle Style = getLLVMStyle();
+  Style.Language = FormatStyle::LK_TableGen;
+  verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
+}
+
+TEST_F(FormatTest, ArrayOfTemplates) {
+  EXPECT_EQ("auto a = new unique_ptr<int>[10];",
+            format("auto a = new unique_ptr<int > [ 10];"));
+
+  FormatStyle Spaces = getLLVMStyle();
+  Spaces.SpacesInSquareBrackets = true;
+  EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
+            format("auto a = new unique_ptr<int > [10];", Spaces));
+}
+
+TEST_F(FormatTest, ArrayAsTemplateType) {
+  EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
+            format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
+
+  FormatStyle Spaces = getLLVMStyle();
+  Spaces.SpacesInSquareBrackets = true;
+  EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
+            format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
+}
+
+TEST_F(FormatTest, NoSpaceAfterSuper) {
+    verifyFormat("__super::FooBar();");
+}
+
+TEST(FormatStyle, GetStyleOfFile) {
+  vfs::InMemoryFileSystem FS;
+  // Test 1: format file in the same directory.
+  ASSERT_TRUE(
+      FS.addFile("/a/.clang-format", 0,
+                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
+  ASSERT_TRUE(
+      FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
+  auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
+  ASSERT_TRUE((bool)Style1);
+  ASSERT_EQ(*Style1, getLLVMStyle());
+
+  // Test 2.1: fallback to default.
+  ASSERT_TRUE(
+      FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
+  auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
+  ASSERT_TRUE((bool)Style2);
+  ASSERT_EQ(*Style2, getMozillaStyle());
+
+  // Test 2.2: no format on 'none' fallback style.
+  Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
+  ASSERT_TRUE((bool)Style2);
+  ASSERT_EQ(*Style2, getNoStyle());
+
+  // Test 2.3: format if config is found with no based style while fallback is
+  // 'none'.
+  ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
+                         llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
+  Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
+  ASSERT_TRUE((bool)Style2);
+  ASSERT_EQ(*Style2, getLLVMStyle());
+
+  // Test 2.4: format if yaml with no based style, while fallback is 'none'.
+  Style2 = getStyle("{}", "a.h", "none", "", &FS);
+  ASSERT_TRUE((bool)Style2);
+  ASSERT_EQ(*Style2, getLLVMStyle());
+
+  // Test 3: format file in parent directory.
+  ASSERT_TRUE(
+      FS.addFile("/c/.clang-format", 0,
+                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
+  ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
+                         llvm::MemoryBuffer::getMemBuffer("int i;")));
+  auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
+  ASSERT_TRUE((bool)Style3);
+  ASSERT_EQ(*Style3, getGoogleStyle());
+
+  // Test 4: error on invalid fallback style
+  auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
+  ASSERT_FALSE((bool)Style4);
+  llvm::consumeError(Style4.takeError());
+
+  // Test 5: error on invalid yaml on command line
+  auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
+  ASSERT_FALSE((bool)Style5);
+  llvm::consumeError(Style5.takeError());
+
+  // Test 6: error on invalid style
+  auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
+  ASSERT_FALSE((bool)Style6);
+  llvm::consumeError(Style6.takeError());
+
+  // Test 7: found config file, error on parsing it
+  ASSERT_TRUE(
+      FS.addFile("/d/.clang-format", 0,
+                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
+                                                  "InvalidKey: InvalidValue")));
+  ASSERT_TRUE(
+      FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
+  auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
+  ASSERT_FALSE((bool)Style7);
+  llvm::consumeError(Style7.takeError());
+}
+
+TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
+  // Column limit is 20.
+  std::string Code = "Type *a =\n"
+                     "    new Type();\n"
+                     "g(iiiii, 0, jjjjj,\n"
+                     "  0, kkkkk, 0, mm);\n"
+                     "int  bad     = format   ;";
+  std::string Expected = "auto a = new Type();\n"
+                         "g(iiiii, nullptr,\n"
+                         "  jjjjj, nullptr,\n"
+                         "  kkkkk, nullptr,\n"
+                         "  mm);\n"
+                         "int  bad     = format   ;";
+  FileID ID = Context.createInMemoryFile("format.cpp", Code);
+  tooling::Replacements Replaces = toReplacements(
+      {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
+                            "auto "),
+       tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
+                            "nullptr"),
+       tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
+                            "nullptr"),
+       tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
+                            "nullptr")});
+
+  format::FormatStyle Style = format::getLLVMStyle();
+  Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
+  auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
+  EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
+      << llvm::toString(FormattedReplaces.takeError()) << "\n";
+  auto Result = applyAllReplacements(Code, *FormattedReplaces);
+  EXPECT_TRUE(static_cast<bool>(Result));
+  EXPECT_EQ(Expected, *Result);
+}
+
+TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
+  std::string Code = "#include \"a.h\"\n"
+                     "#include \"c.h\"\n"
+                     "\n"
+                     "int main() {\n"
+                     "  return 0;\n"
+                     "}";
+  std::string Expected = "#include \"a.h\"\n"
+                         "#include \"b.h\"\n"
+                         "#include \"c.h\"\n"
+                         "\n"
+                         "int main() {\n"
+                         "  return 0;\n"
+                         "}";
+  FileID ID = Context.createInMemoryFile("fix.cpp", Code);
+  tooling::Replacements Replaces = toReplacements(
+      {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
+                            "#include \"b.h\"\n")});
+
+  format::FormatStyle Style = format::getLLVMStyle();
+  Style.SortIncludes = true;
+  auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
+  EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
+      << llvm::toString(FormattedReplaces.takeError()) << "\n";
+  auto Result = applyAllReplacements(Code, *FormattedReplaces);
+  EXPECT_TRUE(static_cast<bool>(Result));
+  EXPECT_EQ(Expected, *Result);
+}
+
+} // end namespace
+} // end namespace format
+} // end namespace clang