[clang-tidy] Add modernize-concat-nested-namespaces check

[wgml]

Summary

Finds instances of namespaces concatenated using explicit syntax, such as namespace a { namespace b { [...] }} and offers fix to glue it to namespace a::b { [...] }.

Properly handles inline and unnamed namespaces. Also, detects empty blocks in nested namespaces and offers to remove them.

Test with common use cases included.
I ran the check against entire llvm repository. Except for expected nested namespace definitions only available with -std=c++17 or -std=gnu++17 warnings I noticed no issues when the check was performed.

Example:

namespace a { namespace b {
void test();
}}

can become

namespace a::b {
void test();
}

[lebedev.ri]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

73–74 ↗

(On Diff #165642)

It should only get registered in C++17 or newer mode.

[lebedev.ri]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

42–45 ↗

(On Diff #165642)

Use proper casting, isa<>(), dyn_cast<>, so on.

79 ↗

(On Diff #165642)

Here and everywhere - the consts are on the wrong side.

102–108 ↗

(On Diff #165642)

1. This is unrelated to the main check, so it should be in a separate check.
2. This is really fragile i think. What about preprocessor-driven emptiness?

clang-tidy/modernize/ConcatNestedNamespacesCheck.h

29–32 ↗

(On Diff #165642)

This looks like a pessimization.
I think you should just store NamespaceDecl*.

[Eugene.Zelenko]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

37 ↗

(On Diff #165642)

Type is not spelled in declaration, so please don't use auto.

53 ↗

(On Diff #165642)

Type is not spelled in declaration, so please don't use auto.

55 ↗

(On Diff #165642)

Type is not spelled in declaration, so please don't use auto.

docs/ReleaseNotes.rst

96 ↗

(On Diff #165642)

Wrong indentation. See other entries.

docs/clang-tidy/checks/modernize-concat-nested-namespaces.rst

12 ↗

(On Diff #165642)

Please add empty line after.

34 ↗

(On Diff #165642)

Please add empty line after.

[wgml]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

102–108 ↗

(On Diff #165642)

1. It seems to me that if I produce fixit to concat empty namespace (that is, execute the else branch), the fix is not applied as I intended - the namespace gets deleted.

I do not fully understand this behavior and did not manage to find bug in the code. I also checked what will happen if I try replace the entire namespace with namespace {} and it is not getting inserted but simply deleted. On the other hand, I if replace with namespace {;}, I see the expected output. So, either it is really sneaky off-by-one somewhere, or clang does it's own thing.
Truth be told, I added that if branch to handle such behavior explicitly instead of silently deleting namespace.

2. Can you provide an example when it will matter?

[wgml]

Adjusted to review comments.

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

102–108 ↗

(On Diff #165642)

I dropped the "support" for removing. However, empty namespaces are still being removed implicitly, by a fixit applying tool, I believe.

I added entries to the test to make sure preprocessor stuff is never removed.

[wgml]

Fixed typo in documentation.
Refactored a bit of check code to make it more readable.

[wgml]

One last typo.

[alexfh]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

102–108 ↗

(On Diff #165642)

Removal of empty namespaces is intentional. Clang-tidy calls clang::format::cleanupAroundReplacements when applying fixes, which, in particular, removes empty namespaces. See code around clang/lib/Format/Format.cpp:1309. The motivation is that when different checks remove different parts of code inside a namespace and this results in an empty namespace, it's better to remove it. Other cleanups are, for example, removal of commas and the colon in constructor initializer lists.

[wgml]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

102–108 ↗

(On Diff #165642)

That is good to know! Everything looks good to me then.

[aaron.ballman]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

52 ↗

(On Diff #165698)

Can this be rewritten with llvm::for_each() and a Twine so that we don't have to use ostringstream (which is a big hammer for this).

73 ↗

(On Diff #165698)

Diagnostics should not start with a capital letter.

clang-tidy/modernize/ConcatNestedNamespacesCheck.h

29 ↗

(On Diff #165698)

Why 6?

docs/clang-tidy/checks/list.rst

13 ↗

(On Diff #165698)

This is an unrelated change -- feel free to make a separate commit that fixes this (no review needed).

[wgml]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

52 ↗

(On Diff #165698)

The main advantage of stringstream was that it is concise.

I don't think I can effectively use Twine to build a result in a loop. If I'm wrong, correct me, please.

I reworked concatNamespaces to use SmallString with another educated guess of 40 for capacity.

clang-tidy/modernize/ConcatNestedNamespacesCheck.h

29 ↗

(On Diff #165698)

Educated guess. I considered the codebases I usually work with and it seemed a sane value in that context.

docs/clang-tidy/checks/list.rst

13 ↗

(On Diff #165698)

Setup script did that I guess. I reverted the change.

[aaron.ballman]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

31 ↗

(On Diff #166529)

We usually only const-qualify local declarations when they're pointers/references, so you can drop the const here (and in several other places). It's not a hard and fast rule, but the clutter is not useful in such small functions.

50 ↗

(On Diff #166529)

I'm not keen on the trailing return type used here. It's reasonable, but clever in ways we don't use elsewhere.

52 ↗

(On Diff #165698)

The Twine idea I was thinking of is not too far off from what you have with SmallString, but perhaps is too clever:

return std::accumulate(Namespaces.begin(), Namespaces.end(), llvm::Twine(), [](llvm::Twine Ret, const NamespaceDecl *ND) {
  return Ret + "::" + ND->getName();
}).str();

clang-tidy/modernize/ConcatNestedNamespacesCheck.h

29 ↗

(On Diff #165698)

Okay, I can live with that. Thanks!

[wgml]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

31 ↗

(On Diff #166529)

From my perspective, const is a easy way of declaring that my intention is only to name given declaration only for reading and to improve code readability.

50 ↗

(On Diff #166529)

Ok. Wanted to avoid line break and the...

ConcatNestedNamespacesCheck::NamespaceString
ConcatNestedNamespacesCheck::concatNamespaces() {...}

but I'll adjust.

52 ↗

(On Diff #165698)

Yeah, I tried that, but Twine has it's operator= deleted.

[wgml]

Updated signature of concatNamespaces.

[aaron.ballman]

Aside from the local const qualification stuff and some minor wordsmithing of the documentation, this LGTM.

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

31 ↗

(On Diff #166529)

I wasn't making a value judgement about the coding style so much as pointing out that this is novel to the code base and we tend to avoid novel constructs unless there's a good reason to deviate. I don't see a strong justification here, so I'd prefer them to be removed for consistency.

52 ↗

(On Diff #165698)

Ugh, good catch! The current formulation is fine then, thank you!

docs/clang-tidy/checks/modernize-concat-nested-namespaces.rst

6 ↗

(On Diff #166602)

in a form of -> such as

7 ↗

(On Diff #166602)

offers change to syntax -> suggests changing to the more concise syntax

8 ↗

(On Diff #166602)

Inlined -> Inline

[wgml]

Dropped a few consts, updated doc text.

[wgml]

Thanks you all for your participation in the review process. I guess it is done now.
I don't have write access to the repositories, @aaron.ballman, could you apply the patch on my behalf?

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

31 ↗

(On Diff #166529)

Okay then, adjusted.

[JonasToth]

Commited for you.

[grandinj]

Hi

Thanks a lot for this checker - would it be possible to enhance it to also update stuff in associated header files?

Thanks

[wgml]

In D52136#1844384, @grandinj wrote:

Hi

Thanks a lot for this checker - would it be possible to enhance it to also update stuff in associated header files?

Thanks

Check out D61989,

[Abpostelnicu]

clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

88 ↗

(On Diff #166960)

This breaks the usage of this checker in an unified build scenario since the main file for the translation unit will be the unified file.

clang-tools-extra/trunk/clang-tidy/modernize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyModernizeModule
   AvoidBindCheck.cpp
+  ConcatNestedNamespacesCheck.cpp
   DeprecatedHeadersCheck.cpp
   LoopConvertCheck.cpp
   LoopConvertUtils.cpp
   MakeSharedCheck.cpp
   MakeSmartPtrCheck.cpp
   MakeUniqueCheck.cpp
   ModernizeTidyModule.cpp
   PassByValueCheck.cpp

clang-tools-extra/trunk/clang-tidy/modernize/ConcatNestedNamespacesCheck.h

+//===--- ConcatNestedNamespacesCheck.h - clang-tidy--------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_CONCATNESTEDNAMESPACESCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_CONCATNESTEDNAMESPACESCHECK_H
+
+#include "../ClangTidy.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+class ConcatNestedNamespacesCheck : public ClangTidyCheck {
+public:
+  ConcatNestedNamespacesCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  using NamespaceContextVec = llvm::SmallVector<const NamespaceDecl *, 6>;
+  using NamespaceString = llvm::SmallString<40>;
+
+  void reportDiagnostic(const SourceRange &FrontReplacement,
+                        const SourceRange &BackReplacement);
+  NamespaceString concatNamespaces();
+  NamespaceContextVec Namespaces;
+};
+} // namespace modernize
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_CONCATNESTEDNAMESPACESCHECK_H

clang-tools-extra/trunk/clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

+//===--- ConcatNestedNamespacesCheck.cpp - clang-tidy----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ConcatNestedNamespacesCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include <algorithm>
+#include <iterator>
+
+namespace clang {
+namespace tidy {
+namespace modernize {
+
+static bool locationsInSameFile(const SourceManager &Sources,
+                                SourceLocation Loc1, SourceLocation Loc2) {
+  return Loc1.isFileID() && Loc2.isFileID() &&
+         Sources.getFileID(Loc1) == Sources.getFileID(Loc2);
+}
+
+static bool anonymousOrInlineNamespace(const NamespaceDecl &ND) {
+  return ND.isAnonymousNamespace() || ND.isInlineNamespace();
+}
+
+static bool singleNamedNamespaceChild(const NamespaceDecl &ND) {
+  NamespaceDecl::decl_range Decls = ND.decls();
+  if (std::distance(Decls.begin(), Decls.end()) != 1)
+    return false;
+
+  const auto *ChildNamespace = dyn_cast<const NamespaceDecl>(*Decls.begin());
+  return ChildNamespace && !anonymousOrInlineNamespace(*ChildNamespace);
+}
+
+static bool alreadyConcatenated(std::size_t NumCandidates,
+                                const SourceRange &ReplacementRange,
+                                const SourceManager &Sources,
+                                const LangOptions &LangOpts) {
+  CharSourceRange TextRange =
+      Lexer::getAsCharRange(ReplacementRange, Sources, LangOpts);
+  StringRef CurrentNamespacesText =
+      Lexer::getSourceText(TextRange, Sources, LangOpts);
+  return CurrentNamespacesText.count(':') == (NumCandidates - 1) * 2;
+}
+
+ConcatNestedNamespacesCheck::NamespaceString
+ConcatNestedNamespacesCheck::concatNamespaces() {
+  NamespaceString Result("namespace ");
+  Result.append(Namespaces.front()->getName());
+
+  std::for_each(std::next(Namespaces.begin()), Namespaces.end(),
+                [&Result](const NamespaceDecl *ND) {
+                  Result.append("::");
+                  Result.append(ND->getName());
+                });
+
+  return Result;
+}
+
+void ConcatNestedNamespacesCheck::registerMatchers(
+    ast_matchers::MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus17)
+    return;
+
+  Finder->addMatcher(ast_matchers::namespaceDecl().bind("namespace"), this);
+}
+
+void ConcatNestedNamespacesCheck::reportDiagnostic(
+    const SourceRange &FrontReplacement, const SourceRange &BackReplacement) {
+  diag(Namespaces.front()->getBeginLoc(),
+       "nested namespaces can be concatenated", DiagnosticIDs::Warning)
+      << FixItHint::CreateReplacement(FrontReplacement, concatNamespaces())
+      << FixItHint::CreateReplacement(BackReplacement, "}");
+}
+
+void ConcatNestedNamespacesCheck::check(
+    const ast_matchers::MatchFinder::MatchResult &Result) {
+  const NamespaceDecl &ND = *Result.Nodes.getNodeAs<NamespaceDecl>("namespace");
+  const SourceManager &Sources = *Result.SourceManager;
+
+  if (!locationsInSameFile(Sources, ND.getBeginLoc(), ND.getRBraceLoc()))
+    return;
+
+  if (!Sources.isInMainFile(ND.getBeginLoc()))
+    return;
+
+  if (anonymousOrInlineNamespace(ND))
+    return;
+
+  Namespaces.push_back(&ND);
+
+  if (singleNamedNamespaceChild(ND))
+    return;
+
+  SourceRange FrontReplacement(Namespaces.front()->getBeginLoc(),
+                               Namespaces.back()->getLocation());
+  SourceRange BackReplacement(Namespaces.back()->getRBraceLoc(),
+                              Namespaces.front()->getRBraceLoc());
+
+  if (!alreadyConcatenated(Namespaces.size(), FrontReplacement, Sources,
+                           getLangOpts()))
+    reportDiagnostic(FrontReplacement, BackReplacement);
+
+  Namespaces.clear();
+}
+
+} // namespace modernize
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp

 //===--- ModernizeTidyModule.cpp - clang-tidy -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "AvoidBindCheck.h"
+#include "ConcatNestedNamespacesCheck.h"
 #include "DeprecatedHeadersCheck.h"
 #include "LoopConvertCheck.h"
 #include "MakeSharedCheck.h"
 #include "MakeUniqueCheck.h"
 #include "PassByValueCheck.h"
 #include "RawStringLiteralCheck.h"
 #include "RedundantVoidArgCheck.h"
 #include "ReplaceAutoPtrCheck.h"

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class ModernizeModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
+    CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(
+        "modernize-concat-nested-namespaces");
     CheckFactories.registerCheck<DeprecatedHeadersCheck>(
         "modernize-deprecated-headers");
     CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
     CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");
     CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
     CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
     CheckFactories.registerCheck<RawStringLiteralCheck>(
         "modernize-raw-string-literal");

clang-tools-extra/trunk/docs/ReleaseNotes.rst

 - New :doc:`abseil-faster-strsplit-delimiter
   <clang-tidy/checks/abseil-faster-strsplit-delimiter>` check.
 
   Finds instances of ``absl::StrSplit()`` or ``absl::MaxSplits()`` where the
   delimiter is a single character string literal and replaces with a character.
 
 - New :doc:`abseil-no-internal-dependencies
   <clang-tidy/checks/abseil-no-internal-dependencies>` check.
-  
   Gives a warning if code using Abseil depends on internal details.
 
 - New :doc:`abseil-no-namespace
   <clang-tidy/checks/abseil-no-namespace>` check.
 
   Ensures code does not open ``namespace absl`` as that violates Abseil's
   compatibility guidelines.
 
 - New :doc:`abseil-redundant-strcat-calls
   <clang-tidy/checks/abseil-redundant-strcat-calls>` check.
 
   Suggests removal of unnecessary calls to ``absl::StrCat`` when the result is
   being passed to another ``absl::StrCat`` or ``absl::StrAppend``.
 
 - New :doc:`abseil-str-cat-append
   <clang-tidy/checks/abseil-str-cat-append>` check.
 
-  Flags uses of ``absl::StrCat()`` to append to a ``std::string``. Suggests 
+  Flags uses of ``absl::StrCat()`` to append to a ``std::string``. Suggests
   ``absl::StrAppend()`` should be used instead.
 
+- New :doc:`modernize-concat-nested-namespaces
+  <clang-tidy/checks/modernize-concat-nested-namespaces>` check.
+
+  Checks for uses of nested namespaces in the form of
+  ``namespace a { namespace b { ... }}`` and offers change to
+  syntax introduced in C++17 standard: ``namespace a::b { ... }``.
+
 - New :doc:`readability-magic-numbers
   <clang-tidy/checks/readability-magic-numbers>` check.
 
   Detects usage of magic numbers, numbers that are used as literals instead of
   introduced via constants or symbols.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

.. toctree::
    misc-static-assert
    misc-throw-by-value-catch-by-reference
    misc-unconventional-assign-operator
    misc-uniqueptr-reset-release
    misc-unused-alias-decls
    misc-unused-parameters
    misc-unused-using-decls
    modernize-avoid-bind
+   modernize-concat-nested-namespaces
    modernize-deprecated-headers
    modernize-loop-convert
    modernize-make-shared
    modernize-make-unique
    modernize-pass-by-value
    modernize-raw-string-literal
    modernize-redundant-void-arg
    modernize-replace-auto-ptr

clang-tools-extra/trunk/docs/clang-tidy/checks/modernize-concat-nested-namespaces.rst

+.. title:: clang-tidy - modernize-concat-nested-namespaces
+
+modernize-concat-nested-namespaces
+==================================
+
+Checks for use of nested namespaces such as ``namespace a { namespace b { ... } }``
+and suggests changing to the more concise syntax introduced in C++17: ``namespace a::b { ... }``.
+Inline namespaces are not modified.
+
+For example:
+
+.. code-block:: c++
+
+  namespace n1 {
+  namespace n2 {
+  void t();
+  }
+  }
+
+  namespace n3 {
+  namespace n4 {
+  namespace n5 {
+  void t();
+  }
+  }
+  namespace n6 {
+  namespace n7 {
+  void t();
+  }
+  }
+  }
+
+Will be modified to:
+
+.. code-block:: c++
+
+  namespace n1::n2 {
+  void t();
+  }
+
+  namespace n3 {
+  namespace n4::n5 {
+  void t();
+  }
+  namespace n6::n7 {
+  void t();
+  }
+  }
+

clang-tools-extra/trunk/test/clang-tidy/modernize-concat-nested-namespaces.cpp

+// RUN: %check_clang_tidy %s modernize-concat-nested-namespaces %t -- -- -std=c++17
+
+namespace n1 {}
+
+namespace n2 {
+namespace n3 {
+void t();
+}
+namespace n4 {
+void t();
+}
+} // namespace n2
+
+namespace n5 {
+inline namespace n6 {
+void t();
+}
+} // namespace n5
+
+namespace n7 {
+void t();
+
+namespace n8 {
+void t();
+}
+} // namespace n7
+
+namespace n9 {
+namespace n10 {
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n9::n10
+void t();
+} // namespace n10
+} // namespace n9
+// CHECK-FIXES: }
+
+namespace n11 {
+namespace n12 {
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n11::n12
+namespace n13 {
+void t();
+}
+namespace n14 {
+void t();
+}
+} // namespace n12
+} // namespace n11
+// CHECK-FIXES: }
+
+namespace n15 {
+namespace n16 {
+void t();
+}
+
+inline namespace n17 {
+void t();
+}
+
+namespace n18 {
+namespace n19 {
+namespace n20 {
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n18::n19::n20
+void t();
+} // namespace n20
+} // namespace n19
+} // namespace n18
+// CHECK-FIXES: }
+
+namespace n21 {
+void t();
+}
+} // namespace n15
+
+namespace n22 {
+namespace {
+void t();
+}
+} // namespace n22
+
+namespace n23 {
+namespace {
+namespace n24 {
+namespace n25 {
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n24::n25
+void t();
+} // namespace n25
+} // namespace n24
+// CHECK-FIXES: }
+} // namespace
+} // namespace n23
+
+namespace n26::n27 {
+namespace n28 {
+namespace n29::n30 {
+// CHECK-MESSAGES: :[[@LINE-3]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n26::n27::n28::n29::n30
+void t() {}
+} // namespace n29::n30
+} // namespace n28
+} // namespace n26::n27
+// CHECK-FIXES: }
+
+namespace n31 {
+namespace n32 {}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+} // namespace n31
+// CHECK-FIXES-EMPTY
+
+namespace n33 {
+namespace n34 {
+namespace n35 {}
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+} // namespace n34
+// CHECK-FIXES-EMPTY
+namespace n36 {
+void t();
+}
+} // namespace n33
+
+namespace n37::n38 {
+void t();
+}
+
+#define IEXIST
+namespace n39 {
+namespace n40 {
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n39::n40
+#ifdef IEXIST
+void t() {}
+#endif
+} // namespace n40
+} // namespace n39
+// CHECK-FIXES: }
+
+namespace n41 {
+namespace n42 {
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: nested namespaces can be concatenated [modernize-concat-nested-namespaces]
+// CHECK-FIXES: namespace n41::n42
+#ifdef IDONTEXIST
+void t() {}
+#endif
+} // namespace n42
+} // namespace n41
+// CHECK-FIXES: }
+
+int main() {
+  n26::n27::n28::n29::n30::t();
+#ifdef IEXIST
+  n39::n40::t();
+#endif
+
+#ifdef IDONTEXIST
+  n41::n42::t();
+#endif
+
+  return 0;
+}