any C/C++ refactoring tool based on libclang? (even simplest “toy example” ) [closed]

Answer 1

Clang contains a library called "CIndex" which was developed, I believe, for doing code completion in IDEs. It can also be used for parsing C++ and walking the AST, but doesn't have anything in the way of refactoring. See Eli Bendersky's article here.

I have started such a project recently: cmonster. It's a Python-based API for parsing C++ (using libclang), analyzing the AST, with an interface for "rewriting" (i.e. inserting/removing/modifying source ranges). There's no nice way (yet) for doing things like modifying function names and having that translated into source-modifications, but it wouldn't be terribly difficult to do that.

I have not yet created a release with this functionality (although it's in the github repo), as I'm waiting for llvm/clang 3.0 to be released.

Also, I should point out a couple of things:

• The code is very rough, calling it alpha would be perhaps generous.
• I'm by no means an expert on this subject (unlike, say, Dr. Ira Baxter over there).

Adjust expectations appropriately.

Update: cmonster 0.2 has been released, which includes the described features. Check it out on Github.

Answer 2

https://github.com/lukhnos/refactorial is based on clang and claims

Transforms Provided

Accessor: Synthesize getters and setters for designated member variables

MethodMove: Move inlined member function bodies to the implementation file

ExtractParameter: promote a function variable to a parameter to that function

TypeRename: Rename types, including tag types (enum, struct, union, class), template classes, Objective-C types (class and protocol), typedefs and even bulit-in types (e.g. unsigned to uint32_t)

RecordFieldRename: Rename record (struct, union) fields, including C++ member variables

FunctionRename: Rename functions, including C++ member functions

Works via specifications in a YAML configuration file. I haven't tried it out (yet).

Answer 3

This may be a bit 'meta', but there's an example thats written in clang as a tool to run on clang (although, there's more to it than just that.

RemoveCStrCalls.cpp

//  This file implements a tool that prints replacements that remove redundant
//  calls of c_str() on strings.
//
//  Usage:
//  remove-cstr-calls <cmake-output-dir> <file1> <file2> ...
//
//  Where <cmake-output-dir> is a CMake build directory in which a file named
//  compile_commands.json exists (enable -DCMAKE_EXPORT_COMPILE_COMMANDS in
//  CMake to get this output).
//
//  <file1> ... specify the paths of files in the CMake source tree. This path
//  is looked up in the compile command database. If the path of a file is
//  absolute, it needs to point into CMake's source tree. If the path is
//  relative, the current working directory needs to be in the CMake source
//  tree and the file must be in a subdirectory of the current working
//  directory. "./" prefixes in the relative files will be automatically
//  removed, but the rest of a relative path must be a suffix of a path in
//  the compile command line database.
//
//  For example, to use remove-cstr-calls on all files in a subtree of the
//  source tree, use:
//
//    /path/in/subtree $ find . -name '*.cpp'|
//        xargs remove-cstr-calls /path/to/source

Answer 4

It's not refactoring, but completion, but might be useful:

• clang complete : Use of Clang for completing C, C++, Objective-C and Objective-C++

Answer 5

Another possibility is to develop your own plugin for GCC, or to develop a GCC MELT extension to do your task. But extending GCC (or Clang) requires understanding the internal representations of these compilers (Gimple & Tree for GCC) and this require some work. MELT is a high-level domain specific language to extend GCC.

Answer 6

Google made a Clang based refactoring tool for their C++ code base and plans to release it. I don't know the current state of the project, but you can see this demo presented on the 2011 LLVM Developers Meeting: https://www.youtube.com/watch?v=mVbDzTM21BQ.

Also, XCode's (4+) built-in auto-completion and refactoring functions are based on libclang.