[include-fixer] Sort headers after inserting new headers.

[ioeric]

Summary

[include-fixer] Sort headers after inserting new headers.

[ioeric]

• Added compile dependency and fixed nits.

[ioeric]

• Passed Headers into IncludeFixerActionFactory so that we can know which headers are added.

[bkramer]

lgtm

include-fixer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 add_clang_library(clangIncludeFixer
   IncludeFixer.cpp
   InMemorySymbolIndex.cpp
   SymbolIndexManager.cpp
   YamlSymbolIndex.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
+  clangFormat
   clangFrontend
   clangLex
   clangParse
   clangSema
   clangTooling
   clangToolingCore
   findAllSymbols
   )
 
 add_subdirectory(tool)
 add_subdirectory(find-all-symbols)

include-fixer/IncludeFixer.h

 class PCHContainerOperations;
 
 namespace include_fixer {
 
 class IncludeFixerActionFactory : public clang::tooling::ToolAction {
 public:
   /// \param SymbolIndexMgr A source for matching symbols to header files.
   /// \param Replacements Storage for the output of the fixer.
+  /// \param StyleName Fallback style for reformatting.
   /// \param MinimizeIncludePaths whether inserted include paths are optimized.
   IncludeFixerActionFactory(
-      SymbolIndexManager &SymbolIndexMgr,
+      SymbolIndexManager &SymbolIndexMgr, std::set<std::string> &Headers,
       std::vector<clang::tooling::Replacement> &Replacements,
-      bool MinimizeIncludePaths = true);
+      StringRef StyleName, bool MinimizeIncludePaths = true);
+
   ~IncludeFixerActionFactory() override;
 
   bool
   runInvocation(clang::CompilerInvocation *Invocation,
                 clang::FileManager *Files,
                 std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
                 clang::DiagnosticConsumer *Diagnostics) override;
 
 private:
   /// The client to use to find cross-references.
   SymbolIndexManager &SymbolIndexMgr;
 
+  /// Headers to be added.
+  std::set<std::string> &Headers;
+
   /// Replacements are written here.
   std::vector<clang::tooling::Replacement> &Replacements;
 
   /// Whether inserted include paths should be optimized.
   bool MinimizeIncludePaths;
+
+  /// The fallback format style for formatting after insertion if no
+  /// clang-format config file was found.
+  std::string FallbackStyle;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H

include-fixer/IncludeFixer.cpp

 //===-- IncludeFixer.cpp - Include inserter based on sema callbacks -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeFixer.h"
+#include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Sema/ExternalSemaSource.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
private:
   /// The current FileEntry.
   const clang::FileEntry *TrackedFile;
 };
 
 /// Manages the parse, gathers include suggestions.
 class Action : public clang::ASTFrontendAction,
                public clang::ExternalSemaSource {
 public:
-  explicit Action(SymbolIndexManager &SymbolIndexMgr, bool MinimizeIncludePaths)
-      : SymbolIndexMgr(SymbolIndexMgr),
+  explicit Action(SymbolIndexManager &SymbolIndexMgr, StringRef StyleName,
+                  bool MinimizeIncludePaths)
+      : SymbolIndexMgr(SymbolIndexMgr), FallbackStyle(StyleName),
         MinimizeIncludePaths(MinimizeIncludePaths) {}
 
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler,
                     StringRef InFile) override {
     Filename = InFile;
     Compiler.getPreprocessor().addPPCallbacks(
         llvm::make_unique<PreprocessorHooks>(this));
std::string minimizeInclude(StringRef Include,
 
     bool IsSystem;
     std::string Suggestion =
         HeaderSearch.suggestPathToFileForDiagnostics(Entry, &IsSystem);
 
     return IsSystem ? '<' + Suggestion + '>' : '"' + Suggestion + '"';
   }
 
+  /// Insert all headers before the first #include in \p Code and run
+  /// clang-format to sort all headers.
+  /// \return Replacements for inserting and sorting headers.
+  std::vector<clang::tooling::Replacement>
+  CreateReplacementsForHeaders(StringRef Code,
+                               const std::set<std::string> &Headers) {
+    std::set<std::string> ExistingHeaders;
+
+    // Create replacements for new headers.
+    clang::tooling::Replacements Insertions;
+    if (FirstIncludeOffset == -1U) {
+      // FIXME: skip header guards.
+      FirstIncludeOffset = 0;
+      // If there is no existing #include, then insert an empty line after new
+      // header block.
+      if (Code.front() != '\n')
+        Insertions.insert(
+            clang::tooling::Replacement(Filename, FirstIncludeOffset, 0, "\n"));
+    }
+    // Keep inserting new headers before the first header.
+    for (StringRef Header : Headers) {
+      std::string Text = "#include " + Header.str() + "\n";
+      Insertions.insert(
+          clang::tooling::Replacement(Filename, FirstIncludeOffset, 0, Text));
+    }
+    DEBUG(llvm::dbgs() << "Header insertions:\n");
+    for (const auto &R : Insertions) {
+      DEBUG(llvm::dbgs() << R.toString() << "\n");
+    }
+
+    clang::format::FormatStyle Style =
+        clang::format::getStyle("file", Filename, FallbackStyle);
+    clang::tooling::Replacements Replaces =
+        formatReplacements(Code, Insertions, Style);
+    // FIXME: remove this when `clang::tooling::Replacements` is implemented as
+    // `std::vector<clang::tooling::Replacement>`.
+    std::vector<clang::tooling::Replacement> Results;
+    std::copy(Replaces.begin(), Replaces.end(), std::back_inserter(Results));
+    return Results;
+  }
+
   /// Generate replacements for the suggested includes.
   /// \return true if changes will be made, false otherwise.
   bool Rewrite(clang::SourceManager &SourceManager,
                clang::HeaderSearch &HeaderSearch,
-               std::vector<clang::tooling::Replacement> &replacements) {
+               std::set<std::string> &Headers,
+               std::vector<clang::tooling::Replacement> &Replacements) {
     if (Untried.empty())
       return false;
 
     const auto &ToTry = UntriedList.front();
-    std::string ToAdd = "#include " +
-                        minimizeInclude(ToTry, SourceManager, HeaderSearch) +
-                        "\n";
-    DEBUG(llvm::dbgs() << "Adding " << ToAdd << "\n");
+    Headers.insert(minimizeInclude(ToTry, SourceManager, HeaderSearch));
 
-    if (FirstIncludeOffset == -1U)
-      FirstIncludeOffset = 0;
-
-    replacements.push_back(clang::tooling::Replacement(
-        SourceManager, FileBegin.getLocWithOffset(FirstIncludeOffset), 0,
-        ToAdd));
+    StringRef Code = SourceManager.getBufferData(SourceManager.getMainFileID());
+    Replacements = CreateReplacementsForHeaders(Code, Headers);
 
     // We currently abort after the first inserted include. The more
     // includes we have the less safe this becomes due to error recovery
     // changing the results.
     // FIXME: Handle multiple includes at once.
     return true;
   }
 
private:
 
   /// The location of the beginning of the tracked file.
   clang::SourceLocation FileBegin;
 
   /// The offset of the last include in the original source file. This will
   /// be used as the insertion point for new include directives.
   unsigned FirstIncludeOffset = -1U;
 
+  /// The fallback format style for formatting after insertion if there is no
+  /// clang-format config file found.
+  std::string FallbackStyle;
+
   /// Includes we have left to try. A set to unique them and a list to keep
   /// track of the order. We prefer includes that were discovered early to avoid
   /// getting caught in results from error recovery.
   std::set<std::string> Untried;
   std::vector<std::string> UntriedList;
 
   /// Whether we should use the smallest possible include path.
   bool MinimizeIncludePaths = true;
if (!IncludeFile || TrackedFile != SourceFile)
     return;
   EnclosingPass->NextInclude(SourceManager, IncludeFile->getName(), FileName,
                              IsAngled, HashLocation, FileNameRange.getEnd());
 }
 
 } // namespace
 
 IncludeFixerActionFactory::IncludeFixerActionFactory(
-    SymbolIndexManager &SymbolIndexMgr,
-    std::vector<clang::tooling::Replacement> &Replacements,
+    SymbolIndexManager &SymbolIndexMgr, std::set<std::string> &Headers,
+    std::vector<clang::tooling::Replacement> &Replacements, StringRef StyleName,
     bool MinimizeIncludePaths)
-    : SymbolIndexMgr(SymbolIndexMgr), Replacements(Replacements),
-      MinimizeIncludePaths(MinimizeIncludePaths) {}
+    : SymbolIndexMgr(SymbolIndexMgr), Headers(Headers),
+      Replacements(Replacements), MinimizeIncludePaths(MinimizeIncludePaths),
+      FallbackStyle(StyleName) {}
 
 IncludeFixerActionFactory::~IncludeFixerActionFactory() = default;
 
 bool IncludeFixerActionFactory::runInvocation(
     clang::CompilerInvocation *Invocation, clang::FileManager *Files,
     std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
     clang::DiagnosticConsumer *Diagnostics) {
   assert(Invocation->getFrontendOpts().Inputs.size() == 1);
Compiler.createDiagnostics(new clang::IgnoringDiagConsumer,
                              /*ShouldOwnClient=*/true);
   Compiler.createSourceManager(*Files);
 
   // We abort on fatal errors so don't let a large number of errors become
   // fatal. A missing #include can cause thousands of errors.
   Compiler.getDiagnostics().setErrorLimit(0);
 
   // Run the parser, gather missing includes.
-  auto ScopedToolAction =
-      llvm::make_unique<Action>(SymbolIndexMgr, MinimizeIncludePaths);
+  auto ScopedToolAction = llvm::make_unique<Action>(
+      SymbolIndexMgr, FallbackStyle, MinimizeIncludePaths);
   Compiler.ExecuteAction(*ScopedToolAction);
 
   // Generate replacements.
   ScopedToolAction->Rewrite(Compiler.getSourceManager(),
                             Compiler.getPreprocessor().getHeaderSearchInfo(),
-                            Replacements);
+                            Headers, Replacements);
 
   // Technically this should only return true if we're sure that we have a
   // parseable file. We don't know that though. Only inform users of fatal
   // errors.
   return !Compiler.getDiagnostics().hasFatalErrorOccurred();
 }
 
 } // namespace include_fixer
 } // namespace clang

include-fixer/tool/ClangIncludeFixer.cpp

cl::opt<bool>
     STDINMode("stdin",
               cl::desc("Override source file's content (in the overlaying\n"
                        "virtual file system) with input from <stdin> and run\n"
                        "the tool on the new content with the compilation\n"
                        "options of the source file. This mode is currently\n"
                        "used for editor integration."),
               cl::init(false), cl::cat(IncludeFixerCategory));
 
+cl::opt<std::string>
+    Style("style",
+          cl::desc("Fallback style for reformatting after inserting new "
+                   "headers if there is no clang-format config file found."),
+          cl::init("llvm"), cl::cat(IncludeFixerCategory));
+
 int includeFixerMain(int argc, const char **argv) {
   tooling::CommonOptionsParser options(argc, argv, IncludeFixerCategory);
   tooling::ClangTool tool(options.getCompilations(),
                           options.getSourcePathList());
 
   // In STDINMode, we override the file content with the <stdin> input.
   // Since `tool.mapVirtualFile` takes `StringRef`, we define `Code` outside of
   // the if-block so that `Code` is not released after the if-block.
case yaml: {
     }
 
     SymbolIndexMgr->addSymbolIndex(std::move(*DB));
     break;
   }
   }
 
   // Now run our tool.
+  std::set<std::string> Headers;  // Headers to be added.
   std::vector<tooling::Replacement> Replacements;
   include_fixer::IncludeFixerActionFactory Factory(
-      *SymbolIndexMgr, Replacements, MinimizeIncludePaths);
+      *SymbolIndexMgr, Headers, Replacements, Style, MinimizeIncludePaths);
 
   if (tool.run(&Factory) != 0) {
     llvm::errs()
         << "Clang died with a fatal error! (incorrect include paths?)\n";
     return 1;
   }
 
   if (!Quiet)
-    for (const tooling::Replacement &Replacement : Replacements)
-      llvm::errs() << "Added " << Replacement.getReplacementText();
+    for (const auto &Header : Headers)
+      llvm::errs() << "Added #include " << Header;
 
   // Set up a new source manager for applying the resulting replacements.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
   DiagnosticsEngine Diagnostics(new DiagnosticIDs, &*DiagOpts);
   TextDiagnosticPrinter DiagnosticPrinter(outs(), &*DiagOpts);
   SourceManager SM(Diagnostics, tool.getFiles());
   Diagnostics.setClient(&DiagnosticPrinter, false);
 
   if (STDINMode) {
-    for (const tooling::Replacement &Replacement : Replacements) {
-      FileID ID = SM.getMainFileID();
-      unsigned LineNum = SM.getLineNumber(ID, Replacement.getOffset());
-      llvm::outs() << LineNum << "," << Replacement.getReplacementText();
-    }
+    tooling::Replacements Replaces(Replacements.begin(), Replacements.end());
+    std::string ChangedCode =
+        tooling::applyAllReplacements(Code->getBuffer(), Replaces);
+    llvm::outs() << ChangedCode;
     return 0;
   }
 
   // Write replacements to disk.
   Rewriter Rewrites(SM, LangOptions());
   tooling::applyAllReplacements(Replacements, Rewrites);
   return Rewrites.overwriteChangedFiles();
 }
 
 } // namespace
 
 int main(int argc, const char **argv) {
   return includeFixerMain(argc, argv);
 }

include-fixer/tool/clang-include-fixer.py

 #
 # With this integration you can press the bound key and clang-include-fixer will
 # be run on the current buffer.
 #
 # It operates on the current, potentially unsaved buffer and does not create
 # or save any files. To revert a fix, just undo.
 
 import argparse
+import difflib
 import subprocess
 import sys
 import vim
 
 # set g:clang_include_fixer_path to the path to clang-include-fixer if it is not
 # on the path.
 # Change this to the full path if clang-include-fixer is not on the path.
 binary = 'clang-include-fixer'
def main():
   stdout, stderr = p.communicate(input=text)
 
   # If successful, replace buffer contents.
   if stderr:
     print stderr
 
   if stdout:
     lines = stdout.splitlines()
-    for line in lines:
-      line_num, text = line.split(",")
-      # clang-include-fixer provides 1-based line number
-      line_num = int(line_num) - 1
-      print 'Inserting "{0}" at line {1}'.format(text, line_num)
-      vim.current.buffer[line_num:line_num] = [text]
+    sequence = difflib.SequenceMatcher(None, vim.current.buffer, lines)
+    for op in reversed(sequence.get_opcodes()):
+      if op[0] is not 'equal':
+        vim.current.buffer[op[1]:op[2]] = lines[op[3]:op[4]]
 
 if __name__ == '__main__':
   main()

unittests/include-fixer/IncludeFixerTest.cpp

std::vector<SymbolInfo> Symbols = {
                  1, {{SymbolInfo::ContextType::EnumDecl, "Color"},
                      {SymbolInfo::ContextType::Namespace, "b"},
                      {SymbolInfo::ContextType::Namespace, "a"}}),
   };
   auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
   SymbolIndexMgr->addSymbolIndex(
       llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
 
+  std::set<std::string> Headers;
   std::vector<clang::tooling::Replacement> Replacements;
-  IncludeFixerActionFactory Factory(*SymbolIndexMgr, Replacements);
+  IncludeFixerActionFactory Factory(*SymbolIndexMgr, Headers, Replacements,
+                                    "llvm");
   runOnCode(&Factory, Code, "input.cc", ExtraArgs);
   clang::RewriterTestContext Context;
   clang::FileID ID = Context.createInMemoryFile("input.cc", Code);
   clang::tooling::applyAllReplacements(Replacements, Context.Rewrite);
   return Context.getRewrittenText(ID);
 }
 
 TEST(IncludeFixer, Typo) {
-  EXPECT_EQ("#include <string>\nstd::string foo;\n",
+  EXPECT_EQ("#include <string>\n\nstd::string foo;\n",
             runIncludeFixer("std::string foo;\n"));
 
   EXPECT_EQ(
-      "// comment\n#include <string>\n#include \"foo.h\"\nstd::string foo;\n"
+      "// comment\n#include \"foo.h\"\n#include <string>\nstd::string foo;\n"
       "#include \"dir/bar.h\"\n",
       runIncludeFixer("// comment\n#include \"foo.h\"\nstd::string foo;\n"
                       "#include \"dir/bar.h\"\n"));
 
-  EXPECT_EQ("#include <string>\n#include \"foo.h\"\nstd::string foo;\n",
+  EXPECT_EQ("#include \"foo.h\"\n#include <string>\nstd::string foo;\n",
             runIncludeFixer("#include \"foo.h\"\nstd::string foo;\n"));
 
   EXPECT_EQ(
-      "#include <string>\n#include \"foo.h\"\nstd::string::size_type foo;\n",
+      "#include \"foo.h\"\n#include <string>\nstd::string::size_type foo;\n",
       runIncludeFixer("#include \"foo.h\"\nstd::string::size_type foo;\n"));
 
   // string without "std::" can also be fixed since fixed db results go through
   // SymbolIndexManager, and SymbolIndexManager matches unqualified identifiers
   // too.
-  EXPECT_EQ("#include <string>\nstring foo;\n",
+  EXPECT_EQ("#include <string>\n\nstring foo;\n",
             runIncludeFixer("string foo;\n"));
 }
 
 TEST(IncludeFixer, IncompleteType) {
   EXPECT_EQ(
-      "#include <string>\n#include \"foo.h\"\n"
+      "#include \"foo.h\"\n#include <string>\n"
       "namespace std {\nclass string;\n}\nstring foo;\n",
       runIncludeFixer("#include \"foo.h\"\n"
                       "namespace std {\nclass string;\n}\nstring foo;\n"));
 }
 
 TEST(IncludeFixer, MinimizeInclude) {
   std::vector<std::string> IncludePath = {"-Idir/"};
-  EXPECT_EQ("#include \"otherdir/qux.h\"\na::b::foo bar;\n",
+  EXPECT_EQ("#include \"otherdir/qux.h\"\n\na::b::foo bar;\n",
             runIncludeFixer("a::b::foo bar;\n", IncludePath));
 
   IncludePath = {"-isystemdir"};
-  EXPECT_EQ("#include <otherdir/qux.h>\na::b::foo bar;\n",
+  EXPECT_EQ("#include <otherdir/qux.h>\n\na::b::foo bar;\n",
             runIncludeFixer("a::b::foo bar;\n", IncludePath));
 
   IncludePath = {"-iquotedir"};
-  EXPECT_EQ("#include \"otherdir/qux.h\"\na::b::foo bar;\n",
+  EXPECT_EQ("#include \"otherdir/qux.h\"\n\na::b::foo bar;\n",
             runIncludeFixer("a::b::foo bar;\n", IncludePath));
 
   IncludePath = {"-Idir", "-Idir/otherdir"};
-  EXPECT_EQ("#include \"qux.h\"\na::b::foo bar;\n",
+  EXPECT_EQ("#include \"qux.h\"\n\na::b::foo bar;\n",
             runIncludeFixer("a::b::foo bar;\n", IncludePath));
 }
 
 TEST(IncludeFixer, NestedName) {
   // Some tests don't pass for target *-win32.
   std::vector<std::string> args = {"-target", "x86_64-unknown-unknown"};
-  EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n"
+  EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n\n"
             "int x = a::b::foo(0);\n",
             runIncludeFixer("int x = a::b::foo(0);\n", args));
 
   // FIXME: Handle simple macros.
   EXPECT_EQ("#define FOO a::b::foo\nint x = FOO;\n",
             runIncludeFixer("#define FOO a::b::foo\nint x = FOO;\n"));
   EXPECT_EQ("#define FOO(x) a::##x\nint x = FOO(b::foo);\n",
             runIncludeFixer("#define FOO(x) a::##x\nint x = FOO(b::foo);\n"));
 
-  EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n"
+  EXPECT_EQ("#include \"dir/otherdir/qux.h\"\n\n"
             "namespace a {}\nint a = a::b::foo(0);\n",
             runIncludeFixer("namespace a {}\nint a = a::b::foo(0);\n", args));
 }
 
 TEST(IncludeFixer, MultipleMissingSymbols) {
-  EXPECT_EQ("#include <string>\nstd::string bar;\nstd::sting foo;\n",
+  EXPECT_EQ("#include <string>\n\nstd::string bar;\nstd::sting foo;\n",
             runIncludeFixer("std::string bar;\nstd::sting foo;\n"));
 }
 
 TEST(IncludeFixer, ScopedNamespaceSymbols) {
-  EXPECT_EQ("#include \"bar.h\"\nnamespace a { b::bar b; }\n",
-            runIncludeFixer("namespace a { b::bar b; }\n"));
-  EXPECT_EQ("#include \"bar.h\"\nnamespace A { a::b::bar b; }\n",
-            runIncludeFixer("namespace A { a::b::bar b; }\n"));
-  EXPECT_EQ("#include \"bar.h\"\nnamespace a { void func() { b::bar b; } }\n",
-            runIncludeFixer("namespace a { void func() { b::bar b; } }\n"));
+  EXPECT_EQ("#include \"bar.h\"\n\nnamespace a {\nb::bar b;\n}",
+            runIncludeFixer("namespace a {\nb::bar b;\n}"));
+  EXPECT_EQ("#include \"bar.h\"\n\nnamespace A {\na::b::bar b;\n}",
+            runIncludeFixer("namespace A {\na::b::bar b;\n}"));
+  EXPECT_EQ("#include \"bar.h\"\n\nnamespace a {\nvoid func() { b::bar b; }\n}",
+            runIncludeFixer("namespace a {\nvoid func() { b::bar b; }\n}"));
   EXPECT_EQ("namespace A { c::b::bar b; }\n",
             runIncludeFixer("namespace A { c::b::bar b; }\n"));
   // FIXME: The header should not be added here. Remove this after we support
   // full match.
-  EXPECT_EQ("#include \"bar.h\"\nnamespace A { b::bar b; }\n",
-            runIncludeFixer("namespace A { b::bar b; }\n"));
+  EXPECT_EQ("#include \"bar.h\"\n\nnamespace A {\nb::bar b;\n}",
+            runIncludeFixer("namespace A {\nb::bar b;\n}"));
 }
 
 TEST(IncludeFixer, EnumConstantSymbols) {
-  EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n",
+  EXPECT_EQ("#include \"color.h\"\n\nint test = a::b::Green;\n",
             runIncludeFixer("int test = a::b::Green;\n"));
 }
 
+// FIXME: add test cases for inserting and sorting multiple headers when
+// include-fixer supports multiple headers insertion.
+TEST(IncludeFixer, InsertAndSortSingleHeader) {
+  // Insert one header.
+  std::string Code = "#include \"a.h\"\n"
+                     "#include \"foo.h\"\n"
+                     "\n"
+                     "namespace a { b::bar b; }";
+  std::string Expected = "#include \"a.h\"\n"
+                         "#include \"bar.h\"\n"
+                         "#include \"foo.h\"\n"
+                         "\n"
+                         "namespace a { b::bar b; }";
+  EXPECT_EQ(Expected, runIncludeFixer(Code));
+}
+
 } // namespace
 } // namespace include_fixer
 } // namespace clang