// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This is the implementation of a clang tool that rewrites containers of
// pointer fields into raw_ptr<T>:
// std::vector<Pointee*> field_
// becomes:
// std::vector<raw_ptr<Pointee>> field_
//
// Note that the tool emits two kinds of outputs:
// 1- A pairs of nodes formatted as {lhs};{rhs}\n representing an edge between
// two nodes.
// 2- A single node formatted as {lhs}\n
// The concatenated outputs from multiple tool runs are then used to construct
// the graph and emit relevant edits using extract_edits.py
//
// A node (lhs, rhs) has the following format:
// '{is_field,is_excluded,has_auto_type,r:::<file
// path>:::<offset>:::<length>:::<replacement text>,include-user-header:::<file
// path>:::-1:::-1:::<include text>}'
//
// where `is_field`,`is_excluded`, and `has_auto_type` are booleans represendted
// as 0 or 1.
//
// For more details, see the doc here:
// https://docs.google.com/document/d/1P8wLVS3xueI4p3EAPO4JJP6d1_zVp5SapQB0EW9iHQI/
#include <assert.h>
#include <algorithm>
#include <cstdio>
#include <fstream>
#include <limits>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
#include "RawPtrHelpers.h"
#include "RawPtrManualPathsToIgnore.h"
#include "SeparateRepositoryPaths.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/ASTMatchersMacros.h"
#include "clang/Basic/CharInfo.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Lex/Lexer.h"
#include "clang/Lex/MacroArgs.h"
#include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Refactoring.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/LineIterator.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/TargetSelect.h"
using namespace clang::ast_matchers;
namespace {
// Include path that needs to be added to all the files where raw_ptr<...>
// replaces a raw pointer.
const char kRawPtrIncludePath[] = "base/memory/raw_ptr.h";
const char kOverrideExcludePathsParamName[] = "override-exclude-paths";
// This iterates over function parameters and matches the ones that match
// parm_var_decl_matcher.
AST_MATCHER_P(clang::FunctionDecl,
forEachParmVarDecl,
clang::ast_matchers::internal::Matcher<clang::ParmVarDecl>,
parm_var_decl_matcher) {
const clang::FunctionDecl& function_decl = Node;
auto num_params = function_decl.getNumParams();
bool is_matching = false;
clang::ast_matchers::internal::BoundNodesTreeBuilder result;
for (unsigned i = 0; i < num_params; i++) {
const clang::ParmVarDecl* param = function_decl.getParamDecl(i);
clang::ast_matchers::internal::BoundNodesTreeBuilder param_matches;
if (parm_var_decl_matcher.matches(*param, Finder, ¶m_matches)) {
is_matching = true;
result.addMatch(param_matches);
}
}
*Builder = std::move(result);
return is_matching;
}
// Returns a StringRef of the elements apprearing after the pattern
// '(anonymous namespace)::' if any, otherwise returns input.
static llvm::StringRef RemoveAnonymous(llvm::StringRef input) {
constexpr llvm::StringRef kAnonymousNamespace{"(anonymous namespace)::"};
auto loc = input.find(kAnonymousNamespace);
if (loc != input.npos) {
return input.substr(loc + kAnonymousNamespace.size());
}
return input;
}
// Statements of the form: for (auto* i : affected_expr)
// need to be changed to: for (type_name* i : affected_expr)
// in order to extract the pointer type from now raw_ptr.
// The text returned by type's `getAsString()` can contain some unuseful
// data. Example: 'const struct n1::(anonymous namespace)::n2::type_name'. As
// is, this wouldn't compile. This needs to be reinterpreted as
// 'const n2::type_name'.
// `RemovePrefix` removes the class/struct keyword if any,
// conserves the constness, and trims '(anonymous namespace)::'
// as well as anything on it's lhs using `RemoveAnonymous`.
static std::string RemovePrefix(llvm::StringRef input) {
constexpr llvm::StringRef kClassPrefix{"class "};
constexpr llvm::StringRef kStructPrefix{"struct "};
constexpr llvm::StringRef kConstPrefix{"const "};
std::string result;
result.reserve(input.size());
if (input.consume_front(kConstPrefix)) {
result += kConstPrefix;
}
input.consume_front(kClassPrefix);
input.consume_front(kStructPrefix);
result += RemoveAnonymous(input);
return result;
}
struct Node {
bool is_field = false;
// This is set to true for Fields annotated with RAW_PTR_EXCLUSION
bool is_excluded = false;
// auto type variables don't need to be rewritten. They still need to be
// present in the graph to propagate the rewrite to non auto expressions.
// Example:
// auto temp = member_; vector<T*>::iterator it = temp.begin();
// `it`'s type needs to be rewritten when member's type is.
bool has_auto_type = false;
// A replacement follows the following format:
// `r:::<file path>:::<offset>:::<length>:::<replacement text>`
std::string replacement;
// An include directive follows the following format:
// `include-user-header:::<file path>:::-1:::-1:::<include text>`
std::string include_directive;
bool operator==(const Node& other) const {
return replacement == other.replacement;
}
bool operator<(const Node& other) const {
return replacement < other.replacement;
}
// The resulting string follows the following format:
// {is_field\,is_excluded\,has_auto_type\,r:::<file
// path>:::<offset>:::<length>:::<replacement
// text>\,include-user-header:::<file path>:::-1:::-1:::<include text>}
// where is_field,is_excluded, and has_auto_type are booleans represendted as
// 0 or 1.
std::string ToString() const {
return llvm::formatv("{{{0:d}\\,{1:d}\\,{2:d}\\,{3}\\,{4}}", is_field,
is_excluded, has_auto_type, replacement,
include_directive);
}
};
// Helper class to add edges to the set of node_pairs_;
class OutputHelper {
public:
OutputHelper() = default;
void AddEdge(const Node& lhs, const Node& rhs) {
node_pairs_.insert(
llvm::formatv("{0};{1}\n", lhs.ToString(), rhs.ToString()));
}
void AddSingleNode(const Node& lhs) {
node_pairs_.insert(llvm::formatv("{0}\n", lhs.ToString()));
}
void Emit() {
for (const auto& p : node_pairs_) {
llvm::outs() << p;
}
}
private:
// This represents a line for every 2 adjacent nodes.
// The format is: {lhs};{rhs}\n where lhs & rhs generated using
// Node::ToString().
// There are two cases where the line contains only a lhs node {lhs}\n
// 1- To make sure that fields that are not connected to any other node are
// represented in the graph.
// 2- Fields annotated with RAW_PTR_EXCLUSION are also inserted as a single
// node to the list.
std::set<std::string> node_pairs_;
};
// This visitor is used to extract a FunctionDecl* bound with a node id
// "fct_decl" from a given match.
// This is used in the `forEachArg` and `forEachBindArg` matchers below.
class LocalVisitor
: public clang::ast_matchers::internal::BoundNodesTreeBuilder::Visitor {
public:
void visitMatch(
const clang::ast_matchers::BoundNodes& BoundNodesView) override {
if (const auto* ptr =
BoundNodesView.getNodeAs<clang::FunctionDecl>("fct_decl")) {
fct_decl_ = BoundNodesView.getNodeAs<clang::FunctionDecl>("fct_decl");
is_lambda_ = false;
} else {
const clang::LambdaExpr* lambda_expr =
BoundNodesView.getNodeAs<clang::LambdaExpr>("lambda_expr");
fct_decl_ = lambda_expr->getCallOperator();
is_lambda_ = true;
}
}
const clang::FunctionDecl* fct_decl_;
bool is_lambda_;
};
// This is used to map arguments passed to std::make_unique to the underlying
// constructor parameters. For each expr that matches, using `LocalVisitor`, we
// extract the ptr to clang::FunctionDecl which represents here the
// constructorDecl and use it to get the parmVarDecl corresponding to the
// argument.
// This iterates over a callExpressions's arguments and matches the ones that
// match expr_matcher. For each argument matched, retrieve the corresponding
// constructor parameter. The constructor parameter is then checked against
// parm_var_decl_matcher.
AST_MATCHER_P2(clang::CallExpr,
forEachArg,
clang::ast_matchers::internal::Matcher<clang::Expr>,
expr_matcher,
clang::ast_matchers::internal::Matcher<clang::ParmVarDecl>,
parm_var_decl_matcher) {
const clang::CallExpr& call_expr = Node;
auto num_args = call_expr.getNumArgs();
bool is_matching = false;
clang::ast_matchers::internal::BoundNodesTreeBuilder result;
for (unsigned i = 0; i < num_args; i++) {
const clang::Expr* arg = call_expr.getArg(i);
clang::ast_matchers::internal::BoundNodesTreeBuilder arg_matches;
if (expr_matcher.matches(*arg, Finder, &arg_matches)) {
LocalVisitor l;
arg_matches.visitMatches(&l);
const auto* fct_decl = l.fct_decl_;
if (fct_decl) {
const auto* param = fct_decl->getParamDecl(i);
clang::ast_matchers::internal::BoundNodesTreeBuilder parm_var_matches(
arg_matches);
if (parm_var_decl_matcher.matches(*param, Finder, &parm_var_matches)) {
is_matching = true;
result.addMatch(parm_var_matches);
}
}
}
}
*Builder = std::move(result);
return is_matching;
}
// This is used to handle expressions of the form:
// base::BindOnce(
// [](std::vector<raw_ptr<Label>>& message_labels,
// Label* message_label) {
// message_labels.push_back(message_label);
// },
// std::ref(message_labels_))))
// This creates a link between the parmVarDecl's in the lambda/functionPointer
// passed as 1st argument and the rest of the arguments passed to the bind call.
AST_MATCHER_P2(clang::CallExpr,
forEachBindArg,
clang::ast_matchers::internal::Matcher<clang::Expr>,
expr_matcher,
clang::ast_matchers::internal::Matcher<clang::ParmVarDecl>,
parm_var_decl_matcher) {
const clang::CallExpr& call_expr = Node;
auto num_args = call_expr.getNumArgs();
if (num_args == 1) {
// No arguments to map to the lambda/fct parmVarDecls.
return false;
}
bool is_matching = false;
clang::ast_matchers::internal::BoundNodesTreeBuilder result;
for (unsigned i = 1; i < num_args; i++) {
const clang::Expr* arg = call_expr.getArg(i);
clang::ast_matchers::internal::BoundNodesTreeBuilder arg_matches;
if (expr_matcher.matches(*arg, Finder, &arg_matches)) {
LocalVisitor l;
arg_matches.visitMatches(&l);
const auto* fct_decl = l.fct_decl_;
// start_index=1 when we start with second arg for Bind and first arg for
// lambda/fct
unsigned start_index = 1;
// start_index=2 when the second arg is a pointer to the object on which
// the function is to be invoked. This is done when the function pointer is
// not a static class function.
// isGlobal is true for free functions as well as static member functions,
// both of which don't need a pointer to the object on which they are
// invoked.
if (!l.is_lambda_ && !l.fct_decl_->isGlobal()) {
start_index = 2;
// Skip the second argument passed to BindOnce/BindRepeating as it is an
// object pointer unrelated to target function args.
if (i == 1) {
continue;
}
}
const auto* param = fct_decl->getParamDecl(i - start_index);
clang::ast_matchers::internal::BoundNodesTreeBuilder
parm_var_decl_matches(arg_matches);
if (parm_var_decl_matcher.matches(*param, Finder,
&parm_var_decl_matches)) {
is_matching = true;
result.addMatch(parm_var_decl_matches);
}
}
}
*Builder = std::move(result);
return is_matching;
}
static std::string GenerateNewType(const clang::ASTContext& ast_context,
const clang::QualType& pointer_type) {
std::string result;
clang::QualType pointee_type = pointer_type->getPointeeType();
// Preserve qualifiers.
assert(!pointer_type.isRestrictQualified() &&
"|restrict| is a C-only qualifier and raw_ptr<T>/raw_ref<T> need C++");
if (pointer_type.isConstQualified()) {
result += "const ";
}
if (pointer_type.isVolatileQualified()) {
result += "volatile ";
}
// Convert pointee type to string.
clang::PrintingPolicy printing_policy(ast_context.getLangOpts());
printing_policy.SuppressScope = 1; // s/blink::Pointee/Pointee/
std::string pointee_type_as_string =
pointee_type.getAsString(printing_policy);
result += llvm::formatv("raw_ptr<{0}>", pointee_type_as_string);
return result;
}
static std::pair<std::string, std::string> GetReplacementAndIncludeDirectives(
const clang::PointerTypeLoc* type_loc,
const clang::TemplateSpecializationTypeLoc* tst_loc,
std::string replacement_text,
const clang::SourceManager& source_manager) {
clang::SourceLocation begin_loc = tst_loc->getLAngleLoc().getLocWithOffset(1);
// This is done to skip the star '*' because type_loc's end loc is just
// before the star position.
clang::SourceLocation end_loc = type_loc->getEndLoc().getLocWithOffset(1);
clang::SourceRange replacement_range(begin_loc, end_loc);
clang::tooling::Replacement replacement(
source_manager, clang::CharSourceRange::getCharRange(replacement_range),
replacement_text);
llvm::StringRef file_path = replacement.getFilePath();
if (file_path.empty()) {
return {"", ""};
}
std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
std::string replacement_directive = llvm::formatv(
"r:::{0}:::{1}:::{2}:::{3}", file_path, replacement.getOffset(),
replacement.getLength(), replacement_text);
std::string include_directive =
llvm::formatv("include-user-header:::{0}:::-1:::-1:::{1}", file_path,
kRawPtrIncludePath);
return {replacement_directive, include_directive};
}
std::string GenerateReplacementForAutoLoc(
const clang::TypeLoc* auto_loc,
const std::string& replacement_text,
const clang::SourceManager& source_manager,
const clang::ASTContext& ast_context) {
clang::SourceLocation begin_loc = auto_loc->getBeginLoc();
clang::SourceRange replacement_range(begin_loc, begin_loc);
clang::tooling::Replacement replacement(
source_manager, clang::CharSourceRange::getCharRange(replacement_range),
replacement_text);
llvm::StringRef file_path = replacement.getFilePath();
return llvm::formatv("r:::{0}:::{1}:::{2}:::{3}", file_path,
replacement.getOffset(), replacement.getLength(),
replacement_text);
}
// Called when the Match registered for it was successfully found in the AST.
// The matches registered represent two categories:
// 1- An adjacency relationship
// In that case, a node pair is created, using matched node ids, and added
// to the node_pair list using `OutputHelper::AddEdge`
// 2- A single fieldDecl node match
// In that case, a single node is created and added to the node_pair list
// using `OutputHelper::AddSingleNode`
class PotentialNodes : public MatchFinder::MatchCallback {
public:
explicit PotentialNodes(OutputHelper& helper) : output_helper_(helper) {}
PotentialNodes(const PotentialNodes&) = delete;
PotentialNodes& operator=(const PotentialNodes&) = delete;
void run(const MatchFinder::MatchResult& result) override {
const clang::SourceManager& source_manager = *result.SourceManager;
const clang::ASTContext& ast_context = *result.Context;
Node lhs;
if (auto* type_loc = result.Nodes.getNodeAs<clang::PointerTypeLoc>(
"lhs_argPointerLoc")) {
std::string replacement_text =
GenerateNewType(ast_context, type_loc->getType());
const clang::TemplateSpecializationTypeLoc* tst_loc =
result.Nodes.getNodeAs<clang::TemplateSpecializationTypeLoc>(
"lhs_tst_loc");
auto p = GetReplacementAndIncludeDirectives(
type_loc, tst_loc, replacement_text, source_manager);
lhs.replacement = p.first;
lhs.include_directive = p.second;
if (const clang::FieldDecl* field_decl =
result.Nodes.getNodeAs<clang::FieldDecl>("lhs_field")) {
lhs.is_field = true;
}
// To make sure we add all field decls to the graph.(Specifically those
// not connected to other nodes)
if (const clang::FieldDecl* field_decl =
result.Nodes.getNodeAs<clang::FieldDecl>("field_decl")) {
lhs.is_field = true;
output_helper_.AddSingleNode(lhs);
return;
}
// RAW_PTR_EXCLUSION is not captured when adding edges between nodes. For
// that reason, fields annotated with RAW_PTR_EXCLUSION are added as
// single nodes to the list, this is then used as a starting point to
// propagate the exclusion to all neighboring nodes.
if (const clang::FieldDecl* field_decl =
result.Nodes.getNodeAs<clang::FieldDecl>("excluded_field_decl")) {
lhs.is_field = true;
lhs.is_excluded = true;
output_helper_.AddSingleNode(lhs);
return;
}
} else if (const clang::TypeLoc* auto_loc =
result.Nodes.getNodeAs<clang::TypeLoc>("lhs_auto_loc")) {
lhs.replacement = GenerateReplacementForAutoLoc(
auto_loc, "replacement_text", source_manager, ast_context);
lhs.include_directive = lhs.replacement;
// No need to emit a rewrite for auto type variables. They still need to
// appear in the graph to propagate the rewrite to non-auto type nodes
// codes connected to them.
lhs.has_auto_type = true;
} else { // Not supposed to get here
assert(false);
}
Node rhs;
if (const clang::FieldDecl* field_decl =
result.Nodes.getNodeAs<clang::FieldDecl>("rhs_field")) {
rhs.is_field = true;
}
if (auto* type_loc = result.Nodes.getNodeAs<clang::PointerTypeLoc>(
"rhs_argPointerLoc")) {
std::string replacement_text =
GenerateNewType(ast_context, type_loc->getType());
const clang::TemplateSpecializationTypeLoc* tst_loc =
result.Nodes.getNodeAs<clang::TemplateSpecializationTypeLoc>(
"rhs_tst_loc");
auto p = GetReplacementAndIncludeDirectives(
type_loc, tst_loc, replacement_text, source_manager);
rhs.replacement = p.first;
rhs.include_directive = p.second;
} else if (const clang::TypeLoc* auto_loc =
result.Nodes.getNodeAs<clang::TypeLoc>("rhs_auto_loc")) {
rhs.replacement = GenerateReplacementForAutoLoc(
auto_loc, "replacement_text", source_manager, ast_context);
rhs.include_directive = rhs.replacement;
// No need to emit a rewrite for auto type variables. They still need to
// appear in the graph to propagate the rewrite to non-auto type nodes
// codes connected to them.
rhs.has_auto_type = true;
} else { // Not supposed to get here
assert(false);
}
output_helper_.AddEdge(lhs, rhs);
}
private:
OutputHelper& output_helper_;
};
// Called when the Match registered for it was successfully found in the AST.
// The match represents a parmVarDecl Node or an RTNode and the corresponding
// function declaration. Using the function declaration:
// 1- Create a unique key `current_key`
// 2- if the function has a previous declaration or is overridden,
// retrieve previous decls and create their keys `prev_key`
// 3- for each `prev_key`, add pair `current_key`, `prev_key` to
// `fct_sig_pairs_`
//
// Using the parmVarDecl or RTNode:
// 1- Create a node
// 2- insert node into `fct_sig_nodes_[current_key]`
//
// At the end of the tool run for a given translation unit, edges between
// corresponding nodes of two adjacent function signatures are created.
class FunctionSignatureNodes : public MatchFinder::MatchCallback {
public:
explicit FunctionSignatureNodes(
std::map<std::string, std::set<Node>>& sig_nodes,
std::vector<std::pair<std::string, std::string>>& sig_pairs)
: fct_sig_nodes_(sig_nodes), fct_sig_pairs_(sig_pairs) {}
FunctionSignatureNodes(const FunctionSignatureNodes&) = delete;
FunctionSignatureNodes& operator=(const FunctionSignatureNodes&) = delete;
// Key here means a unique string generated from a function signature
std::string GetKey(const clang::FunctionDecl* fct_decl,
const clang::SourceManager& source_manager) {
auto name = fct_decl->getNameInfo().getName().getAsString();
clang::SourceLocation start_loc = fct_decl->getBeginLoc();
// This is done here to get the spelling loc of a functionDecl. This is
// needed to handle cases where the function is in a Macro Expansion. In
// that case, multiple functionDecls will have the same location and this
// will create problems for argument mapping. Example:
// MOCK_METHOD0(GetAllStreams, std::vector<DemuxerStream*>());
clang::SourceRange replacement_range(source_manager.getFileLoc(start_loc),
source_manager.getFileLoc(start_loc));
clang::tooling::Replacement replacement(
source_manager, clang::CharSourceRange::getCharRange(replacement_range),
name.c_str());
llvm::StringRef file_path = replacement.getFilePath();
return llvm::formatv("r:::{0}:::{1}:::{2}:::{3}", file_path,
replacement.getOffset(), replacement.getLength(),
name.c_str());
}
void run(const MatchFinder::MatchResult& result) override {
const clang::SourceManager& source_manager = *result.SourceManager;
const clang::ASTContext& ast_context = *result.Context;
const clang::FunctionDecl* fct_decl =
result.Nodes.getNodeAs<clang::FunctionDecl>("fct_decl");
std::string key = GetKey(fct_decl, source_manager);
if (auto* prev_decl = fct_decl->getPreviousDecl()) {
std::string prev_key = GetKey(prev_decl, source_manager);
fct_sig_pairs_.push_back({prev_key, key});
}
if (const clang::CXXMethodDecl* method_decl =
result.Nodes.getNodeAs<clang::CXXMethodDecl>("fct_decl")) {
for (auto* m : method_decl->overridden_methods()) {
std::string prev_key = GetKey(m, source_manager);
fct_sig_pairs_.push_back({prev_key, key});
}
}
auto* type_loc =
result.Nodes.getNodeAs<clang::PointerTypeLoc>("rhs_argPointerLoc");
Node rhs;
std::string replacement_text =
GenerateNewType(ast_context, type_loc->getType());
const clang::TemplateSpecializationTypeLoc* tst_loc =
result.Nodes.getNodeAs<clang::TemplateSpecializationTypeLoc>(
"rhs_tst_loc");
auto p = GetReplacementAndIncludeDirectives(
type_loc, tst_loc, replacement_text, source_manager);
rhs.replacement = p.first;
rhs.include_directive = p.second;
fct_sig_nodes_[key].insert(rhs);
}
private:
// Map a function signature, which is modeled as a string representing file
// location, to it's matched graph nodes (RTNode and ParmVarDecl nodes).
// Note: `RTNode` represents a function return type node.
// In order to avoid relying on the order with which nodes are matched in the
// AST, and to guarantee that nodes are stored in the file declaration order,
// we use a `std::set<Node>` which sorts Nodes based on the replacement
// directive which contains the file offset of a given node.
// Note that a replacement directive has the following format:
// `r:::<file path>:::<offset>:::<length>:::<replacement text>`
// The order is important because at the end of a tool run on a
// translationUnit, for each pair of function signatures, we iterate
// concurrently through the two sets of Nodes creating edges between nodes
// that appear at the same index.
// AddEdge(first function's node1, second function's node1)
// AddEdge(first function's node2, second function's node2)
// and so on...
std::map<std::string, std::set<Node>>& fct_sig_nodes_;
// Map related function signatures to each other, this is needed for functions
// with separate definition and declaration, and for overridden functions.
std::vector<std::pair<std::string, std::string>>& fct_sig_pairs_;
};
// Called when the Match registered for it was successfully found in the AST.
// The matches registered represent three categories:
// 1- Range-based for loops of the form:
// for (auto* i : ctn_expr) => for (type_name* i : ctn_expr)
//
// 2- Expressions of the form:
// auto* var = ctn_expr.front(); => auto* var = ctn_expr.front().get();
//
// 3- Expressions of the form:
// auto* var = ctn_expr[index]; => auto* var = ctn_expr[index].get();
//
// In each of the above cases a node pair is created and added to node_pairs
// using `OutputHelper::AddEdge`
class AffectedPtrExprRewriter : public MatchFinder::MatchCallback {
public:
explicit AffectedPtrExprRewriter(OutputHelper& helper)
: output_helper_(helper) {}
AffectedPtrExprRewriter(const AffectedPtrExprRewriter&) = delete;
AffectedPtrExprRewriter& operator=(const AffectedPtrExprRewriter&) = delete;
void run(const MatchFinder::MatchResult& result) override {
const clang::SourceManager& source_manager = *result.SourceManager;
const clang::ASTContext& ast_context = *result.Context;
Node lhs;
if (const clang::VarDecl* var_decl =
result.Nodes.getNodeAs<clang::VarDecl>("autoVarDecl")) {
auto* type_loc = result.Nodes.getNodeAs<clang::TypeLoc>("autoLoc");
clang::SourceRange replacement_range(var_decl->getBeginLoc(),
type_loc->getEndLoc());
std::string replacement_text =
var_decl->getType()->getPointeeType().getAsString();
replacement_text = RemovePrefix(replacement_text);
lhs.replacement = getReplacementDirective(
replacement_text, replacement_range, source_manager, ast_context);
lhs.include_directive = lhs.replacement;
} else if (const clang::CXXMemberCallExpr* member_expr =
result.Nodes.getNodeAs<clang::CXXMemberCallExpr>(
"affectedMemberExpr")) {
clang::SourceLocation insertion_loc =
member_expr->getEndLoc().getLocWithOffset(1);
clang::SourceRange replacement_range(insertion_loc, insertion_loc);
std::string replacement_text = ".get()";
lhs.replacement = getReplacementDirective(
replacement_text, replacement_range, source_manager, ast_context);
lhs.include_directive = lhs.replacement;
} else if (const clang::CXXOperatorCallExpr* op_call_expr =
result.Nodes.getNodeAs<clang::CXXOperatorCallExpr>(
"affectedOpCall")) {
clang::SourceLocation insertion_loc =
op_call_expr->getEndLoc().getLocWithOffset(1);
clang::SourceRange replacement_range(insertion_loc, insertion_loc);
std::string replacement_text = ".get()";
lhs.replacement = getReplacementDirective(
replacement_text, replacement_range, source_manager, ast_context);
lhs.include_directive = lhs.replacement;
} else if (const clang::ParmVarDecl* var_decl =
result.Nodes.getNodeAs<clang::ParmVarDecl>(
"lambda_parmVarDecl")) {
auto* type_loc =
result.Nodes.getNodeAs<clang::TypeLoc>("template_type_param_loc");
auto* md = result.Nodes.getNodeAs<clang::CXXMethodDecl>("md");
clang::SourceRange replacement_range(var_decl->getBeginLoc(),
type_loc->getEndLoc());
std::string replacement_text =
(md->getParamDecl(var_decl->getFunctionScopeIndex()))
->getType()
->getPointeeType()
.getAsString();
replacement_text = RemovePrefix(replacement_text);
lhs.replacement = getReplacementDirective(
replacement_text, replacement_range, source_manager, ast_context);
lhs.include_directive = lhs.replacement;
}
Node rhs;
if (const clang::FieldDecl* field_decl =
result.Nodes.getNodeAs<clang::FieldDecl>("rhs_field")) {
rhs.is_field = true;
}
if (auto* type_loc = result.Nodes.getNodeAs<clang::PointerTypeLoc>(
"rhs_argPointerLoc")) {
std::string replacement_text =
GenerateNewType(ast_context, type_loc->getType());
const clang::TemplateSpecializationTypeLoc* tst_loc =
result.Nodes.getNodeAs<clang::TemplateSpecializationTypeLoc>(
"rhs_tst_loc");
auto p = GetReplacementAndIncludeDirectives(
type_loc, tst_loc, replacement_text, source_manager);
rhs.replacement = p.first;
rhs.include_directive = p.second;
} else if (const clang::TypeLoc* auto_loc =
result.Nodes.getNodeAs<clang::TypeLoc>("rhs_auto_loc")) {
rhs.replacement = GenerateReplacementForAutoLoc(
auto_loc, "replacement_text", source_manager, ast_context);
rhs.include_directive = rhs.replacement;
rhs.has_auto_type = true;
} else {
// Should not get here.
assert(false);
}
output_helper_.AddEdge(lhs, rhs);
}
private:
std::string getReplacementDirective(
std::string& replacement_text,
clang::SourceRange replacement_range,
const clang::SourceManager& source_manager,
const clang::ASTContext& ast_context) {
clang::tooling::Replacement replacement(
source_manager, clang::CharSourceRange::getCharRange(replacement_range),
replacement_text);
llvm::StringRef file_path = replacement.getFilePath();
std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
return llvm::formatv("r:::{0}:::{1}:::{2}:::{3}", file_path,
replacement.getOffset(), replacement.getLength(),
replacement_text);
}
OutputHelper& output_helper_;
};
class ExprVisitor
: public clang::ast_matchers::internal::BoundNodesTreeBuilder::Visitor {
public:
void visitMatch(
const clang::ast_matchers::BoundNodes& BoundNodesView) override {
expr_ = BoundNodesView.getNodeAs<clang::Expr>("expr");
}
const clang::Expr* expr_;
};
const clang::Expr* getExpr(
clang::ast_matchers::internal::BoundNodesTreeBuilder& matches) {
ExprVisitor v;
matches.visitMatches(&v);
return v.expr_;
}
// The goal of this matcher is to handle all possible combinations of matching
// expressions. This works by unpacking the expression nodes recursively (in any
// order they appear in) until we reach the matching lhs_expr/rhs_expr. This
// allows to handle cases like the following:
// std::map<int, std::vector<S*>> member;
// std::vector<S*>::iterator it = member.begin()->second;
AST_MATCHER_P(clang::Expr,
expr_variations,
clang::ast_matchers::internal::Matcher<clang::Expr>,
InnerMatcher) {
auto iterator = cxxMemberCallExpr(
callee(functionDecl(
anyOf(hasName("begin"), hasName("cbegin"), hasName("rbegin"),
hasName("crbegin"), hasName("end"), hasName("cend"),
hasName("rend"), hasName("crend"), hasName("find"),
hasName("upper_bound"), hasName("lower_bound"),
hasName("equal_range"), hasName("emplace"), hasName("Get")))),
has(memberExpr(has(expr().bind("expr")))));
auto search_calls = callExpr(callee(functionDecl(matchesName("find"))),
hasArgument(0, expr().bind("expr")));
auto unary_op = unaryOperator(has(expr().bind("expr")));
auto reversed_expr = callExpr(callee(functionDecl(hasName("base::Reversed"))),
hasArgument(0, expr().bind("expr")));
auto bracket_op_call = cxxOperatorCallExpr(
has(declRefExpr(to(cxxMethodDecl(hasName("operator[]"))))),
has(expr(unless(declRefExpr(to(cxxMethodDecl(hasName("operator[]"))))))
.bind("expr")));
auto arrow_op_call = cxxOperatorCallExpr(
has(declRefExpr(to(cxxMethodDecl(hasName("operator->"))))),
has(expr(unless(declRefExpr(to(cxxMethodDecl(hasName("operator->"))))))
.bind("expr")));
auto star_op_call = cxxOperatorCallExpr(
has(declRefExpr(to(cxxMethodDecl(hasName("operator*"))))),
has(expr(unless(declRefExpr(to(cxxMethodDecl(hasName("operator*"))))))
.bind("expr")));
auto second_member =
memberExpr(member(hasName("second")), has(expr().bind("expr")));
auto items = {iterator, search_calls, unary_op, reversed_expr,
bracket_op_call, arrow_op_call, star_op_call, second_member};
clang::ast_matchers::internal::BoundNodesTreeBuilder matches;
const clang::Expr* n = nullptr;
std::any_of(items.begin(), items.end(), [&](auto& item) {
if (item.matches(Node, Finder, &matches)) {
n = getExpr(matches);
return true;
}
return false;
});
if (n) {
auto matcher = expr_variations(InnerMatcher);
return matcher.matches(*n, Finder, Builder);
}
return InnerMatcher.matches(Node, Finder, Builder);
}
class DeclVisitor
: public clang::ast_matchers::internal::BoundNodesTreeBuilder::Visitor {
public:
void visitMatch(
const clang::ast_matchers::BoundNodes& BoundNodesView) override {
decl_ = BoundNodesView.getNodeAs<clang::TypedefNameDecl>("decl");
}
const clang::TypedefNameDecl* decl_;
};
const clang::TypedefNameDecl* getDecl(
clang::ast_matchers::internal::BoundNodesTreeBuilder& matches) {
DeclVisitor v;
matches.visitMatches(&v);
return v.decl_;
}
// This allows us to unpack typedefs recursively until we reach the node
// matching InnerMatcher.
// Example:
// using VECTOR = std::vector<S*>;
// using MAP = std::map<int, VECTOR>;
// MAP member; => this will lead to VECTOR being rewritten.
AST_MATCHER_P(clang::TypedefNameDecl,
type_def_name_decl,
clang::ast_matchers::internal::Matcher<clang::TypedefNameDecl>,
InnerMatcher) {
auto type_def_matcher = typedefNameDecl(
hasDescendant(loc(qualType(hasDeclaration(
typedefNameDecl(unless(isExpansionInSystemHeader())).bind("decl"))))),
unless(isExpansionInSystemHeader()));
clang::ast_matchers::internal::BoundNodesTreeBuilder matches;
if (type_def_matcher.matches(Node, Finder, &matches)) {
const clang::TypedefNameDecl* n = getDecl(matches);
auto matcher = type_def_name_decl(InnerMatcher);
return matcher.matches(*n, Finder, Builder);
}
return InnerMatcher.matches(Node, Finder, Builder);
}
class ContainerRewriter {
public:
explicit ContainerRewriter(
MatchFinder& finder,
OutputHelper& output_helper,
std::map<std::string, std::set<Node>>& sig_nodes,
std::vector<std::pair<std::string, std::string>>& sig_pairs,
const raw_ptr_plugin::FilterFile* excluded_paths)
: match_finder_(finder),
affected_ptr_expr_rewriter_(output_helper),
potentail_nodes_(output_helper),
fct_sig_nodes_(sig_nodes, sig_pairs),
paths_to_exclude(excluded_paths) {}
void addMatchers() {
// Assume every container has the three following methods: begin, end, size
auto container_methods =
anyOf(allOf(hasMethod(hasName("push_back")),
hasMethod(hasName("pop_back")), hasMethod(hasName("size"))),
allOf(hasMethod(hasName("insert")), hasMethod(hasName("erase")),
hasMethod(hasName("size"))),
allOf(hasMethod(hasName("push")), hasMethod(hasName("pop")),
hasMethod(hasName("size"))));
// Exclude maps as they need special handling to be rewritten.
// TODO: handle rewriting maps.
auto excluded_containers = matchesName("map");
auto supported_containers = anyOf(
hasDeclaration(classTemplateSpecializationDecl(
container_methods, unless(excluded_containers))),
hasDeclaration(typeAliasTemplateDecl(has(typeAliasDecl(
hasType(qualType(hasDeclaration(classTemplateDecl(has(cxxRecordDecl(
container_methods, unless(excluded_containers))))))))))));
auto tst_type_loc = templateSpecializationTypeLoc(
loc(qualType(supported_containers)),
hasTemplateArgumentLoc(
0, hasTypeLoc(loc(qualType(allOf(
raw_ptr_plugin::supported_pointer_type(),
unless(raw_ptr_plugin::const_char_pointer_type(false))))))));
auto lhs_location =
templateSpecializationTypeLoc(
tst_type_loc,
hasTemplateArgumentLoc(
0, hasTypeLoc(pointerTypeLoc().bind("lhs_argPointerLoc"))))
.bind("lhs_tst_loc");
auto rhs_location =
templateSpecializationTypeLoc(
tst_type_loc,
hasTemplateArgumentLoc(
0, hasTypeLoc(pointerTypeLoc().bind("rhs_argPointerLoc"))))
.bind("rhs_tst_loc");
auto exclude_callbacks = anyOf(
hasType(typedefNameDecl(hasType(qualType(hasDeclaration(
recordDecl(anyOf(hasName("base::RepeatingCallback"),
hasName("base::OnceCallback")))))))),
hasType(qualType(
hasDeclaration(recordDecl(anyOf(hasName("base::RepeatingCallback"),
hasName("base::OnceCallback")))))));
auto field_exclusions =
anyOf(isExpansionInSystemHeader(), raw_ptr_plugin::isInExternCContext(),
raw_ptr_plugin::isInThirdPartyLocation(),
raw_ptr_plugin::isInGeneratedLocation(),
raw_ptr_plugin::ImplicitFieldDeclaration(), exclude_callbacks,
// Exclude fieldDecls in macros.
// `raw_ptr_plugin::isInMacroLocation()` is also true for fields
// annotated with RAW_PTR_EXCLUSION. The annotated fields are not
// included in `field_exclusions` as they are handled differently
// by the `excluded_field_decl` matcher.
allOf(raw_ptr_plugin::isInMacroLocation(),
unless(raw_ptr_plugin::isRawPtrExclusionAnnotated())));
// Supports typedefs as well.
auto lhs_type_loc =
anyOf(hasDescendant(loc(qualType(hasDeclaration(typedefNameDecl(
type_def_name_decl(hasDescendant(lhs_location))))))),
hasDescendant(lhs_location));
// Supports typedefs as well.
auto rhs_type_loc =
anyOf(hasDescendant(loc(qualType(hasDeclaration(typedefNameDecl(
type_def_name_decl(hasDescendant(rhs_location))))))),
hasDescendant(rhs_location));
auto lhs_field =
fieldDecl(raw_ptr_plugin::hasExplicitFieldDecl(lhs_type_loc),
unless(field_exclusions))
.bind("lhs_field");
auto rhs_field =
fieldDecl(raw_ptr_plugin::hasExplicitFieldDecl(rhs_type_loc),
unless(field_exclusions))
.bind("rhs_field");
auto lhs_var = anyOf(
varDecl(hasDescendant(loc(qualType(autoType())).bind("lhs_auto_loc"))),
varDecl(lhs_type_loc).bind("lhs_var"));
auto rhs_var = anyOf(
varDecl(hasDescendant(loc(qualType(autoType())).bind("rhs_auto_loc"))),
varDecl(rhs_type_loc).bind("rhs_var"));
auto lhs_param =
parmVarDecl(raw_ptr_plugin::hasExplicitParmVarDecl(lhs_type_loc))
.bind("lhs_param");
auto rhs_param =
parmVarDecl(raw_ptr_plugin::hasExplicitParmVarDecl(rhs_type_loc))
.bind("rhs_param");
auto rhs_call_expr =
callExpr(callee(functionDecl(hasReturnTypeLoc(rhs_type_loc))));
auto lhs_call_expr =
callExpr(callee(functionDecl(hasReturnTypeLoc(lhs_type_loc))));
auto lhs_expr = expr(
ignoringImpCasts(anyOf(declRefExpr(to(anyOf(lhs_var, lhs_param))),
memberExpr(member(lhs_field)), lhs_call_expr)));
auto rhs_expr = expr(
ignoringImpCasts(anyOf(declRefExpr(to(anyOf(rhs_var, rhs_param))),
memberExpr(member(rhs_field)), rhs_call_expr)));
// To make sure we add all field decls to the graph.(Specifically those not
// connected to other nodes)
auto field_decl =
fieldDecl(raw_ptr_plugin::hasExplicitFieldDecl(lhs_type_loc),
unless(anyOf(field_exclusions,
raw_ptr_plugin::isRawPtrExclusionAnnotated())))
.bind("field_decl");
match_finder_.addMatcher(field_decl, &potentail_nodes_);
// Fields annotated with RAW_PTR_EXCLUSION (as well as fields in excluded
// paths) cannot be filtered using field exclusions. They need to appear in
// the graph so that we can properly propagate the exclusion to reachable
// nodes. For this reason, and in order to capture this information,
// RAW_PTR_EXCLUSION fields are added as single nodes to the list and then
// used as a starting point to propagate the exclusion before running dfs on
// the graph.
auto excluded_field_decl =
fieldDecl(raw_ptr_plugin::hasExplicitFieldDecl(lhs_type_loc),
anyOf(raw_ptr_plugin::isRawPtrExclusionAnnotated(),
isInLocationListedInFilterFile(paths_to_exclude)))
.bind("excluded_field_decl");
match_finder_.addMatcher(excluded_field_decl, &potentail_nodes_);
auto ref_cref_move =
anyOf(hasName("std::move"), hasName("std::ref"), hasName("std::cref"));
auto rhs_move_call =
callExpr(callee(functionDecl(ref_cref_move)), hasArgument(0, rhs_expr));
// This is needed for ternary cond operator true_expr. (cond) ? true_expr :
// false_expr;
auto lhs_move_call =
callExpr(callee(functionDecl(ref_cref_move)), hasArgument(0, lhs_expr));
auto rhs_cxx_temp_expr = cxxTemporaryObjectExpr(rhs_type_loc);
auto lhs_cxx_temp_expr = cxxTemporaryObjectExpr(lhs_type_loc);
// This represents the forms under which an expr could appear on the right
// hand side of an assignment operation, var construction, or an expr passed
// as callExpr argument. Examples: rhs_expr, &rhs_expr, *rhs_expr,
// fct_call(),*fct_call(), &fct_call(), std::move(), .begin();
auto rhs_expr_variations =
expr_variations(anyOf(rhs_expr, rhs_move_call, rhs_cxx_temp_expr));
auto lhs_expr_variations =
expr_variations(anyOf(lhs_expr, lhs_move_call, lhs_cxx_temp_expr));
// rewrite affected expressions
{
// This is needed to handle container-like types that implement a begin()
// method. Range-based for loops over such types also need to be
// rewritten.
auto ctn_like_type =
expr(hasType(cxxRecordDecl(has(functionDecl(
hasName("begin"), hasReturnTypeLoc(rhs_type_loc))))),
unless(isExpansionInSystemHeader()));
auto reversed_expr =
callExpr(callee(functionDecl(hasName("base::Reversed"))),
hasArgument(0, rhs_expr_variations));
// handles statements of the form: for (auto* i : member/var/param/fct())
// that should be modified after rewriting the container.
auto auto_star_in_range_stmt = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
cxxForRangeStmt(
has(varDecl(hasDescendant(loc(qualType(pointsTo(autoType())))
.bind("autoLoc")))
.bind("autoVarDecl")),
has(expr(
anyOf(rhs_expr_variations, reversed_expr, ctn_like_type)))));
match_finder_.addMatcher(auto_star_in_range_stmt,
&affected_ptr_expr_rewriter_);
// handles expressions of the form: auto* var = member.front();
// This becomes: auto* var = member.front().get();
auto affected_expr = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
declStmt(has(varDecl(
hasType(pointsTo(autoType())),
has(cxxMemberCallExpr(
callee(
functionDecl(anyOf(hasName("front"), hasName("back"),
hasName("at"), hasName("top")))),
has(memberExpr(has(expr(rhs_expr_variations)))))
.bind("affectedMemberExpr"))))));
match_finder_.addMatcher(affected_expr, &affected_ptr_expr_rewriter_);
// handles expressions of the form: auto* var = member[0];
// This becomes: auto* var = member[0].get();
auto affected_op_call =
traverse(clang::TK_IgnoreUnlessSpelledInSource,
declStmt(has(varDecl(
hasType(pointsTo(autoType())),
has(cxxOperatorCallExpr(has(expr(rhs_expr_variations)))
.bind("affectedOpCall"))))));
match_finder_.addMatcher(affected_op_call, &affected_ptr_expr_rewriter_);
// handles expressions of the form:
// base::ranges::any_of(view->children(), [](const auto* v) {
// ...
// });
// where auto* needs to be rewritten into type_name*.
auto range_exprs = callExpr(
callee(functionDecl(anyOf(
matchesName("find"), matchesName("any_of"), matchesName("all_of"),
matchesName("transform"), matchesName("copy"),
matchesName("accumulate"), matchesName("count")))),
hasArgument(0, traverse(clang::TK_IgnoreUnlessSpelledInSource,
expr(anyOf(rhs_expr_variations, reversed_expr,
ctn_like_type)))),
hasAnyArgument(expr(allOf(
traverse(
clang::TK_IgnoreUnlessSpelledInSource,
lambdaExpr(
has(parmVarDecl(
hasTypeLoc(loc(qualType(anything()))
.bind("template_type_param_loc")),
hasType(pointsTo(templateTypeParmType())))
.bind("lambda_parmVarDecl")))
.bind("lambda_expr")),
lambdaExpr(has(cxxRecordDecl(has(functionTemplateDecl(has(
cxxMethodDecl(isTemplateInstantiation()).bind("md")))))))))));
match_finder_.addMatcher(range_exprs, &affected_ptr_expr_rewriter_);
}
// needed for ternary operator expr: (cond) ? true_expr : false_expr;
// true_expr => lhs; false_expr => rhs;
// creates a link between false_expr and true_expr of a ternary conditional
// operator;
// handles:
// (cond) ? (a/&a/*a/std::move(a)/fct()/*fct()/&fct()/a.begin()) :
// (b/&b/*b/std::move(b)/fct()/*fct()/&fct()/b.begin())
auto ternary_cond_expr =
traverse(clang::TK_IgnoreUnlessSpelledInSource,
conditionalOperator(hasTrueExpression(lhs_expr_variations),
hasFalseExpression(rhs_expr_variations),
unless(isExpansionInSystemHeader())));
match_finder_.addMatcher(ternary_cond_expr, &potentail_nodes_);
// Handles assignment:
// a = b;
// a = &b;
// *a = b;
// *a = *b;
// a = fct();
// a = *fct();
// a = std::move(b);
// a = &fct();
// it = member.begin();
// a = vector<S*>();
// a = (cond) ? expr1 : expr2;
auto assignement_relationship = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
binaryOperation(hasOperatorName("="),
hasOperands(lhs_expr_variations,
anyOf(rhs_expr_variations,
conditionalOperator(hasTrueExpression(
rhs_expr_variations)))),
unless(isExpansionInSystemHeader())));
match_finder_.addMatcher(assignement_relationship, &potentail_nodes_);
// Supports:
// std::vector<T*>* temp = &member;
// std::vector<T*>& temp = member;
// std::vector<T*> temp = *member;
// std::vector<T*> temp = member; and other similar stmts.
// std::vector<T*> temp = init();
// std::vector<T*> temp = *fct();
// std::vector<T*>::iterator it = member.begin();
// std::vector<T*> temp = (cond) ? expr1 : expr2;
auto var_construction = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
varDecl(
lhs_var,
has(expr(anyOf(
rhs_expr_variations,
conditionalOperator(hasTrueExpression(rhs_expr_variations)),
cxxConstructExpr(has(expr(anyOf(
rhs_expr_variations, conditionalOperator(hasTrueExpression(
rhs_expr_variations))))))))),
unless(isExpansionInSystemHeader())));
match_finder_.addMatcher(var_construction, &potentail_nodes_);
// Supports:
// return member;
// return *member;
// return &member;
// return fct();
// return *fct();
// return std::move(member);
// return member.begin();
// return (cond) ? expr1 : expr2;
auto returned_var_or_member = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
returnStmt(
hasReturnValue(expr(anyOf(
rhs_expr_variations,
conditionalOperator(hasTrueExpression(rhs_expr_variations))))),
unless(isExpansionInSystemHeader()),
forFunction(functionDecl(hasReturnTypeLoc(lhs_type_loc))
.bind("lhs_fct_return")))
.bind("lhs_stmt"));
match_finder_.addMatcher(returned_var_or_member, &potentail_nodes_);
// Handles expressions of the form member(arg).
// A(const std::vector<T*>& arg): member(arg){}
// member(init());
// member(*fct());
// member2(&member1);
auto ctor_initilizer = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
cxxCtorInitializer(withInitializer(anyOf(
cxxConstructExpr(has(expr(rhs_expr_variations))),
rhs_expr_variations)),
forField(lhs_field)));
match_finder_.addMatcher(ctor_initilizer, &potentail_nodes_);
// link var/field passed as function arguments to function parameter
// This handles func(var/member/param), func(&var/member/param),
// func(*var/member/param), func(func2()), func(&func2())
// cxxOpCallExprs excluded here since operator= can be invoked as a call
// expr for classes/structs.
auto call_expr = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
callExpr(forEachArgumentWithParam(
expr(anyOf(rhs_expr_variations,
conditionalOperator(
hasTrueExpression(rhs_expr_variations)))),
lhs_param),
unless(isExpansionInSystemHeader()),
unless(cxxOperatorCallExpr(hasOperatorName("=")))));
match_finder_.addMatcher(call_expr, &potentail_nodes_);
// Handles: member.swap(temp); temp.swap(member);
auto member_swap_call = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
cxxMemberCallExpr(callee(functionDecl(hasName("swap"))),
hasArgument(0, rhs_expr_variations),
has(memberExpr(has(expr(lhs_expr_variations)))),
unless(isExpansionInSystemHeader())));
match_finder_.addMatcher(member_swap_call, &potentail_nodes_);
// Handles: std::swap(member, temp); std::swap(temp, member);
auto std_swap_call =
traverse(clang::TK_IgnoreUnlessSpelledInSource,
callExpr(callee(functionDecl(hasName("std::swap"))),
hasArgument(0, lhs_expr_variations),
hasArgument(1, rhs_expr_variations),
unless(isExpansionInSystemHeader())));
match_finder_.addMatcher(std_swap_call, &potentail_nodes_);
auto assert_expect_eq =
traverse(clang::TK_IgnoreUnlessSpelledInSource,
callExpr(anyOf(isExpandedFromMacro("EXPECT_EQ"),
isExpandedFromMacro("ASSERT_EQ")),
hasArgument(2, lhs_expr_variations),
hasArgument(3, rhs_expr_variations),
unless(isExpansionInSystemHeader())));
match_finder_.addMatcher(assert_expect_eq, &potentail_nodes_);
// Supports:
// std::vector<S*> temp;
// Obj o(temp); Obj o{temp};
// This links temp to the parameter in Obj's constructor.
auto var_passed_in_constructor = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
cxxConstructExpr(forEachArgumentWithParam(
expr(anyOf(
rhs_expr_variations,
conditionalOperator(hasTrueExpression(rhs_expr_variations)))),
lhs_param)));
match_finder_.addMatcher(var_passed_in_constructor, &potentail_nodes_);
// handles Obj o{temp} when Obj has no constructor.
// This creates a link between the expr and the underlying field.
auto var_passed_in_initlistExpr = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
initListExpr(raw_ptr_plugin::forEachInitExprWithFieldDecl(
expr(anyOf(
rhs_expr_variations,
conditionalOperator(hasTrueExpression(rhs_expr_variations)))),
lhs_field)));
match_finder_.addMatcher(var_passed_in_initlistExpr, &potentail_nodes_);
// This creates a link between each argument passed to the make_unique call
// and the corresponding constructor parameter.
auto make_unique_call = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
callExpr(
callee(functionDecl(hasName("std::make_unique"))),
forEachArg(
expr(rhs_expr_variations,
hasParent(callExpr(
callee(functionDecl(hasDescendant(cxxConstructExpr(
has(cxxNewExpr(has(cxxConstructExpr(hasDeclaration(
functionDecl().bind("fct_decl"))))))))))))),
lhs_param)));
match_finder_.addMatcher(make_unique_call, &potentail_nodes_);
// This creates a link between lhs and an argument passed to emplace.
// Example:
// std::map<int, std::vector<S*>> m;
// m.emplace(index, o.member);
// where member has type std::vector<S*>;
auto emplace_call_with_arg =
traverse(clang::TK_IgnoreUnlessSpelledInSource,
cxxMemberCallExpr(callee(functionDecl(hasName("emplace"))),
has(memberExpr(has(rhs_expr_variations))),
hasAnyArgument(lhs_expr_variations)));
match_finder_.addMatcher(emplace_call_with_arg, &potentail_nodes_);
// Handle BindOnce/BindRepeating;
auto first_arg = hasParent(callExpr(hasArgument(
0, anyOf(lambdaExpr().bind("lambda_expr"),
unaryOperator(
has(declRefExpr(to(functionDecl().bind("fct_decl")))))))));
auto bind_args = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
callExpr(
callee(functionDecl(
anyOf(hasName("BindOnce"), hasName("BindRepeating")))),
forEachBindArg(expr(rhs_expr_variations, first_arg), lhs_param)));
match_finder_.addMatcher(bind_args, &potentail_nodes_);
// This is useful to handle iteration over maps with vector as value.
// Example:
// std::vector<int, std::vector<S*>> m;
// for (auto& p : m){
// ...
// }
// This creates a link between p and m.
auto for_range_stmts = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
cxxForRangeStmt(
hasLoopVariable(decl(lhs_var, unless(has(pointerTypeLoc())))),
hasRangeInit(rhs_expr_variations)));
match_finder_.addMatcher(for_range_stmts, &potentail_nodes_);
// Map function declaration signature to function definition signature;
// This is problematic in the case of callbacks defined in function.
auto fct_decls_params = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
functionDecl(forEachParmVarDecl(rhs_param),
unless(anyOf(isExpansionInSystemHeader(),
raw_ptr_plugin::isInMacroLocation())))
.bind("fct_decl"));
match_finder_.addMatcher(fct_decls_params, &fct_sig_nodes_);
auto fct_decls_returns = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
functionDecl(hasReturnTypeLoc(rhs_type_loc),
unless(anyOf(isExpansionInSystemHeader(),
raw_ptr_plugin::isInMacroLocation())))
.bind("fct_decl"));
match_finder_.addMatcher(fct_decls_returns, &fct_sig_nodes_);
auto macro_fct_signatures = traverse(
clang::TK_IgnoreUnlessSpelledInSource,
templateSpecializationTypeLoc(
rhs_location,
hasAncestor(
cxxMethodDecl(raw_ptr_plugin::isInMacroLocation(),
anyOf(isExpandedFromMacro("MOCK_METHOD"),
isExpandedFromMacro("MOCK_METHOD0"),
isExpandedFromMacro("MOCK_METHOD1"),
isExpandedFromMacro("MOCK_METHOD2"),
isExpandedFromMacro("MOCK_METHOD3"),
isExpandedFromMacro("MOCK_METHOD4"),
isExpandedFromMacro("MOCK_METHOD5"),
isExpandedFromMacro("MOCK_METHOD6"),
isExpandedFromMacro("MOCK_METHOD7"),
isExpandedFromMacro("MOCK_METHOD8"),
isExpandedFromMacro("MOCK_METHOD9"),
isExpandedFromMacro("MOCK_METHOD10"),
isExpandedFromMacro("MOCK_CONST_METHOD0"),
isExpandedFromMacro("MOCK_CONST_METHOD1"),
isExpandedFromMacro("MOCK_CONST_METHOD2"),
isExpandedFromMacro("MOCK_CONST_METHOD3"),
isExpandedFromMacro("MOCK_CONST_METHOD4"),
isExpandedFromMacro("MOCK_CONST_METHOD5"),
isExpandedFromMacro("MOCK_CONST_METHOD6"),
isExpandedFromMacro("MOCK_CONST_METHOD7"),
isExpandedFromMacro("MOCK_CONST_METHOD8"),
isExpandedFromMacro("MOCK_CONST_METHOD9"),
isExpandedFromMacro("MOCK_CONST_METHOD10")),
unless(isExpansionInSystemHeader()))
.bind("fct_decl"))));
match_finder_.addMatcher(macro_fct_signatures, &fct_sig_nodes_);
// TODO: handle calls to templated functions
}
private:
MatchFinder& match_finder_;
AffectedPtrExprRewriter affected_ptr_expr_rewriter_;
PotentialNodes potentail_nodes_;
FunctionSignatureNodes fct_sig_nodes_;
const raw_ptr_plugin::FilterFile* paths_to_exclude;
};
} // namespace
int main(int argc, const char* argv[]) {
llvm::InitializeNativeTarget();
llvm::InitializeNativeTargetAsmParser();
llvm::cl::OptionCategory category(
"rewrite_templated_container_fields: changes |vector<T*> field_| to "
"|vector<raw_ptr<T>> field_|.");
llvm::cl::opt<std::string> override_exclude_paths_param(
kOverrideExcludePathsParamName, llvm::cl::value_desc("filepath"),
llvm::cl::desc(
"override file listing paths to be blocked (not rewritten)"));
llvm::Expected<clang::tooling::CommonOptionsParser> options =
clang::tooling::CommonOptionsParser::create(argc, argv, category);
assert(static_cast<bool>(options)); // Should not return an error.
clang::tooling::ClangTool tool(options->getCompilations(),
options->getSourcePathList());
std::unique_ptr<raw_ptr_plugin::FilterFile> paths_to_exclude;
if (override_exclude_paths_param.getValue().empty()) {
std::vector<std::string> paths_to_exclude_lines;
for (auto* const line : kRawPtrManualPathsToIgnore) {
paths_to_exclude_lines.push_back(line);
}
for (auto* const line : kSeparateRepositoryPaths) {
paths_to_exclude_lines.push_back(line);
}
paths_to_exclude =
std::make_unique<raw_ptr_plugin::FilterFile>(paths_to_exclude_lines);
} else {
paths_to_exclude = std::make_unique<raw_ptr_plugin::FilterFile>(
override_exclude_paths_param,
override_exclude_paths_param.ArgStr.str());
}
// Map a function signature, which is modeled as a string representing file
// location, to it's graph nodes (RTNode and ParmVarDecl nodes).
// RTNode represents a function return type.
std::map<std::string, std::set<Node>> fct_sig_nodes;
// Map related function signatures to each other, this is needed for functions
// with separate definition and declaration, and for overridden functions.
std::vector<std::pair<std::string, std::string>> fct_sig_pairs;
OutputHelper output_helper;
MatchFinder match_finder;
ContainerRewriter rewriter(match_finder, output_helper, fct_sig_nodes,
fct_sig_pairs, paths_to_exclude.get());
rewriter.addMatchers();
// Prepare and run the tool.
std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
clang::tooling::newFrontendActionFactory(&match_finder);
int result = tool.run(factory.get());
// For each pair of adjacent function signatures, create a link between
// corresponding parameters.
// 2 functions are said to be adjacent if one overrides the other, or if one
// is a function definition and the other is that function's declaration.
for (auto& [l, r] : fct_sig_pairs) {
if (fct_sig_nodes.find(l) == fct_sig_nodes.end()) {
continue;
}
if (fct_sig_nodes.find(r) == fct_sig_nodes.end()) {
continue;
}
auto& s1 = fct_sig_nodes[l];
auto& s2 = fct_sig_nodes[r];
assert(s1.size() == s2.size());
auto i1 = s1.begin();
auto i2 = s2.begin();
while (i1 != s1.end()) {
output_helper.AddEdge(*i1, *i2);
i1++;
i2++;
}
}
// Emits the list of edges.
output_helper.Emit();
return result;
}
Codebase Browser
chromium