1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
//===--- SpecialMembers.cpp - Generate C++ special member functions -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ParsedAST.h"
#include "refactor/InsertionPoint.h"
#include "refactor/Tweak.h"
#include "support/Logger.h"
#include "clang/AST/DeclCXX.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Sema/Sema.h"
#include "clang/Tooling/Core/Replacement.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Error.h"
namespace clang {
namespace clangd {
namespace {
// Returns code to declare missing copy/move constructors/assignment operators.
// They will be deleted or defaulted to match the class's current state.
std::string buildSpecialMemberDeclarations(const CXXRecordDecl &Class) {
struct Members {
const CXXMethodDecl *Copy = nullptr;
const CXXMethodDecl *Move = nullptr;
} Ctor, Assign;
for (const auto &M : Class.methods()) {
if (M->isCopyAssignmentOperator())
Assign.Copy = M;
else if (M->isMoveAssignmentOperator())
Assign.Move = M;
if (const auto *C = llvm::dyn_cast<CXXConstructorDecl>(M)) {
if (C->isCopyConstructor())
Ctor.Copy = C;
else if (C->isMoveConstructor())
Ctor.Move = C;
}
}
std::string S;
llvm::raw_string_ostream OS(S);
auto PrintMember = [&](const CXXMethodDecl *D, const char *MemberPattern,
const char *ParmPattern) {
if (D && !D->isImplicit())
return;
bool Delete = !D || D->isDeleted();
OS << llvm::formatv(
"{0} = {1};\n",
llvm::formatv(MemberPattern, Class.getName(),
llvm::formatv(ParmPattern, Class.getName())),
Delete ? "delete" : "default");
};
auto PrintMembers = [&](const Members &M, const char *MemberPattern) {
PrintMember(M.Copy, MemberPattern, /*ParmPattern=*/"const {0}&");
PrintMember(M.Move, MemberPattern, /*ParmPattern=*/"{0}&&");
};
PrintMembers(Ctor, /*MemberPattern=*/"{0}({1})");
PrintMembers(Assign, /*MemberPattern=*/"{0} &operator=({1})");
return S;
}
// A tweak that adds missing declarations of copy & move constructors.
//
// e.g. given `struct ^S{};`, produces:
// struct S {
// S(const S&) = default;
// S(S&&) = default;
// S &operator=(const S&) = default;
// S &operator=(S&&) = default;
// };
//
// Added members are defaulted or deleted to approximately preserve semantics.
// (May not be a strict no-op when they were not implicitly declared).
//
// Having these spelled out is useful:
// - to understand the implicit behavior
// - to avoid relying on the implicit behavior
// - as a baseline for explicit modification
class DeclareCopyMove : public Tweak {
public:
const char *id() const final;
llvm::StringLiteral kind() const override {
return CodeAction::REFACTOR_KIND;
}
std::string title() const override {
return llvm::formatv("Declare implicit {0} members",
NeedCopy ? NeedMove ? "copy/move" : "copy" : "move");
}
bool prepare(const Selection &Inputs) override {
// This tweak relies on =default and =delete.
if (!Inputs.AST->getLangOpts().CPlusPlus11)
return false;
// Trigger only on class definitions.
if (auto *N = Inputs.ASTSelection.commonAncestor())
Class = const_cast<CXXRecordDecl *>(N->ASTNode.get<CXXRecordDecl>());
if (!Class || !Class->isThisDeclarationADefinition())
return false;
// Tweak is only available if some members are missing.
NeedCopy = !Class->hasUserDeclaredCopyConstructor() ||
!Class->hasUserDeclaredCopyAssignment();
NeedMove = !Class->hasUserDeclaredMoveAssignment() ||
!Class->hasUserDeclaredMoveConstructor();
return NeedCopy || NeedMove;
}
Expected<Effect> apply(const Selection &Inputs) override {
// Implicit special members are created lazily by clang.
// We need them so we can tell whether they should be =default or =delete.
Inputs.AST->getSema().ForceDeclarationOfImplicitMembers(Class);
std::string Code = buildSpecialMemberDeclarations(*Class);
// Prefer to place the new members...
std::vector<Anchor> Anchors = {
// Below the default constructor
{[](const Decl *D) {
if (const auto *CCD = llvm::dyn_cast<CXXConstructorDecl>(D))
return CCD->isDefaultConstructor();
return false;
},
Anchor::Below},
// Above existing constructors
{[](const Decl *D) { return llvm::isa<CXXConstructorDecl>(D); },
Anchor::Above},
// At the top of the public section
{[](const Decl *D) { return true; }, Anchor::Above},
};
auto Edit = insertDecl(Code, *Class, std::move(Anchors), AS_public);
if (!Edit)
return Edit.takeError();
return Effect::mainFileEdit(Inputs.AST->getSourceManager(),
tooling::Replacements{std::move(*Edit)});
}
private:
bool NeedCopy = false, NeedMove = false;
CXXRecordDecl *Class = nullptr;
};
REGISTER_TWEAK(DeclareCopyMove)
} // namespace
} // namespace clangd
} // namespace clang
|
