Clang Tools Organization¶

Clang Tools are CLI or GUI programs that are intended to be directly used by C++ developers. That is they are not primarily for use by Clang developers, although they are hopefully useful to C++ developers who happen to work on Clang, and we try to actively dogfood their functionality. They are developed in three components: the underlying infrastructure for building a standalone tool based on Clang, core shared logic used by many different tools in the form of refactoring and rewriting libraries, and the tools themselves.

The underlying infrastructure for Clang Tools is the LibTooling platform. See its documentation for much more detailed information about how this infrastructure works. The common refactoring and rewriting toolkit-style library is also part of LibTooling organizationally.

A few Clang Tools are developed along side the core Clang libraries as examples and test cases of fundamental functionality. However, most of the tools are developed in a side repository to provide easy separation from the core libraries. We intentionally do not support public libraries in the side repository, as we want to carefully review and find good APIs for libraries as they are lifted out of a few tools and into the core Clang library set.

Regardless of which repository Clang Tools’ code resides in, the development process and practices for all Clang Tools are exactly those of Clang itself. They are entirely within the Clang project, regardless of the version control scheme.

Core Clang Tools¶

The core set of Clang tools that are within the main repository are tools that very specifically complement, and allow use and testing of Clang specific functionality.

Extra Clang Tools¶

As various categories of Clang Tools are added to the extra repository, they’ll be tracked here. The focus of this documentation is on the scope and features of the tools for other tool developers; each tool should provide its own user-focused documentation.

Ideas for new Tools¶

• C++ cast conversion tool. Will convert C-style casts ((type) value) to appropriate C++ cast (static_cast, const_cast or reinterpret_cast).

• Non-member begin() and end() conversion tool. Will convert foo.begin() into begin(foo) and similarly for end(), where foo is a standard container. We could also detect similar patterns for arrays.

• make_shared / make_unique conversion. Part of this transformation can be incorporated into the auto transformation. Will convert

  std::shared_ptr<Foo> sp(new Foo);
  std::unique_ptr<Foo> up(new Foo);
  
  func(std::shared_ptr<Foo>(new Foo), bar());
  

  into:

  auto sp = std::make_shared<Foo>();
  auto up = std::make_unique<Foo>(); // In C++14 mode.
  
  // This also affects correctness.  For the cases where bar() throws,
  // make_shared() is safe and the original code may leak.
  func(std::make_shared<Foo>(), bar());
  

• tr1 removal tool. Will migrate source code from using TR1 library features to C++11 library. For example:

  #include <tr1/unordered_map>
  int main()
  {
      std::tr1::unordered_map <int, int> ma;
      std::cout << ma.size () << std::endl;
      return 0;
  }
  

  should be rewritten to:

  #include <unordered_map>
  int main()
  {
      std::unordered_map <int, int> ma;
      std::cout << ma.size () << std::endl;
      return 0;
  }
  

• A tool to remove auto. Will convert auto to an explicit type or add comments with deduced types. The motivation is that there are developers that don’t want to use auto because they are afraid that they might lose control over their code.

• C++14: less verbose operator function objects (N3421). For example:

  sort(v.begin(), v.end(), greater<ValueType>());
  

  should be rewritten to:

  sort(v.begin(), v.end(), greater<>());