| 1 |
//===-- tools/extra/clang-reorder-fields/ReorderFieldsAction.cpp -*- C++ -*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
/// |
| 9 |
/// \file |
| 10 |
/// This file contains the definition of the |
| 11 |
/// ReorderFieldsAction::newASTConsumer method |
| 12 |
/// |
| 13 |
//===----------------------------------------------------------------------===// |
| 14 |
|
| 15 |
#include "ReorderFieldsAction.h" |
| 16 |
#include "clang/AST/AST.h" |
| 17 |
#include "clang/AST/ASTConsumer.h" |
| 18 |
#include "clang/AST/ASTContext.h" |
| 19 |
#include "clang/AST/Decl.h" |
| 20 |
#include "clang/AST/RecursiveASTVisitor.h" |
| 21 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 22 |
#include "clang/Lex/Lexer.h" |
| 23 |
#include "clang/Tooling/Refactoring.h" |
| 24 |
#include "llvm/ADT/STLExtras.h" |
| 25 |
#include "llvm/ADT/SetVector.h" |
| 26 |
#include <string> |
| 27 |
|
| 28 |
namespace clang { |
| 29 |
namespace reorder_fields { |
| 30 |
using namespace clang::ast_matchers; |
| 31 |
using llvm::SmallSetVector; |
| 32 |
|
| 33 |
/// Finds the definition of a record by name. |
| 34 |
/// |
| 35 |
/// \returns nullptr if the name is ambiguous or not found. |
| 36 |
static const RecordDecl *findDefinition(StringRef RecordName, |
| 37 |
ASTContext &Context) { |
| 38 |
auto Results = |
| 39 |
match(recordDecl(hasName(RecordName), isDefinition()).bind("recordDecl"), |
| 40 |
Context); |
| 41 |
if (Results.empty()) { |
| 42 |
llvm::errs() << "Definition of " << RecordName << " not found\n"; |
| 43 |
return nullptr; |
| 44 |
} |
| 45 |
if (Results.size() > 1) { |
| 46 |
llvm::errs() << "The name " << RecordName |
| 47 |
<< " is ambiguous, several definitions found\n"; |
| 48 |
return nullptr; |
| 49 |
} |
| 50 |
return selectFirst<RecordDecl>("recordDecl", Results); |
| 51 |
} |
| 52 |
|
| 53 |
/// Calculates the new order of fields. |
| 54 |
/// |
| 55 |
/// \returns empty vector if the list of fields doesn't match the definition. |
| 56 |
static SmallVector<unsigned, 4> |
| 57 |
getNewFieldsOrder(const RecordDecl *Definition, |
| 58 |
ArrayRef<std::string> DesiredFieldsOrder) { |
| 59 |
assert(Definition && "Definition is null"); |
| 60 |
|
| 61 |
llvm::StringMap<unsigned> NameToIndex; |
| 62 |
for (const auto *Field : Definition->fields()) |
| 63 |
NameToIndex[Field->getName()] = Field->getFieldIndex(); |
| 64 |
|
| 65 |
if (DesiredFieldsOrder.size() != NameToIndex.size()) { |
| 66 |
llvm::errs() << "Number of provided fields doesn't match definition.\n"; |
| 67 |
return {}; |
| 68 |
} |
| 69 |
SmallVector<unsigned, 4> NewFieldsOrder; |
| 70 |
for (const auto &Name : DesiredFieldsOrder) { |
| 71 |
if (!NameToIndex.count(Name)) { |
| 72 |
llvm::errs() << "Field " << Name << " not found in definition.\n"; |
| 73 |
return {}; |
| 74 |
} |
| 75 |
NewFieldsOrder.push_back(NameToIndex[Name]); |
| 76 |
} |
| 77 |
assert(NewFieldsOrder.size() == NameToIndex.size()); |
| 78 |
return NewFieldsOrder; |
| 79 |
} |
| 80 |
|
| 81 |
// FIXME: error-handling |
| 82 |
/// Replaces one range of source code by another. |
| 83 |
static void |
| 84 |
addReplacement(SourceRange Old, SourceRange New, const ASTContext &Context, |
| 85 |
std::map<std::string, tooling::Replacements> &Replacements) { |
| 86 |
StringRef NewText = |
| 87 |
Lexer::getSourceText(CharSourceRange::getTokenRange(New), |
| 88 |
Context.getSourceManager(), Context.getLangOpts()); |
| 89 |
tooling::Replacement R(Context.getSourceManager(), |
| 90 |
CharSourceRange::getTokenRange(Old), NewText, |
| 91 |
Context.getLangOpts()); |
| 92 |
consumeError(Replacements[std::string(R.getFilePath())].add(R)); |
| 93 |
} |
| 94 |
|
| 95 |
/// Find all member fields used in the given init-list initializer expr |
| 96 |
/// that belong to the same record |
| 97 |
/// |
| 98 |
/// \returns a set of field declarations, empty if none were present |
| 99 |
static SmallSetVector<FieldDecl *, 1> |
| 100 |
findMembersUsedInInitExpr(const CXXCtorInitializer *Initializer, |
| 101 |
ASTContext &Context) { |
| 102 |
SmallSetVector<FieldDecl *, 1> Results; |
| 103 |
// Note that this does not pick up member fields of base classes since |
| 104 |
// for those accesses Sema::PerformObjectMemberConversion always inserts an |
| 105 |
// UncheckedDerivedToBase ImplicitCastExpr between the this expr and the |
| 106 |
// object expression |
| 107 |
auto FoundExprs = match( |
| 108 |
traverse( |
| 109 |
TK_AsIs, |
| 110 |
findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME"))), |
| 111 |
*Initializer->getInit(), Context); |
| 112 |
for (BoundNodes &BN : FoundExprs) |
| 113 |
if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME")) |
| 114 |
if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl())) |
| 115 |
Results.insert(FD); |
| 116 |
return Results; |
| 117 |
} |
| 118 |
|
| 119 |
/// Reorders fields in the definition of a struct/class. |
| 120 |
/// |
| 121 |
/// At the moment reordering of fields with |
| 122 |
/// different accesses (public/protected/private) is not supported. |
| 123 |
/// \returns true on success. |
| 124 |
static bool reorderFieldsInDefinition( |
| 125 |
const RecordDecl *Definition, ArrayRef<unsigned> NewFieldsOrder, |
| 126 |
const ASTContext &Context, |
| 127 |
std::map<std::string, tooling::Replacements> &Replacements) { |
| 128 |
assert(Definition && "Definition is null"); |
| 129 |
|
| 130 |
SmallVector<const FieldDecl *, 10> Fields; |
| 131 |
for (const auto *Field : Definition->fields()) |
| 132 |
Fields.push_back(Field); |
| 133 |
|
| 134 |
// Check that the permutation of the fields doesn't change the accesses |
| 135 |
for (const auto *Field : Definition->fields()) { |
| 136 |
const auto FieldIndex = Field->getFieldIndex(); |
| 137 |
if (Field->getAccess() != Fields[NewFieldsOrder[FieldIndex]]->getAccess()) { |
| 138 |
llvm::errs() << "Currently reordering of fields with different accesses " |
| 139 |
"is not supported\n"; |
| 140 |
return false; |
| 141 |
} |
| 142 |
} |
| 143 |
|
| 144 |
for (const auto *Field : Definition->fields()) { |
| 145 |
const auto FieldIndex = Field->getFieldIndex(); |
| 146 |
if (FieldIndex == NewFieldsOrder[FieldIndex]) |
| 147 |
continue; |
| 148 |
addReplacement(Field->getSourceRange(), |
| 149 |
Fields[NewFieldsOrder[FieldIndex]]->getSourceRange(), |
| 150 |
Context, Replacements); |
| 151 |
} |
| 152 |
return true; |
| 153 |
} |
| 154 |
|
| 155 |
/// Reorders initializers in a C++ struct/class constructor. |
| 156 |
/// |
| 157 |
/// A constructor can have initializers for an arbitrary subset of the class's |
| 158 |
/// fields. Thus, we need to ensure that we reorder just the initializers that |
| 159 |
/// are present. |
| 160 |
static void reorderFieldsInConstructor( |
| 161 |
const CXXConstructorDecl *CtorDecl, ArrayRef<unsigned> NewFieldsOrder, |
| 162 |
ASTContext &Context, |
| 163 |
std::map<std::string, tooling::Replacements> &Replacements) { |
| 164 |
assert(CtorDecl && "Constructor declaration is null"); |
| 165 |
if (CtorDecl->isImplicit() || CtorDecl->getNumCtorInitializers() <= 1) |
| 166 |
return; |
| 167 |
|
| 168 |
// The method FunctionDecl::isThisDeclarationADefinition returns false |
| 169 |
// for a defaulted function unless that function has been implicitly defined. |
| 170 |
// Thus this assert needs to be after the previous checks. |
| 171 |
assert(CtorDecl->isThisDeclarationADefinition() && "Not a definition"); |
| 172 |
|
| 173 |
SmallVector<unsigned, 10> NewFieldsPositions(NewFieldsOrder.size()); |
| 174 |
for (unsigned i = 0, e = NewFieldsOrder.size(); i < e; ++i) |
| 175 |
NewFieldsPositions[NewFieldsOrder[i]] = i; |
| 176 |
|
| 177 |
SmallVector<const CXXCtorInitializer *, 10> OldWrittenInitializersOrder; |
| 178 |
SmallVector<const CXXCtorInitializer *, 10> NewWrittenInitializersOrder; |
| 179 |
for (const auto *Initializer : CtorDecl->inits()) { |
| 180 |
if (!Initializer->isMemberInitializer() || !Initializer->isWritten()) |
| 181 |
continue; |
| 182 |
|
| 183 |
// Warn if this reordering violates initialization expr dependencies. |
| 184 |
const FieldDecl *ThisM = Initializer->getMember(); |
| 185 |
const auto UsedMembers = findMembersUsedInInitExpr(Initializer, Context); |
| 186 |
for (const FieldDecl *UM : UsedMembers) { |
| 187 |
if (NewFieldsPositions[UM->getFieldIndex()] > |
| 188 |
NewFieldsPositions[ThisM->getFieldIndex()]) { |
| 189 |
DiagnosticsEngine &DiagEngine = Context.getDiagnostics(); |
| 190 |
auto Description = ("reordering field " + UM->getName() + " after " + |
| 191 |
ThisM->getName() + " makes " + UM->getName() + |
| 192 |
" uninitialized when used in init expression") |
| 193 |
.str(); |
| 194 |
unsigned ID = DiagEngine.getDiagnosticIDs()->getCustomDiagID( |
| 195 |
DiagnosticIDs::Warning, Description); |
| 196 |
DiagEngine.Report(Initializer->getSourceLocation(), ID); |
| 197 |
} |
| 198 |
} |
| 199 |
|
| 200 |
OldWrittenInitializersOrder.push_back(Initializer); |
| 201 |
NewWrittenInitializersOrder.push_back(Initializer); |
| 202 |
} |
| 203 |
auto ByFieldNewPosition = [&](const CXXCtorInitializer *LHS, |
| 204 |
const CXXCtorInitializer *RHS) { |
| 205 |
assert(LHS && RHS); |
| 206 |
return NewFieldsPositions[LHS->getMember()->getFieldIndex()] < |
| 207 |
NewFieldsPositions[RHS->getMember()->getFieldIndex()]; |
| 208 |
}; |
| 209 |
llvm::sort(NewWrittenInitializersOrder, ByFieldNewPosition); |
| 210 |
assert(OldWrittenInitializersOrder.size() == |
| 211 |
NewWrittenInitializersOrder.size()); |
| 212 |
for (unsigned i = 0, e = NewWrittenInitializersOrder.size(); i < e; ++i) |
| 213 |
if (OldWrittenInitializersOrder[i] != NewWrittenInitializersOrder[i]) |
| 214 |
addReplacement(OldWrittenInitializersOrder[i]->getSourceRange(), |
| 215 |
NewWrittenInitializersOrder[i]->getSourceRange(), Context, |
| 216 |
Replacements); |
| 217 |
} |
| 218 |
|
| 219 |
/// Reorders initializers in the brace initialization of an aggregate. |
| 220 |
/// |
| 221 |
/// At the moment partial initialization is not supported. |
| 222 |
/// \returns true on success |
| 223 |
static bool reorderFieldsInInitListExpr( |
| 224 |
const InitListExpr *InitListEx, ArrayRef<unsigned> NewFieldsOrder, |
| 225 |
const ASTContext &Context, |
| 226 |
std::map<std::string, tooling::Replacements> &Replacements) { |
| 227 |
assert(InitListEx && "Init list expression is null"); |
| 228 |
// We care only about InitListExprs which originate from source code. |
| 229 |
// Implicit InitListExprs are created by the semantic analyzer. |
| 230 |
if (!InitListEx->isExplicit()) |
| 231 |
return true; |
| 232 |
// The method InitListExpr::getSyntacticForm may return nullptr indicating |
| 233 |
// that the current initializer list also serves as its syntactic form. |
| 234 |
if (const auto *SyntacticForm = InitListEx->getSyntacticForm()) |
| 235 |
InitListEx = SyntacticForm; |
| 236 |
// If there are no initializers we do not need to change anything. |
| 237 |
if (!InitListEx->getNumInits()) |
| 238 |
return true; |
| 239 |
if (InitListEx->getNumInits() != NewFieldsOrder.size()) { |
| 240 |
llvm::errs() << "Currently only full initialization is supported\n"; |
| 241 |
return false; |
| 242 |
} |
| 243 |
for (unsigned i = 0, e = InitListEx->getNumInits(); i < e; ++i) |
| 244 |
if (i != NewFieldsOrder[i]) |
| 245 |
addReplacement(InitListEx->getInit(i)->getSourceRange(), |
| 246 |
InitListEx->getInit(NewFieldsOrder[i])->getSourceRange(), |
| 247 |
Context, Replacements); |
| 248 |
return true; |
| 249 |
} |
| 250 |
|
| 251 |
namespace { |
| 252 |
class ReorderingConsumer : public ASTConsumer { |
| 253 |
StringRef RecordName; |
| 254 |
ArrayRef<std::string> DesiredFieldsOrder; |
| 255 |
std::map<std::string, tooling::Replacements> &Replacements; |
| 256 |
|
| 257 |
public: |
| 258 |
ReorderingConsumer(StringRef RecordName, |
| 259 |
ArrayRef<std::string> DesiredFieldsOrder, |
| 260 |
std::map<std::string, tooling::Replacements> &Replacements) |
| 261 |
: RecordName(RecordName), DesiredFieldsOrder(DesiredFieldsOrder), |
| 262 |
Replacements(Replacements) {} |
| 263 |
|
| 264 |
ReorderingConsumer(const ReorderingConsumer &) = delete; |
| 265 |
ReorderingConsumer &operator=(const ReorderingConsumer &) = delete; |
| 266 |
|
| 267 |
void HandleTranslationUnit(ASTContext &Context) override { |
| 268 |
const RecordDecl *RD = findDefinition(RecordName, Context); |
| 269 |
if (!RD) |
| 270 |
return; |
| 271 |
SmallVector<unsigned, 4> NewFieldsOrder = |
| 272 |
getNewFieldsOrder(RD, DesiredFieldsOrder); |
| 273 |
if (NewFieldsOrder.empty()) |
| 274 |
return; |
| 275 |
if (!reorderFieldsInDefinition(RD, NewFieldsOrder, Context, Replacements)) |
| 276 |
return; |
| 277 |
|
| 278 |
// CXXRD will be nullptr if C code (not C++) is being processed. |
| 279 |
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD); |
| 280 |
if (CXXRD) |
| 281 |
for (const auto *C : CXXRD->ctors()) |
| 282 |
if (const auto *D = dyn_cast<CXXConstructorDecl>(C->getDefinition())) |
| 283 |
reorderFieldsInConstructor(cast<const CXXConstructorDecl>(D), |
| 284 |
NewFieldsOrder, Context, Replacements); |
| 285 |
|
| 286 |
// We only need to reorder init list expressions for |
| 287 |
// plain C structs or C++ aggregate types. |
| 288 |
// For other types the order of constructor parameters is used, |
| 289 |
// which we don't change at the moment. |
| 290 |
// Now (v0) partial initialization is not supported. |
| 291 |
if (!CXXRD || CXXRD->isAggregate()) |
| 292 |
for (auto Result : |
| 293 |
match(initListExpr(hasType(equalsNode(RD))).bind("initListExpr"), |
| 294 |
Context)) |
| 295 |
if (!reorderFieldsInInitListExpr( |
| 296 |
Result.getNodeAs<InitListExpr>("initListExpr"), NewFieldsOrder, |
| 297 |
Context, Replacements)) { |
| 298 |
Replacements.clear(); |
| 299 |
return; |
| 300 |
} |
| 301 |
} |
| 302 |
}; |
| 303 |
} // end anonymous namespace |
| 304 |
|
| 305 |
std::unique_ptr<ASTConsumer> ReorderFieldsAction::newASTConsumer() { |
| 306 |
return std::make_unique<ReorderingConsumer>(RecordName, DesiredFieldsOrder, |
| 307 |
Replacements); |
| 308 |
} |
| 309 |
|
| 310 |
} // namespace reorder_fields |
| 311 |
} // namespace clang |