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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
//===--- Lookup.cpp - Framework for clang refactoring tools ---------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file defines helper methods for clang tools performing name lookup.
//
//===----------------------------------------------------------------------===//
#include "clang/Tooling/Refactoring/Lookup.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclarationName.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/SmallVector.h"
using namespace clang;
using namespace clang::tooling;
// Gets all namespaces that \p Context is in as a vector (ignoring anonymous
// namespaces). The inner namespaces come before outer namespaces in the vector.
// For example, if the context is in the following namespace:
// `namespace a { namespace b { namespace c ( ... ) } }`,
// the vector will be `{c, b, a}`.
static llvm::SmallVector<const NamespaceDecl *, 4>
getAllNamedNamespaces(const DeclContext *Context) {
llvm::SmallVector<const NamespaceDecl *, 4> Namespaces;
auto GetNextNamedNamespace = [](const DeclContext *Context) {
// Look past non-namespaces and anonymous namespaces on FromContext.
while (Context && (!isa<NamespaceDecl>(Context) ||
cast<NamespaceDecl>(Context)->isAnonymousNamespace()))
Context = Context->getParent();
return Context;
};
for (Context = GetNextNamedNamespace(Context); Context != nullptr;
Context = GetNextNamedNamespace(Context->getParent()))
Namespaces.push_back(cast<NamespaceDecl>(Context));
return Namespaces;
}
// Returns true if the context in which the type is used and the context in
// which the type is declared are the same semantical namespace but different
// lexical namespaces.
static bool
usingFromDifferentCanonicalNamespace(const DeclContext *FromContext,
const DeclContext *UseContext) {
// We can skip anonymous namespace because:
// 1. `FromContext` and `UseContext` must be in the same anonymous namespaces
// since referencing across anonymous namespaces is not possible.
// 2. If `FromContext` and `UseContext` are in the same anonymous namespace,
// the function will still return `false` as expected.
llvm::SmallVector<const NamespaceDecl *, 4> FromNamespaces =
getAllNamedNamespaces(FromContext);
llvm::SmallVector<const NamespaceDecl *, 4> UseNamespaces =
getAllNamedNamespaces(UseContext);
// If `UseContext` has fewer level of nested namespaces, it cannot be in the
// same canonical namespace as the `FromContext`.
if (UseNamespaces.size() < FromNamespaces.size())
return false;
unsigned Diff = UseNamespaces.size() - FromNamespaces.size();
auto FromIter = FromNamespaces.begin();
// Only compare `FromNamespaces` with namespaces in `UseNamespaces` that can
// collide, i.e. the top N namespaces where N is the number of namespaces in
// `FromNamespaces`.
auto UseIter = UseNamespaces.begin() + Diff;
for (; FromIter != FromNamespaces.end() && UseIter != UseNamespaces.end();
++FromIter, ++UseIter) {
// Literally the same namespace, not a collision.
if (*FromIter == *UseIter)
return false;
// Now check the names. If they match we have a different canonical
// namespace with the same name.
if (cast<NamespaceDecl>(*FromIter)->getDeclName() ==
cast<NamespaceDecl>(*UseIter)->getDeclName())
return true;
}
assert(FromIter == FromNamespaces.end() && UseIter == UseNamespaces.end());
return false;
}
static StringRef getBestNamespaceSubstr(const DeclContext *DeclA,
StringRef NewName,
bool HadLeadingColonColon) {
while (true) {
while (DeclA && !isa<NamespaceDecl>(DeclA))
DeclA = DeclA->getParent();
// Fully qualified it is! Leave :: in place if it's there already.
if (!DeclA)
return HadLeadingColonColon ? NewName : NewName.substr(2);
// Otherwise strip off redundant namespace qualifications from the new name.
// We use the fully qualified name of the namespace and remove that part
// from NewName if it has an identical prefix.
std::string NS =
"::" + cast<NamespaceDecl>(DeclA)->getQualifiedNameAsString() + "::";
if (NewName.startswith(NS))
return NewName.substr(NS.size());
// No match yet. Strip of a namespace from the end of the chain and try
// again. This allows to get optimal qualifications even if the old and new
// decl only share common namespaces at a higher level.
DeclA = DeclA->getParent();
}
}
/// Check if the name specifier begins with a written "::".
static bool isFullyQualified(const NestedNameSpecifier *NNS) {
while (NNS) {
if (NNS->getKind() == NestedNameSpecifier::Global)
return true;
NNS = NNS->getPrefix();
}
return false;
}
// Adds more scope specifier to the spelled name until the spelling is not
// ambiguous. A spelling is ambiguous if the resolution of the symbol is
// ambiguous. For example, if QName is "::y::bar", the spelling is "y::bar", and
// context contains a nested namespace "a::y", then "y::bar" can be resolved to
// ::a::y::bar in the context, which can cause compile error.
// FIXME: consider using namespaces.
static std::string disambiguateSpellingInScope(StringRef Spelling,
StringRef QName,
const DeclContext &UseContext,
SourceLocation UseLoc) {
assert(QName.startswith("::"));
assert(QName.endswith(Spelling));
if (Spelling.startswith("::"))
return std::string(Spelling);
auto UnspelledSpecifier = QName.drop_back(Spelling.size());
llvm::SmallVector<llvm::StringRef, 2> UnspelledScopes;
UnspelledSpecifier.split(UnspelledScopes, "::", /*MaxSplit=*/-1,
/*KeepEmpty=*/false);
llvm::SmallVector<const NamespaceDecl *, 4> EnclosingNamespaces =
getAllNamedNamespaces(&UseContext);
auto &AST = UseContext.getParentASTContext();
StringRef TrimmedQName = QName.substr(2);
const auto &SM = UseContext.getParentASTContext().getSourceManager();
UseLoc = SM.getSpellingLoc(UseLoc);
auto IsAmbiguousSpelling = [&](const llvm::StringRef CurSpelling) {
if (CurSpelling.startswith("::"))
return false;
// Lookup the first component of Spelling in all enclosing namespaces
// and check if there is any existing symbols with the same name but in
// different scope.
StringRef Head = CurSpelling.split("::").first;
for (const auto *NS : EnclosingNamespaces) {
auto LookupRes = NS->lookup(DeclarationName(&AST.Idents.get(Head)));
if (!LookupRes.empty()) {
for (const NamedDecl *Res : LookupRes)
// If `Res` is not visible in `UseLoc`, we don't consider it
// ambiguous. For example, a reference in a header file should not be
// affected by a potentially ambiguous name in some file that includes
// the header.
if (!TrimmedQName.startswith(Res->getQualifiedNameAsString()) &&
SM.isBeforeInTranslationUnit(
SM.getSpellingLoc(Res->getLocation()), UseLoc))
return true;
}
}
return false;
};
// Add more qualifiers until the spelling is not ambiguous.
std::string Disambiguated = std::string(Spelling);
while (IsAmbiguousSpelling(Disambiguated)) {
if (UnspelledScopes.empty()) {
Disambiguated = "::" + Disambiguated;
} else {
Disambiguated = (UnspelledScopes.back() + "::" + Disambiguated).str();
UnspelledScopes.pop_back();
}
}
return Disambiguated;
}
std::string tooling::replaceNestedName(const NestedNameSpecifier *Use,
SourceLocation UseLoc,
const DeclContext *UseContext,
const NamedDecl *FromDecl,
StringRef ReplacementString) {
assert(ReplacementString.startswith("::") &&
"Expected fully-qualified name!");
// We can do a raw name replacement when we are not inside the namespace for
// the original class/function and it is not in the global namespace. The
// assumption is that outside the original namespace we must have a using
// statement that makes this work out and that other parts of this refactor
// will automatically fix using statements to point to the new class/function.
// However, if the `FromDecl` is a class forward declaration, the reference is
// still considered as referring to the original definition, so we can't do a
// raw name replacement in this case.
const bool class_name_only = !Use;
const bool in_global_namespace =
isa<TranslationUnitDecl>(FromDecl->getDeclContext());
const bool is_class_forward_decl =
isa<CXXRecordDecl>(FromDecl) &&
!cast<CXXRecordDecl>(FromDecl)->isCompleteDefinition();
if (class_name_only && !in_global_namespace && !is_class_forward_decl &&
!usingFromDifferentCanonicalNamespace(FromDecl->getDeclContext(),
UseContext)) {
auto Pos = ReplacementString.rfind("::");
return std::string(Pos != StringRef::npos
? ReplacementString.substr(Pos + 2)
: ReplacementString);
}
// We did not match this because of a using statement, so we will need to
// figure out how good a namespace match we have with our destination type.
// We work backwards (from most specific possible namespace to least
// specific).
StringRef Suggested = getBestNamespaceSubstr(UseContext, ReplacementString,
isFullyQualified(Use));
return disambiguateSpellingInScope(Suggested, ReplacementString, *UseContext,
UseLoc);
}
|
