[clang-format][PR47290] Add ShortNamespaceLines format option

[kuzkry]

Summary

clang-format documentation states that having enabled
FixNamespaceComments one may expect below code:

c++
namespace a {
foo();
}

to be turned into:

c++
namespace a {
foo();
} // namespace a

In reality, no "// namespace a" was added. The problem was too high
value of kShortNamespaceMaxLines, which is used while deciding whether
a namespace is long enough to be formatted.

As with 9163fe2, clang-format idempotence is preserved.

[kuzkry]

This fixes https://bugs.llvm.org/show_bug.cgi?id=47290.

@Jake
I decided I would at least create this pull request so you can decide whether you want it or not.

[kuzkry]

Adjusted tests IncludeFixerTest.cpp after CI failure.

[kuzkry]

Formatted code after CI failure.

[JakeMerdichAMD]

After looking at more of the history (ie, the commit you referenced), I'd definitely be open to something like this, provided that it doesn't affect namespaces that reside completely on one line. Since it was mostly a clang-format limitation and relatively rare, I think we can change the default here, but that's not up to just me (+@MyDeveloperDay), and extra scrutiny is definitely required when changing existing tests.

In any case, can you also add the full diff context? It makes it easier for us to review.

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

426–428

I strongly believe that these ones are not correct. Namespaces that are entirely on one line should never have a trailing comment, even if it has content in it.

A solution would also have to take into account whether future passes would split this onto separate lines (and thus have a different result after re-running clang-format), which was the reason for this limitation in the first place.

[kuzkry]

Thanks @JakeMerdichAMD for your quick feedback.

In any case, can you also add the full diff context? It makes it easier for us to review.

I'll do that starting from the next patch because I'm afraid if I resubmit the longer version of the same patch, your comment would be hidden or considered obsolete as it would refer to an older revision.

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

426–428

You're absolutely right. Btw. do you happen to know which style option controls this behaviour that splits these namespaces onto separate lines?
Anyway, I'm going to look into this in a few days.

[MyDeveloperDay]

I have a hard time when people change tests! just because one person wants them this way doesn't mean everyone will.

I am not sure about others but I'd be ok about seeing this as an option to override the value but not changing the default.

I like to think of unit tests as the "Beyonce Rule", "if you liked it you put a test on it!"... when people come along and say... "All these tests are wrong"... I start thinking... is this subjective or objective?

The flux in llvm alone will be massive

https://github.com/llvm/llvm-project/search?q=namespace+%7B+++%7D&unscoped_q=namespace+%7B+++%7D

This would be a substantially smaller diff if you were adding the option. (option/doc/test...)

Full context diff please too!

clang/lib/Format/NamespaceEndCommentsFixer.cpp

28

I think change this will break the world... why don't we expose this as an option and not change everything!

[kuzkry]

Hey @MyDeveloperDay, thanks for the review.

On the one hand, you're right, it's a breaking change and I dislike it too.
But please, reconsider because on the other hand:
a) adding a new option means increasing our maintenance cost by possibly adding a rarely-used switch (which I also dislike)
b) it's been a part of clang-format documentation since release 5 so we could make clang-format work as expected
c) this patch doesn't have to be applied to already released versions and could be merged with a new major release. I think people can expect certain things to work differently while changing major versions.
d) in general, people care about preserving their git history and they normally don't format all their code blindly. I think the most frequent use case it to format only adjacent parts of code.

So, I'd say both ways have their ups and downs.

@all
Still, so far I've got two change requests from you lot but they are mutually exclusive.
To sum it up, which do you prefer?
a) add a new option (@MyDeveloperDay's approach)
b) change kShortNamespaceMaxLines (my approach) assuming @JakeMerdichAMD's suggestions (non-empty one-line namespaces aren't given the end comment)

[MyDeveloperDay]

Firstly let me say thank you for the patch, and taking the time to listen to the reviewers. Please don't be discouraged by my reply/opinon.

a) adding a new option means increasing our maintenance cost by possibly adding a rarely-used switch (which I also dislike)

I always here people complaining about this...but what is the cost to ALL the users that see formatting changes every release across all the projects that use clang-format. Its potentially massive. I'm not sure the cost is that high for us.

b) it's been a part of clang-format documentation since release 5 so we could make clang-format work as expected

Either the documentation isn't being read/understood/misinterpreted, or perhaps the person who wrote this wanted it like this, to not namespace comment small namespaces. Again who can tell, but in my view the precedent has been set for 6 releases and I'd be uncomfortable about changing it now without a get out clause if we were wrong,

if your view was correct then having an option and setting the default to the new value so people could set it back is a far better solution because it doesn't create an impasse for those that don't like your opinion of what is correct? but I think hundreds of projects will complain they have to change the default. (as many as complain they have to set it in the first place potentially)

c) this patch doesn't have to be applied to already released versions and could be merged with a new major release. I think people can expect certain things to work differently while changing major versions.

If its not good enough for trunk its not good enough for the next release in my view, there is never a good time to land something that causes a lot of flux. remember people massively lag the release number and often jump many version numbers, by which time going back and changing a default will be far too late.

I think people can expect certain things to work differently while changing major versions.

I think certain people expect things to work differently, others, easily an equal number expect it to just work as is, and don't want subjective changes.

d) in general, people care about preserving their git history and they normally don't format all their code blindly. I think the most frequent use case it to format only adjacent parts of code.

We should not make assumptions about what others care about.. IMHO this is not true, I work in an organization where any file that is committed MUST conform fully to clang-format resulting in failed phabricator builds (by design), every time we update clang-format we have to makes some alterations for bug fixes. But this change would likely cause a change in almost every file and the impact and cost would be massive to us alone let alone every project that might use it.

This is also what happens inside LLVM (in some sub-projects) where checking for clang-format status is actually part of what will be done via the build_bots. As soon as you check this in, you'll break LLVM, you need to be prepared for that!

I don't want to discourage you, and my opinion is as subjective as yours. But I'm afraid I won't be able to hit the accept button with the review in this form.

Feel free to reach out to other reviewers, mine is not the only opinion.

Ultimately thank you for the patch I think the idea behind it is a good change, I'd personally just want to give people the option, I see this as no different to the people who wanted Small Functions/If/Else blocks formatted differently if they were considered "Small"

Many thanks @MyDeveloperDay

[kuzkry]

Thanks @MyDeveloperDay, I appreciate your input in this review. You're a good reviewer. :)
Also, I think you've made some good points there and I'm going to turn this review into "non-breaking the world" one. I'll be back in a few days with a new diff.

[MyDeveloperDay]

In D87587#2276462, @kuzkry wrote:

Thanks @MyDeveloperDay, I appreciate your input in this review. You're a good reviewer. :)
Also, I think you've made some good points there and I'm going to turn this review into "non-breaking the world" one. I'll be back in a few days with a new diff.

Thank you for considering that, I'm pretty sure I for one will be happy to approve it in its new form. I think this has merits.

[kuzkry]

As proposed by @MyDeveloperDay, I added MaxUnwrappedLinesForShortNamespace option to control behaviour of FixNamespaceComments. This time I'm providing you with a full diff.
Btw. sorry for taking so long.

EDIT: git clang-format is unhappy but I think it's properly formatted. Please, run it locally to check what I mean.

[MyDeveloperDay]

Thanks for making the changes, this LGTM

[MyDeveloperDay]

clang/docs/ClangFormatStyleOptions.rst

2790

This is quite a mouthful before this lands do you want to consider shortening it?

ShortNamespaceLength ?

I'm not sure non clang-formast developers will know what an UnwrappedLine is?

[curdeius]

clang/docs/ClangFormatStyleOptions.rst

2790

I agree that one needs to wrap its head around to digest this name. I'd vote for what @MyDeveloperDay proposed.

[HazardyKnusperkeks]

clang/docs/ClangFormatStyleOptions.rst

2790

Although I already made some changes inside clang-format and single stepped through some formations, I still can not explain what those UnwrappedLines are.

[curdeius]

clang/docs/ClangFormatStyleOptions.rst

2790

Just found a precedence for this: https://clang.llvm.org/extra/clang-tidy/checks/llvm-namespace-comment.html. This clang-tidy check uses ShortNamespaceLines for the very same thing so maybe we should match?

[kuzkry]

Renamed MaxUnwrappedLinesForShortNamespace to ShortNamespaceLines (thank you @MyDeveloperDay for the idea and @curdeius for mentioning clang-tidy). I haven't changed the description of this option so you might wanna complain on that. Tbh. English isn't my native language so I'll take your tips if you wanna help simplify it.

Luckily formatting is magically fixed and hopefully CI check's gonna be satisfied.

[HazardyKnusperkeks]

Apart from my comments, this looks good to me and I really wonder why it hasn't been pushed. (I would directly use it!)

clang/include/clang/Format/Format.h

3230

Could you sort this one alphabetically?

clang/lib/Format/Format.cpp

619

Dito

1002

Dito

[curdeius]

Please regroup tests and add release notes.

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

1126

This could be tested together with another test.

1129

In general, I think you can merge some test cases to match the current testing "style".

1141

From the tests one could imply that 0 means "never add comments", or "add comments for non empty namespaces". Please add a test with at least one line in the namespace.

1161

You should check that Style.ShortNamespaceLines is 1 here.

[kuzkry]

Rebased to the tip of the main branch, sorted code alphabetically as suggested by @HazardyKnusperkeks and applied almost all fixes proposed by @curdeius (entry in release notes + some changes in unit tests)

[kuzkry]

In D87587#2552232, @HazardyKnusperkeks wrote:

Apart from my comments, this looks good to me and I really wonder why it hasn't been pushed. (I would directly use it!)

I don't know, maybe noone needed this except for us :D

clang/include/clang/Format/Format.h

3230

Oops, I just sed'ed through it when renaming and forgot to sort it. Thx :)

[kuzkry]

In D87587#2552314, @curdeius wrote:

Please regroup tests and add release notes.

Regroup tests - by that I think you meant all your 4 remarks about the tests. So I've done 3/4 :D
Release notes - done

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

1126

I merged it with "OneUnwrappedLine_*" tests

1129

Sorry, I didn't understand what you meant so I skipped this one for now.

1161

My initial idea was to have a separated test that would validate ShortNamespaceLines defaulting to "1". If that test failed, someone would know why and they might think:
"Oh my, I think I broke something, let's see what. Oh, I see the test is called "DefaultsToOneUnwrappedLine" so I probably changed this default". Now, some example test, say "OneUnwrappedLine_AddsEndCommentForLongNamespace", does two things, which is a bit like trying to kill two birds with one stone making it, imho, a bit inferior.

[curdeius]

Almost there. I hope I'm clear this time on what I'd like to see.
Thanks for the release notes update.

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

1162

Nit.

1201–1206

What I meant by "merging the tests together" is just writing:

TEST_F(ShortNamespaceLinesTest,
       MultipleUnwrappedLine) {
  auto Style = getLLVMStyle();
  Style.ShortNamespaceLines = 2u;

  EXPECT_EQ(...);

  EXPECT_EQ(...);
}

This will get rid of duplicated setup (even if small), and, what's more important, show the behaviour with the same style on different cases.

Or even, but I'm not forcing you to do so, having a single test case for all ShortNamespaceLinesTest.* tests. It groups the test for the same feature together.

[kuzkry]

Rebased to the tip of the main branch, merged similar tests (requested by @curdeius)

[kuzkry]

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

1162

Well, instead of using comments or giving it a separate test, I wanted to have a nice self-explanatory name.

[HazardyKnusperkeks]

Although I would put it in one test, this is fine by me.

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

1201–1206

I would even go further and put the 0, 1, and 2 in one function.

[HazardyKnusperkeks]

Is this acceptable to the others? Do you need someone to push it?

[kuzkry]

Do you need someone to push it?

Yes, I need someone to do that. I don't have write permissions. I'm new here.

[curdeius]

LGTM.

[HazardyKnusperkeks]

In D87587#2592605, @kuzkry wrote:

Do you need someone to push it?

Yes, I need someone to do that. I don't have write permissions. I'm new here.

Please state the name and mail for the commit. I will push it for you.

[kuzkry]

In D87587#2592722, @HazardyKnusperkeks wrote:

In D87587#2592605, @kuzkry wrote:

Do you need someone to push it?

Yes, I need someone to do that. I don't have write permissions. I'm new here.

Please state the name and mail for the commit. I will push it for you.

Name: Krystian Kuzniarek
Email: [e-mail]

[kuzkry]

Thank you for delivering it, @HazardyKnusperkeks.

One thing concerns me though. I'm not an author of changes done in clang/docs/ClangFormatStyleOptions.rst in lines 2372, 3069-3073, 3075, 3077, 3082-3086, 3088, 3093-3097, 3099, 3104-3108, and 3110-3111. Perhaps it's just a mistake (something might have slipped through git add). Please let me know.

[HazardyKnusperkeks]

In D87587#2597241, @kuzkry wrote:

Thank you for delivering it, @HazardyKnusperkeks.

One thing concerns me though. I'm not an author of changes done in clang/docs/ClangFormatStyleOptions.rst in lines 2372, 3069-3073, 3075, 3077, 3082-3086, 3088, 3093-3097, 3099, 3104-3108, and 3110-3111. Perhaps it's just a mistake (something might have slipped through git add). Please let me know.

I've just run dump_format_style.py, why the other lines were changed (or not correct before) I don't know, but this is the result of the official script.

If that bothers you I can revert and split it in two commits. But I don't think that's necessary as the real author of those lines is the script, not what's written in the git history.

[kuzkry]

In D87587#2602523, @HazardyKnusperkeks wrote:

In D87587#2597241, @kuzkry wrote:

Thank you for delivering it, @HazardyKnusperkeks.

One thing concerns me though. I'm not an author of changes done in clang/docs/ClangFormatStyleOptions.rst in lines 2372, 3069-3073, 3075, 3077, 3082-3086, 3088, 3093-3097, 3099, 3104-3108, and 3110-3111. Perhaps it's just a mistake (something might have slipped through git add). Please let me know.

I've just run dump_format_style.py, why the other lines were changed (or not correct before) I don't know, but this is the result of the official script.

If that bothers you I can revert and split it in two commits. But I don't think that's necessary as the real author of those lines is the script, not what's written in the git history.

Oh, no need to do that. Thank you for your involvement in this review.

clang/docs/ClangFormatStyleOptions.rst

**ExperimentalAutoDetectBinPacking** (``bool``)
   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.
+  If ``true``, clang-format adds missing namespace end comments for
+  short namespaces and fixes invalid existing ones. Short ones are
+  controlled by "ShortNamespaceLines".
 
   .. code-block:: c++
 
      true:                                  false:
      namespace a {                  vs.     namespace a {
      foo();                                 foo();
+     bar();                                 bar();
      } // 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:
 

 
 **IndentAccessModifiers** (``bool``)
   Specify whether access modifiers should have their own indentation level.
 
   When ``false``, access modifiers are indented (or outdented) relative to
   the record members, respecting the ``AccessModifierOffset``. Record
   members are indented one level below the record.
   When ``true``, access modifiers get their own indentation level. As a
-  consequence, record members are indented 2 levels below the record,
+  consequence, record members are always indented 2 levels below the record,
   regardless of the access modifier presence. Value of the
   ``AccessModifierOffset`` is ignored.
 
   .. code-block:: c++
 
      false:                                 true:
      class C {                      vs.     class C {
        class D {                                class D {
.. code-block:: c++
      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++
.. code-block:: c++
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
 
      true:
      // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
      // information
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
       * information */
 
+**ShortNamespaceLines** (``unsigned``)
+  The maximal number of unwrapped lines that a short namespace spans.
+  Defaults to 1.
+
+  This determines the maximum length of short namespaces by counting
+  unwrapped lines (i.e. containing neither opening nor closing
+  namespace brace) and makes "FixNamespaceComments" omit adding
+  end comments for those.
+
+  .. code-block:: c++
+
+     ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
+     namespace a {                      namespace a {
+       int foo;                           int foo;
+     }                                  } // namespace a
+
+     ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
+     namespace b {                      namespace b {
+       int foo;                           int foo;
+       int bar;                           int bar;
+     } // namespace b                   } // namespace b
+
 **SortIncludes** (``SortIncludesOptions``)
   Controls if and how clang-format will sort ``#includes``.
+  If ``Never``, includes are never sorted.
+  If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
+  insensitive fashion.
+  If ``CaseSensitive``, includes are sorted in an alphabetical or case
+  sensitive fashion.
 
-  Possible Values:
+  Possible values:
 
-  * ``SI_Never`` (in configuration ``Never``)
+  * ``SI_Never`` (in configuration: ``Never``)
     Includes are never sorted.
 
     .. code-block:: c++
 
        #include "B/A.h"
        #include "A/B.h"
        #include "a/b.h"
        #include "A/b.h"
        #include "B/a.h"
 
-  * ``SI_CaseInsensitive`` (in configuration ``CaseInsensitive``)
+  * ``SI_CaseInsensitive`` (in configuration: ``CaseInsensitive``)
     Includes are sorted in an ASCIIbetical or case insensitive fashion.
 
     .. code-block:: c++
 
        #include "A/B.h"
        #include "A/b.h"
        #include "B/A.h"
        #include "B/a.h"
        #include "a/b.h"
 
-  * ``SI_CaseSensitive`` (in configuration ``CaseSensitive``)
+  * ``SI_CaseSensitive`` (in configuration: ``CaseSensitive``)
     Includes are sorted in an alphabetical or case sensitive fashion.
 
     .. code-block:: c++
 
        #include "A/B.h"
        #include "A/b.h"
        #include "a/b.h"
        #include "B/A.h"
        #include "B/a.h"
 
+
+
 **SortJavaStaticImport** (``SortJavaStaticImportOptions``)
   When sorting Java imports, by default static imports are placed before
   non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
   static imports are placed after non-static imports.
 
   Possible values:
 
   * ``SJSIO_Before`` (in configuration: ``Before``)

clang/docs/ReleaseNotes.rst

.. code-block:: c++
     #include "B/a.h"
 
 - ``BasedOnStyle: InheritParentConfig`` allows to use the ``.clang-format`` of
   the parent directories to overwrite only parts of it.
 
 - Option ``IndentAccessModifiers`` has been added to be able to give access
   modifiers their own indentation level inside records.
 
+- Option ``ShortNamespaceLines`` has been added to give better control
+  over ``FixNamespaceComments`` when determining a namespace length.
+
 libclang
 --------
 
 - ...
 
 Static Analyzer
 ---------------
 

clang/include/clang/Format/Format.h

   /// 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;
 
-  /// If ``true``, clang-format adds missing namespace end comments and
-  /// fixes invalid existing ones.
+  /// If ``true``, clang-format adds missing namespace end comments for
+  /// short namespaces and fixes invalid existing ones. Short ones are
+  /// controlled by "ShortNamespaceLines".
   /// \code
   ///    true:                                  false:
   ///    namespace a {                  vs.     namespace a {
   ///    foo();                                 foo();
+  ///    bar();                                 bar();
   ///    } // namespace a                       }
   /// \endcode
   bool FixNamespaceComments;
 
   /// 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:

   ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
   ///    // information
   ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
   ///     * information */
   /// \endcode
   bool ReflowComments;
   // clang-format on
 
+  /// The maximal number of unwrapped lines that a short namespace spans.
+  /// Defaults to 1.
+  ///
+  /// This determines the maximum length of short namespaces by counting
+  /// unwrapped lines (i.e. containing neither opening nor closing
+  /// namespace brace) and makes "FixNamespaceComments" omit adding
+  /// end comments for those.
+  /// \code
+  ///    ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
+  ///    namespace a {                      namespace a {
+  ///      int foo;                           int foo;
+  ///    }                                  } // namespace a
+  ///
+  ///    ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
+  ///    namespace b {                      namespace b {
+  ///      int foo;                           int foo;
+  ///      int bar;                           int bar;
+  ///    } // namespace b                   } // namespace b
+  /// \endcode
+  unsigned ShortNamespaceLines;
+
   /// Include sorting options.
   enum SortIncludesOptions : unsigned char {
     /// Includes are never sorted.
     /// \code
     ///    #include "B/A.h"
     ///    #include "A/B.h"
     ///    #include "a/b.h"
     ///    #include "A/b.h"
return AccessModifierOffset == R.AccessModifierOffset &&
            JavaImportGroups == R.JavaImportGroups &&
            JavaScriptQuotes == R.JavaScriptQuotes &&
            JavaScriptWrapImports == R.JavaScriptWrapImports &&
            KeepEmptyLinesAtTheStartOfBlocks ==
                R.KeepEmptyLinesAtTheStartOfBlocks &&
            MacroBlockBegin == R.MacroBlockBegin &&
            MacroBlockEnd == R.MacroBlockEnd &&
            MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
            NamespaceIndentation == R.NamespaceIndentation &&
            NamespaceMacros == R.NamespaceMacros &&
            ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
            ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
            ObjCBreakBeforeNestedBlockParam ==
                R.ObjCBreakBeforeNestedBlockParam &&
            ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
            ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
            PenaltyBreakAssignment == R.PenaltyBreakAssignment &&
            PenaltyBreakBeforeFirstCallParameter ==
                R.PenaltyBreakBeforeFirstCallParameter &&
            PenaltyBreakComment == R.PenaltyBreakComment &&
            PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
            PenaltyBreakString == R.PenaltyBreakString &&
            PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
            PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
            PenaltyBreakTemplateDeclaration ==
                R.PenaltyBreakTemplateDeclaration &&
            PointerAlignment == R.PointerAlignment &&
            RawStringFormats == R.RawStringFormats &&
+           ShortNamespaceLines == R.ShortNamespaceLines &&
            SortIncludes == R.SortIncludes &&
            SortJavaStaticImport == R.SortJavaStaticImport &&
            SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
            SpaceAfterLogicalNot == R.SpaceAfterLogicalNot &&
            SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
            SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
            SpaceBeforeCaseColon == R.SpaceBeforeCaseColon &&
            SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList &&

clang/lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("JavaImportGroups", Style.JavaImportGroups);
     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("NamespaceMacros", Style.NamespaceMacros);
     IO.mapOptional("ObjCBinPackProtocolList", Style.ObjCBinPackProtocolList);
     IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
     IO.mapOptional("ObjCBreakBeforeNestedBlockParam",
                    Style.ObjCBreakBeforeNestedBlockParam);
     IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
     IO.mapOptional("ObjCSpaceBeforeProtocolList",
                    Style.ObjCSpaceBeforeProtocolList);
static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
     IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
                    Style.PenaltyReturnTypeOnItsOwnLine);
     IO.mapOptional("PenaltyIndentedWhitespace",
                    Style.PenaltyIndentedWhitespace);
     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
     IO.mapOptional("RawStringFormats", Style.RawStringFormats);
     IO.mapOptional("ReflowComments", Style.ReflowComments);
+    IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
     IO.mapOptional("SortIncludes", Style.SortIncludes);
     IO.mapOptional("SortJavaStaticImport", Style.SortJavaStaticImport);
     IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
     IO.mapOptional("SpaceAfterLogicalNot", Style.SpaceAfterLogicalNot);
     IO.mapOptional("SpaceAfterTemplateKeyword",
                    Style.SpaceAfterTemplateKeyword);
     IO.mapOptional("SpaceBeforeAssignmentOperators",
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.IndentRequires = false;
   LLVMStyle.IndentWrappedFunctionNames = false;
   LLVMStyle.IndentWidth = 2;
   LLVMStyle.InsertTrailingCommas = FormatStyle::TCS_None;
   LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
   LLVMStyle.JavaScriptWrapImports = true;
   LLVMStyle.TabWidth = 8;
   LLVMStyle.MaxEmptyLinesToKeep = 1;
   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
   LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
   LLVMStyle.ObjCBlockIndentWidth = 2;
   LLVMStyle.ObjCBreakBeforeNestedBlockParam = true;
   LLVMStyle.ObjCSpaceAfterProperty = false;
   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
+  LLVMStyle.ShortNamespaceLines = 1;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.Standard = FormatStyle::LS_Latest;
   LLVMStyle.UseCRLF = false;
   LLVMStyle.UseTab = FormatStyle::UT_Never;
   LLVMStyle.ReflowComments = true;
   LLVMStyle.SpacesInParentheses = false;
   LLVMStyle.SpacesInSquareBrackets = false;
   LLVMStyle.SpaceInEmptyBlock = false;

clang/lib/Format/NamespaceEndCommentsFixer.cpp

 #include "llvm/Support/Regex.h"
 
 #define DEBUG_TYPE "namespace-end-comments-fixer"
 
 namespace clang {
 namespace format {
 
 namespace {
-// The maximal number of unwrapped lines that a short namespace spans.
-// Short namespaces don't need an end comment.
-static const int kShortNamespaceMaxLines = 1;
-
 // Computes the name of a namespace given the namespace token.
 // Returns "" for anonymous namespace.
 std::string computeName(const FormatToken *NamespaceTok) {
   assert(NamespaceTok &&
          NamespaceTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "expecting a namespace token");
   std::string name = "";
   const FormatToken *Tok = NamespaceTok->getNextNonComment();
   if (NamespaceTok->is(TT_NamespaceMacro)) {
     // Collects all the non-comment tokens between opening parenthesis
     // and closing parenthesis or comma.
     assert(Tok && Tok->is(tok::l_paren) && "expected an opening parenthesis");
if (!EndCommentNextTok && I + 1 < E)
       EndCommentNextTok = AnnotatedLines[I + 1]->First;
     bool AddNewline = EndCommentNextTok &&
                       EndCommentNextTok->NewlinesBefore == 0 &&
                       EndCommentNextTok->isNot(tok::eof);
     const std::string EndCommentText =
         computeEndCommentText(NamespaceName, AddNewline, NamespaceTok,
                               Style.SpacesInLineCommentPrefix.Minimum);
     if (!hasEndComment(EndCommentPrevTok)) {
-      bool isShort = I - StartLineIndex <= kShortNamespaceMaxLines + 1;
+      bool isShort = I - StartLineIndex <= Style.ShortNamespaceLines + 1;
       if (!isShort)
         addEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
     } else if (!validEndComment(EndCommentPrevTok, NamespaceName,
                                 NamespaceTok)) {
       updateEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
     }
     StartLineIndex = SIZE_MAX;
   }
   return {Fixes, 0};
 }
 
 } // namespace format
 } // namespace clang

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

EXPECT_EQ("namespace {\n"
                                     "int j;\n"
                                     "};;"));
 }
 
 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
   EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
   EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
   EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
   EXPECT_EQ("namespace A { a };",
             fixNamespaceEndComments("namespace A { a };"));
 }
 
 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
   EXPECT_EQ("namespace A {\n"
             "int i;\n"
             "}",
             fixNamespaceEndComments("namespace A {\n"
                                     "int i;\n"
                                     "}",
EXPECT_EQ("#ifdef 1\n"
                                     "#elseif\n"
                                     "namespace B {\n"
                                     "#endif\n"
                                     "int i;\n"
                                     "}\n"
                                     "}\n"));
 }
 
-TEST_F(NamespaceEndCommentsFixerTest, AddEndCommentForNamespacesAroundMacros) {
+TEST_F(NamespaceEndCommentsFixerTest, AddsEndCommentForNamespacesAroundMacros) {
   // Conditional blocks around are fine
   EXPECT_EQ("namespace A {\n"
             "#if 1\n"
             "int i;\n"
             "#endif\n"
             "}// namespace A",
             fixNamespaceEndComments("namespace A {\n"
                                     "#if 1\n"
EXPECT_EQ("namespace A {\n"
             "}\n"
             "}\n",
             fixNamespaceEndComments("namespace A {\n"
                                     "class Foo {\n"
                                     "}\n"
                                     "}\n"
                                     "}\n"));
 }
+
+using ShortNamespaceLinesTest = NamespaceEndCommentsFixerTest;
+
+TEST_F(ShortNamespaceLinesTest, ZeroUnwrappedLines) {
+  auto Style = getLLVMStyle();
+  Style.ShortNamespaceLines = 0u;
+
+  EXPECT_EQ("namespace OneLinerNamespace {}\n",
+            fixNamespaceEndComments("namespace OneLinerNamespace {}\n", Style));
+  EXPECT_EQ("namespace ShortNamespace {\n"
+            "}\n",
+            fixNamespaceEndComments("namespace ShortNamespace {\n"
+                                    "}\n",
+                                    Style));
+  EXPECT_EQ("namespace LongNamespace {\n"
+            "int i;\n"
+            "}// namespace LongNamespace\n",
+            fixNamespaceEndComments("namespace LongNamespace {\n"
+                                    "int i;\n"
+                                    "}\n",
+                                    Style));
+}
+
+TEST_F(ShortNamespaceLinesTest, OneUnwrappedLine) {
+  constexpr auto DefaultUnwrappedLines = 1u;
+  auto const Style = getLLVMStyle();
+
+  EXPECT_EQ(DefaultUnwrappedLines, Style.ShortNamespaceLines);
+  EXPECT_EQ("namespace ShortNamespace {\n"
+            "int i;\n"
+            "}\n",
+            fixNamespaceEndComments("namespace ShortNamespace {\n"
+                                    "int i;\n"
+                                    "}\n"));
+  EXPECT_EQ("namespace LongNamespace {\n"
+            "int i;\n"
+            "int j;\n"
+            "}// namespace LongNamespace\n",
+            fixNamespaceEndComments("namespace LongNamespace {\n"
+                                    "int i;\n"
+                                    "int j;\n"
+                                    "}\n"));
+}
+
+TEST_F(ShortNamespaceLinesTest, MultipleUnwrappedLine) {
+  auto Style = getLLVMStyle();
+  Style.ShortNamespaceLines = 2u;
+
+  EXPECT_EQ("namespace ShortNamespace {\n"
+            "int i;\n"
+            "int j;\n"
+            "}\n",
+            fixNamespaceEndComments("namespace ShortNamespace {\n"
+                                    "int i;\n"
+                                    "int j;\n"
+                                    "}\n",
+                                    Style));
+  EXPECT_EQ("namespace LongNamespace {\n"
+            "int i;\n"
+            "int j;\n"
+            "int k;\n"
+            "}// namespace LongNamespace\n",
+            fixNamespaceEndComments("namespace LongNamespace {\n"
+                                    "int i;\n"
+                                    "int j;\n"
+                                    "int k;\n"
+                                    "}\n",
+                                    Style));
+}
 } // end namespace
 } // end namespace format
 } // end namespace clang