forked from OSchip/llvm-project
273 lines
8.8 KiB
Python
Executable File
273 lines
8.8 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
#===- add_new_check.py - clang-tidy check generator ----------*- python -*--===#
|
|
#
|
|
# The LLVM Compiler Infrastructure
|
|
#
|
|
# This file is distributed under the University of Illinois Open Source
|
|
# License. See LICENSE.TXT for details.
|
|
#
|
|
#===------------------------------------------------------------------------===#
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
|
|
# Adapts the module's CMakelist file. Returns 'True' if it could add a new entry
|
|
# and 'False' if the entry already existed.
|
|
def adapt_cmake(module_path, check_name_camel):
|
|
filename = os.path.join(module_path, 'CMakeLists.txt')
|
|
with open(filename, 'r') as f:
|
|
lines = f.readlines()
|
|
|
|
cpp_file = check_name_camel + '.cpp'
|
|
|
|
# Figure out whether this check already exists.
|
|
for line in lines:
|
|
if line.strip() == cpp_file:
|
|
return False
|
|
|
|
print('Updating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
cpp_found = False
|
|
file_added = False
|
|
for line in lines:
|
|
cpp_line = line.strip().endswith('.cpp')
|
|
if (not file_added) and (cpp_line or cpp_found):
|
|
cpp_found = True
|
|
if (line.strip() > cpp_file) or (not cpp_line):
|
|
f.write(' ' + cpp_file + '\n')
|
|
file_added = True
|
|
f.write(line)
|
|
|
|
return True
|
|
|
|
|
|
# Adds a header for the new check.
|
|
def write_header(module_path, module, check_name, check_name_camel):
|
|
check_name_dashes = module + '-' + check_name
|
|
filename = os.path.join(module_path, check_name_camel) + '.h'
|
|
print('Creating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
header_guard = ('LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_' + module.upper() +
|
|
'_' + check_name.upper().replace('-', '_') + '_H')
|
|
f.write('//===--- ')
|
|
f.write(os.path.basename(filename))
|
|
f.write(' - clang-tidy')
|
|
f.write('-' * max(0, 43 - len(os.path.basename(filename))))
|
|
f.write('*- C++ -*-===//')
|
|
f.write("""
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef %(header_guard)s
|
|
#define %(header_guard)s
|
|
|
|
#include "../ClangTidy.h"
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
|
|
/// FIXME: Write a short description.
|
|
///
|
|
/// For the user-facing documentation see:
|
|
/// http://clang.llvm.org/extra/clang-tidy/checks/%(check_name_dashes)s.html
|
|
class %(check_name)s : public ClangTidyCheck {
|
|
public:
|
|
%(check_name)s(StringRef Name, ClangTidyContext *Context)
|
|
: ClangTidyCheck(Name, Context) {}
|
|
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
|
|
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
|
|
};
|
|
|
|
} // namespace tidy
|
|
} // namespace clang
|
|
|
|
#endif // %(header_guard)s
|
|
|
|
""" % {'header_guard': header_guard,
|
|
'check_name': check_name_camel,
|
|
'check_name_dashes': check_name_dashes})
|
|
|
|
|
|
# Adds the implementation of the new check.
|
|
def write_implementation(module_path, check_name_camel):
|
|
filename = os.path.join(module_path, check_name_camel) + '.cpp'
|
|
print('Creating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
f.write('//===--- ')
|
|
f.write(os.path.basename(filename))
|
|
f.write(' - clang-tidy')
|
|
f.write('-' * max(0, 52 - len(os.path.basename(filename))))
|
|
f.write('-===//')
|
|
f.write("""
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "%(check_name)s.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
|
|
void %(check_name)s::registerMatchers(MatchFinder *Finder) {
|
|
// FIXME: Add matchers.
|
|
Finder->addMatcher(functionDecl().bind("x"), this);
|
|
}
|
|
|
|
void %(check_name)s::check(const MatchFinder::MatchResult &Result) {
|
|
// FIXME: Add callback implementation.
|
|
const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("x");
|
|
if (MatchedDecl->getName().startswith("awesome_"))
|
|
return;
|
|
diag(MatchedDecl->getLocation(), "function '%%0' is insufficiently awesome")
|
|
<< MatchedDecl->getName()
|
|
<< FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_");
|
|
}
|
|
|
|
} // namespace tidy
|
|
} // namespace clang
|
|
|
|
""" % {'check_name': check_name_camel})
|
|
|
|
|
|
# Modifies the module to include the new check.
|
|
def adapt_module(module_path, module, check_name, check_name_camel):
|
|
modulecpp = filter(lambda p: p.lower() == module.lower() + "tidymodule.cpp", os.listdir(module_path))[0]
|
|
filename = os.path.join(module_path, modulecpp)
|
|
with open(filename, 'r') as f:
|
|
lines = f.readlines()
|
|
|
|
print('Updating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
header_added = False
|
|
header_found = False
|
|
check_added = False
|
|
check_decl = (' CheckFactories.registerCheck<' + check_name_camel +
|
|
'>(\n "' + module + '-' + check_name + '");\n')
|
|
|
|
for line in lines:
|
|
if not header_added:
|
|
match = re.search('#include "(.*)"', line)
|
|
if match:
|
|
header_found = True
|
|
if match.group(1) > check_name_camel:
|
|
header_added = True
|
|
f.write('#include "' + check_name_camel + '.h"\n')
|
|
elif header_found:
|
|
header_added = True
|
|
f.write('#include "' + check_name_camel + '.h"\n')
|
|
|
|
if not check_added:
|
|
if line.strip() == '}':
|
|
check_added = True
|
|
f.write(check_decl)
|
|
else:
|
|
match = re.search('registerCheck<(.*)>', line)
|
|
if match and match.group(1) > check_name_camel:
|
|
check_added = True
|
|
f.write(check_decl)
|
|
f.write(line)
|
|
|
|
|
|
# Adds a test for the check.
|
|
def write_test(module_path, module, check_name):
|
|
check_name_dashes = module + '-' + check_name
|
|
filename = os.path.normpath(
|
|
os.path.join(module_path, '../../test/clang-tidy',
|
|
check_name_dashes + '.cpp'))
|
|
print('Creating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
f.write(
|
|
"""// RUN: %%check_clang_tidy %%s %(check_name_dashes)s %%t
|
|
|
|
// FIXME: Add something that triggers the check here.
|
|
void f();
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'f' is insufficiently awesome [%(check_name_dashes)s]
|
|
|
|
// FIXME: Verify the applied fix.
|
|
// * Make the CHECK patterns specific enough and try to make verified lines
|
|
// unique to avoid incorrect matches.
|
|
// * Use {{}} for regular expressions.
|
|
// CHECK-FIXES: {{^}}void awesome_f();{{$}}
|
|
|
|
// FIXME: Add something that doesn't trigger the check here.
|
|
void awesome_f2();
|
|
""" % {"check_name_dashes" : check_name_dashes})
|
|
|
|
# Recreates the list of checks in the docs/clang-tidy/checks directory.
|
|
def update_checks_list(module_path):
|
|
filename = os.path.normpath(
|
|
os.path.join(module_path, '../../docs/clang-tidy/checks/list.rst'))
|
|
with open(filename, 'r') as f:
|
|
lines = f.readlines()
|
|
|
|
checks = map(lambda s: ' ' + s.replace('.rst', '\n'),
|
|
filter(lambda s: s.endswith('.rst') and s != 'list.rst',
|
|
os.listdir(os.path.join(module_path, '../../docs/clang-tidy/checks'))))
|
|
checks.sort()
|
|
|
|
print('Updating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
for line in lines:
|
|
f.write(line)
|
|
if line.startswith('.. toctree::'):
|
|
f.writelines(checks)
|
|
break
|
|
|
|
# Adds a documentation for the check.
|
|
def write_docs(module_path, module, check_name):
|
|
check_name_dashes = module + '-' + check_name
|
|
filename = os.path.normpath(
|
|
os.path.join(module_path, '../../docs/clang-tidy/checks/',
|
|
check_name_dashes + '.rst'))
|
|
print('Creating %s...' % filename)
|
|
with open(filename, 'wb') as f:
|
|
f.write(
|
|
"""%(check_name_dashes)s
|
|
%(underline)s
|
|
|
|
FIXME: Describe what patterns does the check detect and why. Give examples.
|
|
""" % {"check_name_dashes" : check_name_dashes,
|
|
"underline" : "=" * len(check_name_dashes)})
|
|
|
|
def main():
|
|
if len(sys.argv) != 3:
|
|
print 'Usage: add_new_check.py <module> <check>, e.g.\n'
|
|
print 'add_new_check.py misc awesome-functions\n'
|
|
return
|
|
|
|
module = sys.argv[1]
|
|
check_name = sys.argv[2]
|
|
check_name_camel = ''.join(map(lambda elem: elem.capitalize(),
|
|
check_name.split('-'))) + 'Check'
|
|
clang_tidy_path = os.path.dirname(sys.argv[0])
|
|
module_path = os.path.join(clang_tidy_path, module)
|
|
|
|
if not adapt_cmake(module_path, check_name_camel):
|
|
return
|
|
write_header(module_path, module, check_name, check_name_camel)
|
|
write_implementation(module_path, check_name_camel)
|
|
adapt_module(module_path, module, check_name, check_name_camel)
|
|
write_test(module_path, module, check_name)
|
|
write_docs(module_path, module, check_name)
|
|
update_checks_list(module_path)
|
|
print('Done. Now it\'s your turn!')
|
|
|
|
if __name__ == '__main__':
|
|
main()
|