Bug Summary

File:tools/clang/lib/Sema/SemaLookup.cpp
Warning:line 97, column 3
Assigned value is garbage or undefined

Annotated Source Code

[?] Use j/k keys for keyboard navigation

/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp

1//===--------------------- SemaLookup.cpp - Name Lookup ------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements name lookup for C, C++, Objective-C, and
11// Objective-C++.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/CXXInheritance.h"
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclLookups.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/Basic/Builtins.h"
25#include "clang/Basic/LangOptions.h"
26#include "clang/Lex/HeaderSearch.h"
27#include "clang/Lex/ModuleLoader.h"
28#include "clang/Lex/Preprocessor.h"
29#include "clang/Sema/DeclSpec.h"
30#include "clang/Sema/Lookup.h"
31#include "clang/Sema/Overload.h"
32#include "clang/Sema/Scope.h"
33#include "clang/Sema/ScopeInfo.h"
34#include "clang/Sema/Sema.h"
35#include "clang/Sema/SemaInternal.h"
36#include "clang/Sema/TemplateDeduction.h"
37#include "clang/Sema/TypoCorrection.h"
38#include "llvm/ADT/STLExtras.h"
39#include "llvm/ADT/SmallPtrSet.h"
40#include "llvm/ADT/TinyPtrVector.h"
41#include "llvm/ADT/edit_distance.h"
42#include "llvm/Support/ErrorHandling.h"
43#include <algorithm>
44#include <iterator>
45#include <list>
46#include <set>
47#include <utility>
48#include <vector>
49
50using namespace clang;
51using namespace sema;
52
53namespace {
54 class UnqualUsingEntry {
55 const DeclContext *Nominated;
56 const DeclContext *CommonAncestor;
57
58 public:
59 UnqualUsingEntry(const DeclContext *Nominated,
60 const DeclContext *CommonAncestor)
61 : Nominated(Nominated), CommonAncestor(CommonAncestor) {
62 }
63
64 const DeclContext *getCommonAncestor() const {
65 return CommonAncestor;
66 }
67
68 const DeclContext *getNominatedNamespace() const {
69 return Nominated;
70 }
71
72 // Sort by the pointer value of the common ancestor.
73 struct Comparator {
74 bool operator()(const UnqualUsingEntry &L, const UnqualUsingEntry &R) {
75 return L.getCommonAncestor() < R.getCommonAncestor();
76 }
77
78 bool operator()(const UnqualUsingEntry &E, const DeclContext *DC) {
79 return E.getCommonAncestor() < DC;
80 }
81
82 bool operator()(const DeclContext *DC, const UnqualUsingEntry &E) {
83 return DC < E.getCommonAncestor();
84 }
85 };
86 };
87
88 /// A collection of using directives, as used by C++ unqualified
89 /// lookup.
90 class UnqualUsingDirectiveSet {
91 Sema &SemaRef;
92
93 typedef SmallVector<UnqualUsingEntry, 8> ListTy;
94
95 ListTy list;
96 llvm::SmallPtrSet<DeclContext*, 8> visited;
97
98 public:
99 UnqualUsingDirectiveSet(Sema &SemaRef) : SemaRef(SemaRef) {}
100
101 void visitScopeChain(Scope *S, Scope *InnermostFileScope) {
102 // C++ [namespace.udir]p1:
103 // During unqualified name lookup, the names appear as if they
104 // were declared in the nearest enclosing namespace which contains
105 // both the using-directive and the nominated namespace.
106 DeclContext *InnermostFileDC = InnermostFileScope->getEntity();
107 assert(InnermostFileDC && InnermostFileDC->isFileContext())(static_cast <bool> (InnermostFileDC && InnermostFileDC
->isFileContext()) ? void (0) : __assert_fail ("InnermostFileDC && InnermostFileDC->isFileContext()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 107, __extension__ __PRETTY_FUNCTION__))
;
108
109 for (; S; S = S->getParent()) {
110 // C++ [namespace.udir]p1:
111 // A using-directive shall not appear in class scope, but may
112 // appear in namespace scope or in block scope.
113 DeclContext *Ctx = S->getEntity();
114 if (Ctx && Ctx->isFileContext()) {
115 visit(Ctx, Ctx);
116 } else if (!Ctx || Ctx->isFunctionOrMethod()) {
117 for (auto *I : S->using_directives())
118 if (SemaRef.isVisible(I))
119 visit(I, InnermostFileDC);
120 }
121 }
122 }
123
124 // Visits a context and collect all of its using directives
125 // recursively. Treats all using directives as if they were
126 // declared in the context.
127 //
128 // A given context is only every visited once, so it is important
129 // that contexts be visited from the inside out in order to get
130 // the effective DCs right.
131 void visit(DeclContext *DC, DeclContext *EffectiveDC) {
132 if (!visited.insert(DC).second)
133 return;
134
135 addUsingDirectives(DC, EffectiveDC);
136 }
137
138 // Visits a using directive and collects all of its using
139 // directives recursively. Treats all using directives as if they
140 // were declared in the effective DC.
141 void visit(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
142 DeclContext *NS = UD->getNominatedNamespace();
143 if (!visited.insert(NS).second)
144 return;
145
146 addUsingDirective(UD, EffectiveDC);
147 addUsingDirectives(NS, EffectiveDC);
148 }
149
150 // Adds all the using directives in a context (and those nominated
151 // by its using directives, transitively) as if they appeared in
152 // the given effective context.
153 void addUsingDirectives(DeclContext *DC, DeclContext *EffectiveDC) {
154 SmallVector<DeclContext*, 4> queue;
155 while (true) {
156 for (auto UD : DC->using_directives()) {
157 DeclContext *NS = UD->getNominatedNamespace();
158 if (SemaRef.isVisible(UD) && visited.insert(NS).second) {
159 addUsingDirective(UD, EffectiveDC);
160 queue.push_back(NS);
161 }
162 }
163
164 if (queue.empty())
165 return;
166
167 DC = queue.pop_back_val();
168 }
169 }
170
171 // Add a using directive as if it had been declared in the given
172 // context. This helps implement C++ [namespace.udir]p3:
173 // The using-directive is transitive: if a scope contains a
174 // using-directive that nominates a second namespace that itself
175 // contains using-directives, the effect is as if the
176 // using-directives from the second namespace also appeared in
177 // the first.
178 void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
179 // Find the common ancestor between the effective context and
180 // the nominated namespace.
181 DeclContext *Common = UD->getNominatedNamespace();
182 while (!Common->Encloses(EffectiveDC))
183 Common = Common->getParent();
184 Common = Common->getPrimaryContext();
185
186 list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common));
187 }
188
189 void done() {
190 std::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
191 }
192
193 typedef ListTy::const_iterator const_iterator;
194
195 const_iterator begin() const { return list.begin(); }
196 const_iterator end() const { return list.end(); }
197
198 llvm::iterator_range<const_iterator>
199 getNamespacesFor(DeclContext *DC) const {
200 return llvm::make_range(std::equal_range(begin(), end(),
201 DC->getPrimaryContext(),
202 UnqualUsingEntry::Comparator()));
203 }
204 };
205} // end anonymous namespace
206
207// Retrieve the set of identifier namespaces that correspond to a
208// specific kind of name lookup.
209static inline unsigned getIDNS(Sema::LookupNameKind NameKind,
210 bool CPlusPlus,
211 bool Redeclaration) {
212 unsigned IDNS = 0;
213 switch (NameKind) {
214 case Sema::LookupObjCImplicitSelfParam:
215 case Sema::LookupOrdinaryName:
216 case Sema::LookupRedeclarationWithLinkage:
217 case Sema::LookupLocalFriendName:
218 IDNS = Decl::IDNS_Ordinary;
219 if (CPlusPlus) {
220 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Member | Decl::IDNS_Namespace;
221 if (Redeclaration)
222 IDNS |= Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend;
223 }
224 if (Redeclaration)
225 IDNS |= Decl::IDNS_LocalExtern;
226 break;
227
228 case Sema::LookupOperatorName:
229 // Operator lookup is its own crazy thing; it is not the same
230 // as (e.g.) looking up an operator name for redeclaration.
231 assert(!Redeclaration && "cannot do redeclaration operator lookup")(static_cast <bool> (!Redeclaration && "cannot do redeclaration operator lookup"
) ? void (0) : __assert_fail ("!Redeclaration && \"cannot do redeclaration operator lookup\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 231, __extension__ __PRETTY_FUNCTION__))
;
232 IDNS = Decl::IDNS_NonMemberOperator;
233 break;
234
235 case Sema::LookupTagName:
236 if (CPlusPlus) {
237 IDNS = Decl::IDNS_Type;
238
239 // When looking for a redeclaration of a tag name, we add:
240 // 1) TagFriend to find undeclared friend decls
241 // 2) Namespace because they can't "overload" with tag decls.
242 // 3) Tag because it includes class templates, which can't
243 // "overload" with tag decls.
244 if (Redeclaration)
245 IDNS |= Decl::IDNS_Tag | Decl::IDNS_TagFriend | Decl::IDNS_Namespace;
246 } else {
247 IDNS = Decl::IDNS_Tag;
248 }
249 break;
250
251 case Sema::LookupLabel:
252 IDNS = Decl::IDNS_Label;
253 break;
254
255 case Sema::LookupMemberName:
256 IDNS = Decl::IDNS_Member;
257 if (CPlusPlus)
258 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Ordinary;
259 break;
260
261 case Sema::LookupNestedNameSpecifierName:
262 IDNS = Decl::IDNS_Type | Decl::IDNS_Namespace;
263 break;
264
265 case Sema::LookupNamespaceName:
266 IDNS = Decl::IDNS_Namespace;
267 break;
268
269 case Sema::LookupUsingDeclName:
270 assert(Redeclaration && "should only be used for redecl lookup")(static_cast <bool> (Redeclaration && "should only be used for redecl lookup"
) ? void (0) : __assert_fail ("Redeclaration && \"should only be used for redecl lookup\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 270, __extension__ __PRETTY_FUNCTION__))
;
271 IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member |
272 Decl::IDNS_Using | Decl::IDNS_TagFriend | Decl::IDNS_OrdinaryFriend |
273 Decl::IDNS_LocalExtern;
274 break;
275
276 case Sema::LookupObjCProtocolName:
277 IDNS = Decl::IDNS_ObjCProtocol;
278 break;
279
280 case Sema::LookupOMPReductionName:
281 IDNS = Decl::IDNS_OMPReduction;
282 break;
283
284 case Sema::LookupAnyName:
285 IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Member
286 | Decl::IDNS_Using | Decl::IDNS_Namespace | Decl::IDNS_ObjCProtocol
287 | Decl::IDNS_Type;
288 break;
289 }
290 return IDNS;
291}
292
293void LookupResult::configure() {
294 IDNS = getIDNS(LookupKind, getSema().getLangOpts().CPlusPlus,
295 isForRedeclaration());
296
297 // If we're looking for one of the allocation or deallocation
298 // operators, make sure that the implicitly-declared new and delete
299 // operators can be found.
300 switch (NameInfo.getName().getCXXOverloadedOperator()) {
301 case OO_New:
302 case OO_Delete:
303 case OO_Array_New:
304 case OO_Array_Delete:
305 getSema().DeclareGlobalNewDelete();
306 break;
307
308 default:
309 break;
310 }
311
312 // Compiler builtins are always visible, regardless of where they end
313 // up being declared.
314 if (IdentifierInfo *Id = NameInfo.getName().getAsIdentifierInfo()) {
315 if (unsigned BuiltinID = Id->getBuiltinID()) {
316 if (!getSema().Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
317 AllowHidden = true;
318 }
319 }
320}
321
322bool LookupResult::sanity() const {
323 // This function is never called by NDEBUG builds.
324 assert(ResultKind != NotFound || Decls.size() == 0)(static_cast <bool> (ResultKind != NotFound || Decls.size
() == 0) ? void (0) : __assert_fail ("ResultKind != NotFound || Decls.size() == 0"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 324, __extension__ __PRETTY_FUNCTION__))
;
325 assert(ResultKind != Found || Decls.size() == 1)(static_cast <bool> (ResultKind != Found || Decls.size(
) == 1) ? void (0) : __assert_fail ("ResultKind != Found || Decls.size() == 1"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 325, __extension__ __PRETTY_FUNCTION__))
;
326 assert(ResultKind != FoundOverloaded || Decls.size() > 1 ||(static_cast <bool> (ResultKind != FoundOverloaded || Decls
.size() > 1 || (Decls.size() == 1 && isa<FunctionTemplateDecl
>((*begin())->getUnderlyingDecl()))) ? void (0) : __assert_fail
("ResultKind != FoundOverloaded || Decls.size() > 1 || (Decls.size() == 1 && isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 328, __extension__ __PRETTY_FUNCTION__))
327 (Decls.size() == 1 &&(static_cast <bool> (ResultKind != FoundOverloaded || Decls
.size() > 1 || (Decls.size() == 1 && isa<FunctionTemplateDecl
>((*begin())->getUnderlyingDecl()))) ? void (0) : __assert_fail
("ResultKind != FoundOverloaded || Decls.size() > 1 || (Decls.size() == 1 && isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 328, __extension__ __PRETTY_FUNCTION__))
328 isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl())))(static_cast <bool> (ResultKind != FoundOverloaded || Decls
.size() > 1 || (Decls.size() == 1 && isa<FunctionTemplateDecl
>((*begin())->getUnderlyingDecl()))) ? void (0) : __assert_fail
("ResultKind != FoundOverloaded || Decls.size() > 1 || (Decls.size() == 1 && isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 328, __extension__ __PRETTY_FUNCTION__))
;
329 assert(ResultKind != FoundUnresolvedValue || sanityCheckUnresolved())(static_cast <bool> (ResultKind != FoundUnresolvedValue
|| sanityCheckUnresolved()) ? void (0) : __assert_fail ("ResultKind != FoundUnresolvedValue || sanityCheckUnresolved()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 329, __extension__ __PRETTY_FUNCTION__))
;
330 assert(ResultKind != Ambiguous || Decls.size() > 1 ||(static_cast <bool> (ResultKind != Ambiguous || Decls.size
() > 1 || (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects
|| Ambiguity == AmbiguousBaseSubobjectTypes))) ? void (0) : __assert_fail
("ResultKind != Ambiguous || Decls.size() > 1 || (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects || Ambiguity == AmbiguousBaseSubobjectTypes))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 332, __extension__ __PRETTY_FUNCTION__))
331 (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects ||(static_cast <bool> (ResultKind != Ambiguous || Decls.size
() > 1 || (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects
|| Ambiguity == AmbiguousBaseSubobjectTypes))) ? void (0) : __assert_fail
("ResultKind != Ambiguous || Decls.size() > 1 || (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects || Ambiguity == AmbiguousBaseSubobjectTypes))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 332, __extension__ __PRETTY_FUNCTION__))
332 Ambiguity == AmbiguousBaseSubobjectTypes)))(static_cast <bool> (ResultKind != Ambiguous || Decls.size
() > 1 || (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects
|| Ambiguity == AmbiguousBaseSubobjectTypes))) ? void (0) : __assert_fail
("ResultKind != Ambiguous || Decls.size() > 1 || (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects || Ambiguity == AmbiguousBaseSubobjectTypes))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 332, __extension__ __PRETTY_FUNCTION__))
;
333 assert((Paths != nullptr) == (ResultKind == Ambiguous &&(static_cast <bool> ((Paths != nullptr) == (ResultKind ==
Ambiguous && (Ambiguity == AmbiguousBaseSubobjectTypes
|| Ambiguity == AmbiguousBaseSubobjects))) ? void (0) : __assert_fail
("(Paths != nullptr) == (ResultKind == Ambiguous && (Ambiguity == AmbiguousBaseSubobjectTypes || Ambiguity == AmbiguousBaseSubobjects))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 335, __extension__ __PRETTY_FUNCTION__))
334 (Ambiguity == AmbiguousBaseSubobjectTypes ||(static_cast <bool> ((Paths != nullptr) == (ResultKind ==
Ambiguous && (Ambiguity == AmbiguousBaseSubobjectTypes
|| Ambiguity == AmbiguousBaseSubobjects))) ? void (0) : __assert_fail
("(Paths != nullptr) == (ResultKind == Ambiguous && (Ambiguity == AmbiguousBaseSubobjectTypes || Ambiguity == AmbiguousBaseSubobjects))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 335, __extension__ __PRETTY_FUNCTION__))
335 Ambiguity == AmbiguousBaseSubobjects)))(static_cast <bool> ((Paths != nullptr) == (ResultKind ==
Ambiguous && (Ambiguity == AmbiguousBaseSubobjectTypes
|| Ambiguity == AmbiguousBaseSubobjects))) ? void (0) : __assert_fail
("(Paths != nullptr) == (ResultKind == Ambiguous && (Ambiguity == AmbiguousBaseSubobjectTypes || Ambiguity == AmbiguousBaseSubobjects))"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 335, __extension__ __PRETTY_FUNCTION__))
;
336 return true;
337}
338
339// Necessary because CXXBasePaths is not complete in Sema.h
340void LookupResult::deletePaths(CXXBasePaths *Paths) {
341 delete Paths;
342}
343
344/// Get a representative context for a declaration such that two declarations
345/// will have the same context if they were found within the same scope.
346static DeclContext *getContextForScopeMatching(Decl *D) {
347 // For function-local declarations, use that function as the context. This
348 // doesn't account for scopes within the function; the caller must deal with
349 // those.
350 DeclContext *DC = D->getLexicalDeclContext();
351 if (DC->isFunctionOrMethod())
352 return DC;
353
354 // Otherwise, look at the semantic context of the declaration. The
355 // declaration must have been found there.
356 return D->getDeclContext()->getRedeclContext();
357}
358
359/// \brief Determine whether \p D is a better lookup result than \p Existing,
360/// given that they declare the same entity.
361static bool isPreferredLookupResult(Sema &S, Sema::LookupNameKind Kind,
362 NamedDecl *D, NamedDecl *Existing) {
363 // When looking up redeclarations of a using declaration, prefer a using
364 // shadow declaration over any other declaration of the same entity.
365 if (Kind == Sema::LookupUsingDeclName && isa<UsingShadowDecl>(D) &&
366 !isa<UsingShadowDecl>(Existing))
367 return true;
368
369 auto *DUnderlying = D->getUnderlyingDecl();
370 auto *EUnderlying = Existing->getUnderlyingDecl();
371
372 // If they have different underlying declarations, prefer a typedef over the
373 // original type (this happens when two type declarations denote the same
374 // type), per a generous reading of C++ [dcl.typedef]p3 and p4. The typedef
375 // might carry additional semantic information, such as an alignment override.
376 // However, per C++ [dcl.typedef]p5, when looking up a tag name, prefer a tag
377 // declaration over a typedef.
378 if (DUnderlying->getCanonicalDecl() != EUnderlying->getCanonicalDecl()) {
379 assert(isa<TypeDecl>(DUnderlying) && isa<TypeDecl>(EUnderlying))(static_cast <bool> (isa<TypeDecl>(DUnderlying) &&
isa<TypeDecl>(EUnderlying)) ? void (0) : __assert_fail
("isa<TypeDecl>(DUnderlying) && isa<TypeDecl>(EUnderlying)"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 379, __extension__ __PRETTY_FUNCTION__))
;
380 bool HaveTag = isa<TagDecl>(EUnderlying);
381 bool WantTag = Kind == Sema::LookupTagName;
382 return HaveTag != WantTag;
383 }
384
385 // Pick the function with more default arguments.
386 // FIXME: In the presence of ambiguous default arguments, we should keep both,
387 // so we can diagnose the ambiguity if the default argument is needed.
388 // See C++ [over.match.best]p3.
389 if (auto *DFD = dyn_cast<FunctionDecl>(DUnderlying)) {
390 auto *EFD = cast<FunctionDecl>(EUnderlying);
391 unsigned DMin = DFD->getMinRequiredArguments();
392 unsigned EMin = EFD->getMinRequiredArguments();
393 // If D has more default arguments, it is preferred.
394 if (DMin != EMin)
395 return DMin < EMin;
396 // FIXME: When we track visibility for default function arguments, check
397 // that we pick the declaration with more visible default arguments.
398 }
399
400 // Pick the template with more default template arguments.
401 if (auto *DTD = dyn_cast<TemplateDecl>(DUnderlying)) {
402 auto *ETD = cast<TemplateDecl>(EUnderlying);
403 unsigned DMin = DTD->getTemplateParameters()->getMinRequiredArguments();
404 unsigned EMin = ETD->getTemplateParameters()->getMinRequiredArguments();
405 // If D has more default arguments, it is preferred. Note that default
406 // arguments (and their visibility) is monotonically increasing across the
407 // redeclaration chain, so this is a quick proxy for "is more recent".
408 if (DMin != EMin)
409 return DMin < EMin;
410 // If D has more *visible* default arguments, it is preferred. Note, an
411 // earlier default argument being visible does not imply that a later
412 // default argument is visible, so we can't just check the first one.
413 for (unsigned I = DMin, N = DTD->getTemplateParameters()->size();
414 I != N; ++I) {
415 if (!S.hasVisibleDefaultArgument(
416 ETD->getTemplateParameters()->getParam(I)) &&
417 S.hasVisibleDefaultArgument(
418 DTD->getTemplateParameters()->getParam(I)))
419 return true;
420 }
421 }
422
423 // VarDecl can have incomplete array types, prefer the one with more complete
424 // array type.
425 if (VarDecl *DVD = dyn_cast<VarDecl>(DUnderlying)) {
426 VarDecl *EVD = cast<VarDecl>(EUnderlying);
427 if (EVD->getType()->isIncompleteType() &&
428 !DVD->getType()->isIncompleteType()) {
429 // Prefer the decl with a more complete type if visible.
430 return S.isVisible(DVD);
431 }
432 return false; // Avoid picking up a newer decl, just because it was newer.
433 }
434
435 // For most kinds of declaration, it doesn't really matter which one we pick.
436 if (!isa<FunctionDecl>(DUnderlying) && !isa<VarDecl>(DUnderlying)) {
437 // If the existing declaration is hidden, prefer the new one. Otherwise,
438 // keep what we've got.
439 return !S.isVisible(Existing);
440 }
441
442 // Pick the newer declaration; it might have a more precise type.
443 for (Decl *Prev = DUnderlying->getPreviousDecl(); Prev;
444 Prev = Prev->getPreviousDecl())
445 if (Prev == EUnderlying)
446 return true;
447 return false;
448}
449
450/// Determine whether \p D can hide a tag declaration.
451static bool canHideTag(NamedDecl *D) {
452 // C++ [basic.scope.declarative]p4:
453 // Given a set of declarations in a single declarative region [...]
454 // exactly one declaration shall declare a class name or enumeration name
455 // that is not a typedef name and the other declarations shall all refer to
456 // the same variable, non-static data member, or enumerator, or all refer
457 // to functions and function templates; in this case the class name or
458 // enumeration name is hidden.
459 // C++ [basic.scope.hiding]p2:
460 // A class name or enumeration name can be hidden by the name of a
461 // variable, data member, function, or enumerator declared in the same
462 // scope.
463 // An UnresolvedUsingValueDecl always instantiates to one of these.
464 D = D->getUnderlyingDecl();
465 return isa<VarDecl>(D) || isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D) ||
466 isa<FunctionTemplateDecl>(D) || isa<FieldDecl>(D) ||
467 isa<UnresolvedUsingValueDecl>(D);
468}
469
470/// Resolves the result kind of this lookup.
471void LookupResult::resolveKind() {
472 unsigned N = Decls.size();
473
474 // Fast case: no possible ambiguity.
475 if (N == 0) {
476 assert(ResultKind == NotFound ||(static_cast <bool> (ResultKind == NotFound || ResultKind
== NotFoundInCurrentInstantiation) ? void (0) : __assert_fail
("ResultKind == NotFound || ResultKind == NotFoundInCurrentInstantiation"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 477, __extension__ __PRETTY_FUNCTION__))
477 ResultKind == NotFoundInCurrentInstantiation)(static_cast <bool> (ResultKind == NotFound || ResultKind
== NotFoundInCurrentInstantiation) ? void (0) : __assert_fail
("ResultKind == NotFound || ResultKind == NotFoundInCurrentInstantiation"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 477, __extension__ __PRETTY_FUNCTION__))
;
478 return;
479 }
480
481 // If there's a single decl, we need to examine it to decide what
482 // kind of lookup this is.
483 if (N == 1) {
484 NamedDecl *D = (*Decls.begin())->getUnderlyingDecl();
485 if (isa<FunctionTemplateDecl>(D))
486 ResultKind = FoundOverloaded;
487 else if (isa<UnresolvedUsingValueDecl>(D))
488 ResultKind = FoundUnresolvedValue;
489 return;
490 }
491
492 // Don't do any extra resolution if we've already resolved as ambiguous.
493 if (ResultKind == Ambiguous) return;
494
495 llvm::SmallDenseMap<NamedDecl*, unsigned, 16> Unique;
496 llvm::SmallDenseMap<QualType, unsigned, 16> UniqueTypes;
497
498 bool Ambiguous = false;
499 bool HasTag = false, HasFunction = false;
500 bool HasFunctionTemplate = false, HasUnresolved = false;
501 NamedDecl *HasNonFunction = nullptr;
502
503 llvm::SmallVector<NamedDecl*, 4> EquivalentNonFunctions;
504
505 unsigned UniqueTagIndex = 0;
506
507 unsigned I = 0;
508 while (I < N) {
509 NamedDecl *D = Decls[I]->getUnderlyingDecl();
510 D = cast<NamedDecl>(D->getCanonicalDecl());
511
512 // Ignore an invalid declaration unless it's the only one left.
513 if (D->isInvalidDecl() && !(I == 0 && N == 1)) {
514 Decls[I] = Decls[--N];
515 continue;
516 }
517
518 llvm::Optional<unsigned> ExistingI;
519
520 // Redeclarations of types via typedef can occur both within a scope
521 // and, through using declarations and directives, across scopes. There is
522 // no ambiguity if they all refer to the same type, so unique based on the
523 // canonical type.
524 if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
525 QualType T = getSema().Context.getTypeDeclType(TD);
526 auto UniqueResult = UniqueTypes.insert(
527 std::make_pair(getSema().Context.getCanonicalType(T), I));
528 if (!UniqueResult.second) {
529 // The type is not unique.
530 ExistingI = UniqueResult.first->second;
531 }
532 }
533
534 // For non-type declarations, check for a prior lookup result naming this
535 // canonical declaration.
536 if (!ExistingI) {
537 auto UniqueResult = Unique.insert(std::make_pair(D, I));
538 if (!UniqueResult.second) {
539 // We've seen this entity before.
540 ExistingI = UniqueResult.first->second;
541 }
542 }
543
544 if (ExistingI) {
545 // This is not a unique lookup result. Pick one of the results and
546 // discard the other.
547 if (isPreferredLookupResult(getSema(), getLookupKind(), Decls[I],
548 Decls[*ExistingI]))
549 Decls[*ExistingI] = Decls[I];
550 Decls[I] = Decls[--N];
551 continue;
552 }
553
554 // Otherwise, do some decl type analysis and then continue.
555
556 if (isa<UnresolvedUsingValueDecl>(D)) {
557 HasUnresolved = true;
558 } else if (isa<TagDecl>(D)) {
559 if (HasTag)
560 Ambiguous = true;
561 UniqueTagIndex = I;
562 HasTag = true;
563 } else if (isa<FunctionTemplateDecl>(D)) {
564 HasFunction = true;
565 HasFunctionTemplate = true;
566 } else if (isa<FunctionDecl>(D)) {
567 HasFunction = true;
568 } else {
569 if (HasNonFunction) {
570 // If we're about to create an ambiguity between two declarations that
571 // are equivalent, but one is an internal linkage declaration from one
572 // module and the other is an internal linkage declaration from another
573 // module, just skip it.
574 if (getSema().isEquivalentInternalLinkageDeclaration(HasNonFunction,
575 D)) {
576 EquivalentNonFunctions.push_back(D);
577 Decls[I] = Decls[--N];
578 continue;
579 }
580
581 Ambiguous = true;
582 }
583 HasNonFunction = D;
584 }
585 I++;
586 }
587
588 // C++ [basic.scope.hiding]p2:
589 // A class name or enumeration name can be hidden by the name of
590 // an object, function, or enumerator declared in the same
591 // scope. If a class or enumeration name and an object, function,
592 // or enumerator are declared in the same scope (in any order)
593 // with the same name, the class or enumeration name is hidden
594 // wherever the object, function, or enumerator name is visible.
595 // But it's still an error if there are distinct tag types found,
596 // even if they're not visible. (ref?)
597 if (N > 1 && HideTags && HasTag && !Ambiguous &&
598 (HasFunction || HasNonFunction || HasUnresolved)) {
599 NamedDecl *OtherDecl = Decls[UniqueTagIndex ? 0 : N - 1];
600 if (isa<TagDecl>(Decls[UniqueTagIndex]->getUnderlyingDecl()) &&
601 getContextForScopeMatching(Decls[UniqueTagIndex])->Equals(
602 getContextForScopeMatching(OtherDecl)) &&
603 canHideTag(OtherDecl))
604 Decls[UniqueTagIndex] = Decls[--N];
605 else
606 Ambiguous = true;
607 }
608
609 // FIXME: This diagnostic should really be delayed until we're done with
610 // the lookup result, in case the ambiguity is resolved by the caller.
611 if (!EquivalentNonFunctions.empty() && !Ambiguous)
612 getSema().diagnoseEquivalentInternalLinkageDeclarations(
613 getNameLoc(), HasNonFunction, EquivalentNonFunctions);
614
615 Decls.set_size(N);
616
617 if (HasNonFunction && (HasFunction || HasUnresolved))
618 Ambiguous = true;
619
620 if (Ambiguous)
621 setAmbiguous(LookupResult::AmbiguousReference);
622 else if (HasUnresolved)
623 ResultKind = LookupResult::FoundUnresolvedValue;
624 else if (N > 1 || HasFunctionTemplate)
625 ResultKind = LookupResult::FoundOverloaded;
626 else
627 ResultKind = LookupResult::Found;
628}
629
630void LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) {
631 CXXBasePaths::const_paths_iterator I, E;
632 for (I = P.begin(), E = P.end(); I != E; ++I)
633 for (DeclContext::lookup_iterator DI = I->Decls.begin(),
634 DE = I->Decls.end(); DI != DE; ++DI)
635 addDecl(*DI);
636}
637
638void LookupResult::setAmbiguousBaseSubobjects(CXXBasePaths &P) {
639 Paths = new CXXBasePaths;
640 Paths->swap(P);
641 addDeclsFromBasePaths(*Paths);
642 resolveKind();
643 setAmbiguous(AmbiguousBaseSubobjects);
644}
645
646void LookupResult::setAmbiguousBaseSubobjectTypes(CXXBasePaths &P) {
647 Paths = new CXXBasePaths;
648 Paths->swap(P);
649 addDeclsFromBasePaths(*Paths);
650 resolveKind();
651 setAmbiguous(AmbiguousBaseSubobjectTypes);
652}
653
654void LookupResult::print(raw_ostream &Out) {
655 Out << Decls.size() << " result(s)";
656 if (isAmbiguous()) Out << ", ambiguous";
657 if (Paths) Out << ", base paths present";
658
659 for (iterator I = begin(), E = end(); I != E; ++I) {
660 Out << "\n";
661 (*I)->print(Out, 2);
662 }
663}
664
665LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void LookupResult::dump() {
666 llvm::errs() << "lookup results for " << getLookupName().getAsString()
667 << ":\n";
668 for (NamedDecl *D : *this)
669 D->dump();
670}
671
672/// \brief Lookup a builtin function, when name lookup would otherwise
673/// fail.
674static bool LookupBuiltin(Sema &S, LookupResult &R) {
675 Sema::LookupNameKind NameKind = R.getLookupKind();
676
677 // If we didn't find a use of this identifier, and if the identifier
678 // corresponds to a compiler builtin, create the decl object for the builtin
679 // now, injecting it into translation unit scope, and return it.
680 if (NameKind == Sema::LookupOrdinaryName ||
681 NameKind == Sema::LookupRedeclarationWithLinkage) {
682 IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo();
683 if (II) {
684 if (S.getLangOpts().CPlusPlus && NameKind == Sema::LookupOrdinaryName) {
685 if (II == S.getASTContext().getMakeIntegerSeqName()) {
686 R.addDecl(S.getASTContext().getMakeIntegerSeqDecl());
687 return true;
688 } else if (II == S.getASTContext().getTypePackElementName()) {
689 R.addDecl(S.getASTContext().getTypePackElementDecl());
690 return true;
691 }
692 }
693
694 // If this is a builtin on this (or all) targets, create the decl.
695 if (unsigned BuiltinID = II->getBuiltinID()) {
696 // In C++ and OpenCL (spec v1.2 s6.9.f), we don't have any predefined
697 // library functions like 'malloc'. Instead, we'll just error.
698 if ((S.getLangOpts().CPlusPlus || S.getLangOpts().OpenCL) &&
699 S.Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
700 return false;
701
702 if (NamedDecl *D = S.LazilyCreateBuiltin((IdentifierInfo *)II,
703 BuiltinID, S.TUScope,
704 R.isForRedeclaration(),
705 R.getNameLoc())) {
706 R.addDecl(D);
707 return true;
708 }
709 }
710 }
711 }
712
713 return false;
714}
715
716/// \brief Determine whether we can declare a special member function within
717/// the class at this point.
718static bool CanDeclareSpecialMemberFunction(const CXXRecordDecl *Class) {
719 // We need to have a definition for the class.
720 if (!Class->getDefinition() || Class->isDependentContext())
721 return false;
722
723 // We can't be in the middle of defining the class.
724 return !Class->isBeingDefined();
725}
726
727void Sema::ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class) {
728 if (!CanDeclareSpecialMemberFunction(Class))
729 return;
730
731 // If the default constructor has not yet been declared, do so now.
732 if (Class->needsImplicitDefaultConstructor())
733 DeclareImplicitDefaultConstructor(Class);
734
735 // If the copy constructor has not yet been declared, do so now.
736 if (Class->needsImplicitCopyConstructor())
737 DeclareImplicitCopyConstructor(Class);
738
739 // If the copy assignment operator has not yet been declared, do so now.
740 if (Class->needsImplicitCopyAssignment())
741 DeclareImplicitCopyAssignment(Class);
742
743 if (getLangOpts().CPlusPlus11) {
744 // If the move constructor has not yet been declared, do so now.
745 if (Class->needsImplicitMoveConstructor())
746 DeclareImplicitMoveConstructor(Class);
747
748 // If the move assignment operator has not yet been declared, do so now.
749 if (Class->needsImplicitMoveAssignment())
750 DeclareImplicitMoveAssignment(Class);
751 }
752
753 // If the destructor has not yet been declared, do so now.
754 if (Class->needsImplicitDestructor())
755 DeclareImplicitDestructor(Class);
756}
757
758/// \brief Determine whether this is the name of an implicitly-declared
759/// special member function.
760static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name) {
761 switch (Name.getNameKind()) {
762 case DeclarationName::CXXConstructorName:
763 case DeclarationName::CXXDestructorName:
764 return true;
765
766 case DeclarationName::CXXOperatorName:
767 return Name.getCXXOverloadedOperator() == OO_Equal;
768
769 default:
770 break;
771 }
772
773 return false;
774}
775
776/// \brief If there are any implicit member functions with the given name
777/// that need to be declared in the given declaration context, do so.
778static void DeclareImplicitMemberFunctionsWithName(Sema &S,
779 DeclarationName Name,
780 SourceLocation Loc,
781 const DeclContext *DC) {
782 if (!DC)
783 return;
784
785 switch (Name.getNameKind()) {
786 case DeclarationName::CXXConstructorName:
787 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
788 if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) {
789 CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
790 if (Record->needsImplicitDefaultConstructor())
791 S.DeclareImplicitDefaultConstructor(Class);
792 if (Record->needsImplicitCopyConstructor())
793 S.DeclareImplicitCopyConstructor(Class);
794 if (S.getLangOpts().CPlusPlus11 &&
795 Record->needsImplicitMoveConstructor())
796 S.DeclareImplicitMoveConstructor(Class);
797 }
798 break;
799
800 case DeclarationName::CXXDestructorName:
801 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
802 if (Record->getDefinition() && Record->needsImplicitDestructor() &&
803 CanDeclareSpecialMemberFunction(Record))
804 S.DeclareImplicitDestructor(const_cast<CXXRecordDecl *>(Record));
805 break;
806
807 case DeclarationName::CXXOperatorName:
808 if (Name.getCXXOverloadedOperator() != OO_Equal)
809 break;
810
811 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) {
812 if (Record->getDefinition() && CanDeclareSpecialMemberFunction(Record)) {
813 CXXRecordDecl *Class = const_cast<CXXRecordDecl *>(Record);
814 if (Record->needsImplicitCopyAssignment())
815 S.DeclareImplicitCopyAssignment(Class);
816 if (S.getLangOpts().CPlusPlus11 &&
817 Record->needsImplicitMoveAssignment())
818 S.DeclareImplicitMoveAssignment(Class);
819 }
820 }
821 break;
822
823 case DeclarationName::CXXDeductionGuideName:
824 S.DeclareImplicitDeductionGuides(Name.getCXXDeductionGuideTemplate(), Loc);
825 break;
826
827 default:
828 break;
829 }
830}
831
832// Adds all qualifying matches for a name within a decl context to the
833// given lookup result. Returns true if any matches were found.
834static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
835 bool Found = false;
836
837 // Lazily declare C++ special member functions.
838 if (S.getLangOpts().CPlusPlus)
839 DeclareImplicitMemberFunctionsWithName(S, R.getLookupName(), R.getNameLoc(),
840 DC);
841
842 // Perform lookup into this declaration context.
843 DeclContext::lookup_result DR = DC->lookup(R.getLookupName());
844 for (NamedDecl *D : DR) {
845 if ((D = R.getAcceptableDecl(D))) {
846 R.addDecl(D);
847 Found = true;
848 }
849 }
850
851 if (!Found && DC->isTranslationUnit() && LookupBuiltin(S, R))
852 return true;
853
854 if (R.getLookupName().getNameKind()
855 != DeclarationName::CXXConversionFunctionName ||
856 R.getLookupName().getCXXNameType()->isDependentType() ||
857 !isa<CXXRecordDecl>(DC))
858 return Found;
859
860 // C++ [temp.mem]p6:
861 // A specialization of a conversion function template is not found by
862 // name lookup. Instead, any conversion function templates visible in the
863 // context of the use are considered. [...]
864 const CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
865 if (!Record->isCompleteDefinition())
866 return Found;
867
868 // For conversion operators, 'operator auto' should only match
869 // 'operator auto'. Since 'auto' is not a type, it shouldn't be considered
870 // as a candidate for template substitution.
871 auto *ContainedDeducedType =
872 R.getLookupName().getCXXNameType()->getContainedDeducedType();
873 if (R.getLookupName().getNameKind() ==
874 DeclarationName::CXXConversionFunctionName &&
875 ContainedDeducedType && ContainedDeducedType->isUndeducedType())
876 return Found;
877
878 for (CXXRecordDecl::conversion_iterator U = Record->conversion_begin(),
879 UEnd = Record->conversion_end(); U != UEnd; ++U) {
880 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(*U);
881 if (!ConvTemplate)
882 continue;
883
884 // When we're performing lookup for the purposes of redeclaration, just
885 // add the conversion function template. When we deduce template
886 // arguments for specializations, we'll end up unifying the return
887 // type of the new declaration with the type of the function template.
888 if (R.isForRedeclaration()) {
889 R.addDecl(ConvTemplate);
890 Found = true;
891 continue;
892 }
893
894 // C++ [temp.mem]p6:
895 // [...] For each such operator, if argument deduction succeeds
896 // (14.9.2.3), the resulting specialization is used as if found by
897 // name lookup.
898 //
899 // When referencing a conversion function for any purpose other than
900 // a redeclaration (such that we'll be building an expression with the
901 // result), perform template argument deduction and place the
902 // specialization into the result set. We do this to avoid forcing all
903 // callers to perform special deduction for conversion functions.
904 TemplateDeductionInfo Info(R.getNameLoc());
905 FunctionDecl *Specialization = nullptr;
906
907 const FunctionProtoType *ConvProto
908 = ConvTemplate->getTemplatedDecl()->getType()->getAs<FunctionProtoType>();
909 assert(ConvProto && "Nonsensical conversion function template type")(static_cast <bool> (ConvProto && "Nonsensical conversion function template type"
) ? void (0) : __assert_fail ("ConvProto && \"Nonsensical conversion function template type\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 909, __extension__ __PRETTY_FUNCTION__))
;
910
911 // Compute the type of the function that we would expect the conversion
912 // function to have, if it were to match the name given.
913 // FIXME: Calling convention!
914 FunctionProtoType::ExtProtoInfo EPI = ConvProto->getExtProtoInfo();
915 EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC_C);
916 EPI.ExceptionSpec = EST_None;
917 QualType ExpectedType
918 = R.getSema().Context.getFunctionType(R.getLookupName().getCXXNameType(),
919 None, EPI);
920
921 // Perform template argument deduction against the type that we would
922 // expect the function to have.
923 if (R.getSema().DeduceTemplateArguments(ConvTemplate, nullptr, ExpectedType,
924 Specialization, Info)
925 == Sema::TDK_Success) {
926 R.addDecl(Specialization);
927 Found = true;
928 }
929 }
930
931 return Found;
932}
933
934// Performs C++ unqualified lookup into the given file context.
935static bool
936CppNamespaceLookup(Sema &S, LookupResult &R, ASTContext &Context,
937 DeclContext *NS, UnqualUsingDirectiveSet &UDirs) {
938
939 assert(NS && NS->isFileContext() && "CppNamespaceLookup() requires namespace!")(static_cast <bool> (NS && NS->isFileContext
() && "CppNamespaceLookup() requires namespace!") ? void
(0) : __assert_fail ("NS && NS->isFileContext() && \"CppNamespaceLookup() requires namespace!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 939, __extension__ __PRETTY_FUNCTION__))
;
940
941 // Perform direct name lookup into the LookupCtx.
942 bool Found = LookupDirect(S, R, NS);
943
944 // Perform direct name lookup into the namespaces nominated by the
945 // using directives whose common ancestor is this namespace.
946 for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(NS))
947 if (LookupDirect(S, R, UUE.getNominatedNamespace()))
948 Found = true;
949
950 R.resolveKind();
951
952 return Found;
953}
954
955static bool isNamespaceOrTranslationUnitScope(Scope *S) {
956 if (DeclContext *Ctx = S->getEntity())
957 return Ctx->isFileContext();
958 return false;
959}
960
961// Find the next outer declaration context from this scope. This
962// routine actually returns the semantic outer context, which may
963// differ from the lexical context (encoded directly in the Scope
964// stack) when we are parsing a member of a class template. In this
965// case, the second element of the pair will be true, to indicate that
966// name lookup should continue searching in this semantic context when
967// it leaves the current template parameter scope.
968static std::pair<DeclContext *, bool> findOuterContext(Scope *S) {
969 DeclContext *DC = S->getEntity();
970 DeclContext *Lexical = nullptr;
971 for (Scope *OuterS = S->getParent(); OuterS;
972 OuterS = OuterS->getParent()) {
973 if (OuterS->getEntity()) {
974 Lexical = OuterS->getEntity();
975 break;
976 }
977 }
978
979 // C++ [temp.local]p8:
980 // In the definition of a member of a class template that appears
981 // outside of the namespace containing the class template
982 // definition, the name of a template-parameter hides the name of
983 // a member of this namespace.
984 //
985 // Example:
986 //
987 // namespace N {
988 // class C { };
989 //
990 // template<class T> class B {
991 // void f(T);
992 // };
993 // }
994 //
995 // template<class C> void N::B<C>::f(C) {
996 // C b; // C is the template parameter, not N::C
997 // }
998 //
999 // In this example, the lexical context we return is the
1000 // TranslationUnit, while the semantic context is the namespace N.
1001 if (!Lexical || !DC || !S->getParent() ||
1002 !S->getParent()->isTemplateParamScope())
1003 return std::make_pair(Lexical, false);
1004
1005 // Find the outermost template parameter scope.
1006 // For the example, this is the scope for the template parameters of
1007 // template<class C>.
1008 Scope *OutermostTemplateScope = S->getParent();
1009 while (OutermostTemplateScope->getParent() &&
1010 OutermostTemplateScope->getParent()->isTemplateParamScope())
1011 OutermostTemplateScope = OutermostTemplateScope->getParent();
1012
1013 // Find the namespace context in which the original scope occurs. In
1014 // the example, this is namespace N.
1015 DeclContext *Semantic = DC;
1016 while (!Semantic->isFileContext())
1017 Semantic = Semantic->getParent();
1018
1019 // Find the declaration context just outside of the template
1020 // parameter scope. This is the context in which the template is
1021 // being lexically declaration (a namespace context). In the
1022 // example, this is the global scope.
1023 if (Lexical->isFileContext() && !Lexical->Equals(Semantic) &&
1024 Lexical->Encloses(Semantic))
1025 return std::make_pair(Semantic, true);
1026
1027 return std::make_pair(Lexical, false);
1028}
1029
1030namespace {
1031/// An RAII object to specify that we want to find block scope extern
1032/// declarations.
1033struct FindLocalExternScope {
1034 FindLocalExternScope(LookupResult &R)
1035 : R(R), OldFindLocalExtern(R.getIdentifierNamespace() &
1036 Decl::IDNS_LocalExtern) {
1037 R.setFindLocalExtern(R.getIdentifierNamespace() &
1038 (Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator));
1039 }
1040 void restore() {
1041 R.setFindLocalExtern(OldFindLocalExtern);
1042 }
1043 ~FindLocalExternScope() {
1044 restore();
1045 }
1046 LookupResult &R;
1047 bool OldFindLocalExtern;
1048};
1049} // end anonymous namespace
1050
1051bool Sema::CppLookupName(LookupResult &R, Scope *S) {
1052 assert(getLangOpts().CPlusPlus && "Can perform only C++ lookup")(static_cast <bool> (getLangOpts().CPlusPlus &&
"Can perform only C++ lookup") ? void (0) : __assert_fail ("getLangOpts().CPlusPlus && \"Can perform only C++ lookup\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1052, __extension__ __PRETTY_FUNCTION__))
;
1053
1054 DeclarationName Name = R.getLookupName();
1055 Sema::LookupNameKind NameKind = R.getLookupKind();
1056
1057 // If this is the name of an implicitly-declared special member function,
1058 // go through the scope stack to implicitly declare
1059 if (isImplicitlyDeclaredMemberFunctionName(Name)) {
1060 for (Scope *PreS = S; PreS; PreS = PreS->getParent())
1061 if (DeclContext *DC = PreS->getEntity())
1062 DeclareImplicitMemberFunctionsWithName(*this, Name, R.getNameLoc(), DC);
1063 }
1064
1065 // Implicitly declare member functions with the name we're looking for, if in
1066 // fact we are in a scope where it matters.
1067
1068 Scope *Initial = S;
1069 IdentifierResolver::iterator
1070 I = IdResolver.begin(Name),
1071 IEnd = IdResolver.end();
1072
1073 // First we lookup local scope.
1074 // We don't consider using-directives, as per 7.3.4.p1 [namespace.udir]
1075 // ...During unqualified name lookup (3.4.1), the names appear as if
1076 // they were declared in the nearest enclosing namespace which contains
1077 // both the using-directive and the nominated namespace.
1078 // [Note: in this context, "contains" means "contains directly or
1079 // indirectly".
1080 //
1081 // For example:
1082 // namespace A { int i; }
1083 // void foo() {
1084 // int i;
1085 // {
1086 // using namespace A;
1087 // ++i; // finds local 'i', A::i appears at global scope
1088 // }
1089 // }
1090 //
1091 UnqualUsingDirectiveSet UDirs(*this);
1092 bool VisitedUsingDirectives = false;
1093 bool LeftStartingScope = false;
1094 DeclContext *OutsideOfTemplateParamDC = nullptr;
1095
1096 // When performing a scope lookup, we want to find local extern decls.
1097 FindLocalExternScope FindLocals(R);
1098
1099 for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) {
1100 DeclContext *Ctx = S->getEntity();
1101 bool SearchNamespaceScope = true;
1102 // Check whether the IdResolver has anything in this scope.
1103 for (; I != IEnd && S->isDeclScope(*I); ++I) {
1104 if (NamedDecl *ND = R.getAcceptableDecl(*I)) {
1105 if (NameKind == LookupRedeclarationWithLinkage &&
1106 !(*I)->isTemplateParameter()) {
1107 // If it's a template parameter, we still find it, so we can diagnose
1108 // the invalid redeclaration.
1109
1110 // Determine whether this (or a previous) declaration is
1111 // out-of-scope.
1112 if (!LeftStartingScope && !Initial->isDeclScope(*I))
1113 LeftStartingScope = true;
1114
1115 // If we found something outside of our starting scope that
1116 // does not have linkage, skip it.
1117 if (LeftStartingScope && !((*I)->hasLinkage())) {
1118 R.setShadowed();
1119 continue;
1120 }
1121 } else {
1122 // We found something in this scope, we should not look at the
1123 // namespace scope
1124 SearchNamespaceScope = false;
1125 }
1126 R.addDecl(ND);
1127 }
1128 }
1129 if (!SearchNamespaceScope) {
1130 R.resolveKind();
1131 if (S->isClassScope())
1132 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(Ctx))
1133 R.setNamingClass(Record);
1134 return true;
1135 }
1136
1137 if (NameKind == LookupLocalFriendName && !S->isClassScope()) {
1138 // C++11 [class.friend]p11:
1139 // If a friend declaration appears in a local class and the name
1140 // specified is an unqualified name, a prior declaration is
1141 // looked up without considering scopes that are outside the
1142 // innermost enclosing non-class scope.
1143 return false;
1144 }
1145
1146 if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC &&
1147 S->getParent() && !S->getParent()->isTemplateParamScope()) {
1148 // We've just searched the last template parameter scope and
1149 // found nothing, so look into the contexts between the
1150 // lexical and semantic declaration contexts returned by
1151 // findOuterContext(). This implements the name lookup behavior
1152 // of C++ [temp.local]p8.
1153 Ctx = OutsideOfTemplateParamDC;
1154 OutsideOfTemplateParamDC = nullptr;
1155 }
1156
1157 if (Ctx) {
1158 DeclContext *OuterCtx;
1159 bool SearchAfterTemplateScope;
1160 std::tie(OuterCtx, SearchAfterTemplateScope) = findOuterContext(S);
1161 if (SearchAfterTemplateScope)
1162 OutsideOfTemplateParamDC = OuterCtx;
1163
1164 for (; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) {
1165 // We do not directly look into transparent contexts, since
1166 // those entities will be found in the nearest enclosing
1167 // non-transparent context.
1168 if (Ctx->isTransparentContext())
1169 continue;
1170
1171 // We do not look directly into function or method contexts,
1172 // since all of the local variables and parameters of the
1173 // function/method are present within the Scope.
1174 if (Ctx->isFunctionOrMethod()) {
1175 // If we have an Objective-C instance method, look for ivars
1176 // in the corresponding interface.
1177 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Ctx)) {
1178 if (Method->isInstanceMethod() && Name.getAsIdentifierInfo())
1179 if (ObjCInterfaceDecl *Class = Method->getClassInterface()) {
1180 ObjCInterfaceDecl *ClassDeclared;
1181 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(
1182 Name.getAsIdentifierInfo(),
1183 ClassDeclared)) {
1184 if (NamedDecl *ND = R.getAcceptableDecl(Ivar)) {
1185 R.addDecl(ND);
1186 R.resolveKind();
1187 return true;
1188 }
1189 }
1190 }
1191 }
1192
1193 continue;
1194 }
1195
1196 // If this is a file context, we need to perform unqualified name
1197 // lookup considering using directives.
1198 if (Ctx->isFileContext()) {
1199 // If we haven't handled using directives yet, do so now.
1200 if (!VisitedUsingDirectives) {
1201 // Add using directives from this context up to the top level.
1202 for (DeclContext *UCtx = Ctx; UCtx; UCtx = UCtx->getParent()) {
1203 if (UCtx->isTransparentContext())
1204 continue;
1205
1206 UDirs.visit(UCtx, UCtx);
1207 }
1208
1209 // Find the innermost file scope, so we can add using directives
1210 // from local scopes.
1211 Scope *InnermostFileScope = S;
1212 while (InnermostFileScope &&
1213 !isNamespaceOrTranslationUnitScope(InnermostFileScope))
1214 InnermostFileScope = InnermostFileScope->getParent();
1215 UDirs.visitScopeChain(Initial, InnermostFileScope);
1216
1217 UDirs.done();
1218
1219 VisitedUsingDirectives = true;
1220 }
1221
1222 if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs)) {
1223 R.resolveKind();
1224 return true;
1225 }
1226
1227 continue;
1228 }
1229
1230 // Perform qualified name lookup into this context.
1231 // FIXME: In some cases, we know that every name that could be found by
1232 // this qualified name lookup will also be on the identifier chain. For
1233 // example, inside a class without any base classes, we never need to
1234 // perform qualified lookup because all of the members are on top of the
1235 // identifier chain.
1236 if (LookupQualifiedName(R, Ctx, /*InUnqualifiedLookup=*/true))
1237 return true;
1238 }
1239 }
1240 }
1241
1242 // Stop if we ran out of scopes.
1243 // FIXME: This really, really shouldn't be happening.
1244 if (!S) return false;
1245
1246 // If we are looking for members, no need to look into global/namespace scope.
1247 if (NameKind == LookupMemberName)
1248 return false;
1249
1250 // Collect UsingDirectiveDecls in all scopes, and recursively all
1251 // nominated namespaces by those using-directives.
1252 //
1253 // FIXME: Cache this sorted list in Scope structure, and DeclContext, so we
1254 // don't build it for each lookup!
1255 if (!VisitedUsingDirectives) {
1256 UDirs.visitScopeChain(Initial, S);
1257 UDirs.done();
1258 }
1259
1260 // If we're not performing redeclaration lookup, do not look for local
1261 // extern declarations outside of a function scope.
1262 if (!R.isForRedeclaration())
1263 FindLocals.restore();
1264
1265 // Lookup namespace scope, and global scope.
1266 // Unqualified name lookup in C++ requires looking into scopes
1267 // that aren't strictly lexical, and therefore we walk through the
1268 // context as well as walking through the scopes.
1269 for (; S; S = S->getParent()) {
1270 // Check whether the IdResolver has anything in this scope.
1271 bool Found = false;
1272 for (; I != IEnd && S->isDeclScope(*I); ++I) {
1273 if (NamedDecl *ND = R.getAcceptableDecl(*I)) {
1274 // We found something. Look for anything else in our scope
1275 // with this same name and in an acceptable identifier
1276 // namespace, so that we can construct an overload set if we
1277 // need to.
1278 Found = true;
1279 R.addDecl(ND);
1280 }
1281 }
1282
1283 if (Found && S->isTemplateParamScope()) {
1284 R.resolveKind();
1285 return true;
1286 }
1287
1288 DeclContext *Ctx = S->getEntity();
1289 if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC &&
1290 S->getParent() && !S->getParent()->isTemplateParamScope()) {
1291 // We've just searched the last template parameter scope and
1292 // found nothing, so look into the contexts between the
1293 // lexical and semantic declaration contexts returned by
1294 // findOuterContext(). This implements the name lookup behavior
1295 // of C++ [temp.local]p8.
1296 Ctx = OutsideOfTemplateParamDC;
1297 OutsideOfTemplateParamDC = nullptr;
1298 }
1299
1300 if (Ctx) {
1301 DeclContext *OuterCtx;
1302 bool SearchAfterTemplateScope;
1303 std::tie(OuterCtx, SearchAfterTemplateScope) = findOuterContext(S);
1304 if (SearchAfterTemplateScope)
1305 OutsideOfTemplateParamDC = OuterCtx;
1306
1307 for (; Ctx && !Ctx->Equals(OuterCtx); Ctx = Ctx->getLookupParent()) {
1308 // We do not directly look into transparent contexts, since
1309 // those entities will be found in the nearest enclosing
1310 // non-transparent context.
1311 if (Ctx->isTransparentContext())
1312 continue;
1313
1314 // If we have a context, and it's not a context stashed in the
1315 // template parameter scope for an out-of-line definition, also
1316 // look into that context.
1317 if (!(Found && S->isTemplateParamScope())) {
1318 assert(Ctx->isFileContext() &&(static_cast <bool> (Ctx->isFileContext() &&
"We should have been looking only at file context here already."
) ? void (0) : __assert_fail ("Ctx->isFileContext() && \"We should have been looking only at file context here already.\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1319, __extension__ __PRETTY_FUNCTION__))
1319 "We should have been looking only at file context here already.")(static_cast <bool> (Ctx->isFileContext() &&
"We should have been looking only at file context here already."
) ? void (0) : __assert_fail ("Ctx->isFileContext() && \"We should have been looking only at file context here already.\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1319, __extension__ __PRETTY_FUNCTION__))
;
1320
1321 // Look into context considering using-directives.
1322 if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs))
1323 Found = true;
1324 }
1325
1326 if (Found) {
1327 R.resolveKind();
1328 return true;
1329 }
1330
1331 if (R.isForRedeclaration() && !Ctx->isTransparentContext())
1332 return false;
1333 }
1334 }
1335
1336 if (R.isForRedeclaration() && Ctx && !Ctx->isTransparentContext())
1337 return false;
1338 }
1339
1340 return !R.empty();
1341}
1342
1343void Sema::makeMergedDefinitionVisible(NamedDecl *ND) {
1344 if (auto *M = getCurrentModule())
1345 Context.mergeDefinitionIntoModule(ND, M);
1346 else
1347 // We're not building a module; just make the definition visible.
1348 ND->setVisibleDespiteOwningModule();
1349
1350 // If ND is a template declaration, make the template parameters
1351 // visible too. They're not (necessarily) within a mergeable DeclContext.
1352 if (auto *TD = dyn_cast<TemplateDecl>(ND))
1353 for (auto *Param : *TD->getTemplateParameters())
1354 makeMergedDefinitionVisible(Param);
1355}
1356
1357/// \brief Find the module in which the given declaration was defined.
1358static Module *getDefiningModule(Sema &S, Decl *Entity) {
1359 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Entity)) {
1360 // If this function was instantiated from a template, the defining module is
1361 // the module containing the pattern.
1362 if (FunctionDecl *Pattern = FD->getTemplateInstantiationPattern())
1363 Entity = Pattern;
1364 } else if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Entity)) {
1365 if (CXXRecordDecl *Pattern = RD->getTemplateInstantiationPattern())
1366 Entity = Pattern;
1367 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(Entity)) {
1368 if (auto *Pattern = ED->getTemplateInstantiationPattern())
1369 Entity = Pattern;
1370 } else if (VarDecl *VD = dyn_cast<VarDecl>(Entity)) {
1371 if (VarDecl *Pattern = VD->getTemplateInstantiationPattern())
1372 Entity = Pattern;
1373 }
1374
1375 // Walk up to the containing context. That might also have been instantiated
1376 // from a template.
1377 DeclContext *Context = Entity->getLexicalDeclContext();
1378 if (Context->isFileContext())
1379 return S.getOwningModule(Entity);
1380 return getDefiningModule(S, cast<Decl>(Context));
1381}
1382
1383llvm::DenseSet<Module*> &Sema::getLookupModules() {
1384 unsigned N = CodeSynthesisContexts.size();
1385 for (unsigned I = CodeSynthesisContextLookupModules.size();
1386 I != N; ++I) {
1387 Module *M = getDefiningModule(*this, CodeSynthesisContexts[I].Entity);
1388 if (M && !LookupModulesCache.insert(M).second)
1389 M = nullptr;
1390 CodeSynthesisContextLookupModules.push_back(M);
1391 }
1392 return LookupModulesCache;
1393}
1394
1395bool Sema::hasVisibleMergedDefinition(NamedDecl *Def) {
1396 for (Module *Merged : Context.getModulesWithMergedDefinition(Def))
1397 if (isModuleVisible(Merged))
1398 return true;
1399 return false;
1400}
1401
1402bool Sema::hasMergedDefinitionInCurrentModule(NamedDecl *Def) {
1403 // FIXME: When not in local visibility mode, we can't tell the difference
1404 // between a declaration being visible because we merged a local copy of
1405 // the same declaration into it, and it being visible because its owning
1406 // module is visible.
1407 if (Def->getModuleOwnershipKind() == Decl::ModuleOwnershipKind::Visible &&
1408 getLangOpts().ModulesLocalVisibility)
1409 return true;
1410 for (Module *Merged : Context.getModulesWithMergedDefinition(Def))
1411 if (Merged->getTopLevelModuleName() == getLangOpts().CurrentModule)
1412 return true;
1413 return false;
1414}
1415
1416template<typename ParmDecl>
1417static bool
1418hasVisibleDefaultArgument(Sema &S, const ParmDecl *D,
1419 llvm::SmallVectorImpl<Module *> *Modules) {
1420 if (!D->hasDefaultArgument())
1421 return false;
1422
1423 while (D) {
1424 auto &DefaultArg = D->getDefaultArgStorage();
1425 if (!DefaultArg.isInherited() && S.isVisible(D))
1426 return true;
1427
1428 if (!DefaultArg.isInherited() && Modules) {
1429 auto *NonConstD = const_cast<ParmDecl*>(D);
1430 Modules->push_back(S.getOwningModule(NonConstD));
1431 const auto &Merged = S.Context.getModulesWithMergedDefinition(NonConstD);
1432 Modules->insert(Modules->end(), Merged.begin(), Merged.end());
1433 }
1434
1435 // If there was a previous default argument, maybe its parameter is visible.
1436 D = DefaultArg.getInheritedFrom();
1437 }
1438 return false;
1439}
1440
1441bool Sema::hasVisibleDefaultArgument(const NamedDecl *D,
1442 llvm::SmallVectorImpl<Module *> *Modules) {
1443 if (auto *P = dyn_cast<TemplateTypeParmDecl>(D))
1444 return ::hasVisibleDefaultArgument(*this, P, Modules);
1445 if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D))
1446 return ::hasVisibleDefaultArgument(*this, P, Modules);
1447 return ::hasVisibleDefaultArgument(*this, cast<TemplateTemplateParmDecl>(D),
1448 Modules);
1449}
1450
1451template<typename Filter>
1452static bool hasVisibleDeclarationImpl(Sema &S, const NamedDecl *D,
1453 llvm::SmallVectorImpl<Module *> *Modules,
1454 Filter F) {
1455 for (auto *Redecl : D->redecls()) {
1456 auto *R = cast<NamedDecl>(Redecl);
1457 if (!F(R))
1458 continue;
1459
1460 if (S.isVisible(R))
1461 return true;
1462
1463 if (Modules) {
1464 Modules->push_back(R->getOwningModule());
1465 const auto &Merged = S.Context.getModulesWithMergedDefinition(R);
1466 Modules->insert(Modules->end(), Merged.begin(), Merged.end());
1467 }
1468 }
1469
1470 return false;
1471}
1472
1473bool Sema::hasVisibleExplicitSpecialization(
1474 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1475 return hasVisibleDeclarationImpl(*this, D, Modules, [](const NamedDecl *D) {
1476 if (auto *RD = dyn_cast<CXXRecordDecl>(D))
1477 return RD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
1478 if (auto *FD = dyn_cast<FunctionDecl>(D))
1479 return FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
1480 if (auto *VD = dyn_cast<VarDecl>(D))
1481 return VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
1482 llvm_unreachable("unknown explicit specialization kind")::llvm::llvm_unreachable_internal("unknown explicit specialization kind"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1482)
;
1483 });
1484}
1485
1486bool Sema::hasVisibleMemberSpecialization(
1487 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
1488 assert(isa<CXXRecordDecl>(D->getDeclContext()) &&(static_cast <bool> (isa<CXXRecordDecl>(D->getDeclContext
()) && "not a member specialization") ? void (0) : __assert_fail
("isa<CXXRecordDecl>(D->getDeclContext()) && \"not a member specialization\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1489, __extension__ __PRETTY_FUNCTION__))
1489 "not a member specialization")(static_cast <bool> (isa<CXXRecordDecl>(D->getDeclContext
()) && "not a member specialization") ? void (0) : __assert_fail
("isa<CXXRecordDecl>(D->getDeclContext()) && \"not a member specialization\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1489, __extension__ __PRETTY_FUNCTION__))
;
1490 return hasVisibleDeclarationImpl(*this, D, Modules, [](const NamedDecl *D) {
1491 // If the specialization is declared at namespace scope, then it's a member
1492 // specialization declaration. If it's lexically inside the class
1493 // definition then it was instantiated.
1494 //
1495 // FIXME: This is a hack. There should be a better way to determine this.
1496 // FIXME: What about MS-style explicit specializations declared within a
1497 // class definition?
1498 return D->getLexicalDeclContext()->isFileContext();
1499 });
1500
1501 return false;
1502}
1503
1504/// \brief Determine whether a declaration is visible to name lookup.
1505///
1506/// This routine determines whether the declaration D is visible in the current
1507/// lookup context, taking into account the current template instantiation
1508/// stack. During template instantiation, a declaration is visible if it is
1509/// visible from a module containing any entity on the template instantiation
1510/// path (by instantiating a template, you allow it to see the declarations that
1511/// your module can see, including those later on in your module).
1512bool LookupResult::isVisibleSlow(Sema &SemaRef, NamedDecl *D) {
1513 assert(D->isHidden() && "should not call this: not in slow case")(static_cast <bool> (D->isHidden() && "should not call this: not in slow case"
) ? void (0) : __assert_fail ("D->isHidden() && \"should not call this: not in slow case\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1513, __extension__ __PRETTY_FUNCTION__))
;
1514
1515 Module *DeclModule = SemaRef.getOwningModule(D);
1516 if (!DeclModule) {
1517 // A module-private declaration with no owning module means this is in the
1518 // global module in the C++ Modules TS. This is visible within the same
1519 // translation unit only.
1520 // FIXME: Don't assume that "same translation unit" means the same thing
1521 // as "not from an AST file".
1522 assert(D->isModulePrivate() && "hidden decl has no module")(static_cast <bool> (D->isModulePrivate() &&
"hidden decl has no module") ? void (0) : __assert_fail ("D->isModulePrivate() && \"hidden decl has no module\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1522, __extension__ __PRETTY_FUNCTION__))
;
1523 if (!D->isFromASTFile() || SemaRef.hasMergedDefinitionInCurrentModule(D))
1524 return true;
1525 } else {
1526 // If the owning module is visible, and the decl is not module private,
1527 // then the decl is visible too. (Module private is ignored within the same
1528 // top-level module.)
1529 if (D->isModulePrivate()
1530 ? DeclModule->getTopLevelModuleName() ==
1531 SemaRef.getLangOpts().CurrentModule ||
1532 SemaRef.hasMergedDefinitionInCurrentModule(D)
1533 : SemaRef.isModuleVisible(DeclModule) ||
1534 SemaRef.hasVisibleMergedDefinition(D))
1535 return true;
1536 }
1537
1538 // Determine whether a decl context is a file context for the purpose of
1539 // visibility. This looks through some (export and linkage spec) transparent
1540 // contexts, but not others (enums).
1541 auto IsEffectivelyFileContext = [](const DeclContext *DC) {
1542 return DC->isFileContext() || isa<LinkageSpecDecl>(DC) ||
1543 isa<ExportDecl>(DC);
1544 };
1545
1546 // If this declaration is not at namespace scope
1547 // then it is visible if its lexical parent has a visible definition.
1548 DeclContext *DC = D->getLexicalDeclContext();
1549 if (DC && !IsEffectivelyFileContext(DC)) {
1550 // For a parameter, check whether our current template declaration's
1551 // lexical context is visible, not whether there's some other visible
1552 // definition of it, because parameters aren't "within" the definition.
1553 //
1554 // In C++ we need to check for a visible definition due to ODR merging,
1555 // and in C we must not because each declaration of a function gets its own
1556 // set of declarations for tags in prototype scope.
1557 bool VisibleWithinParent;
1558 if (D->isTemplateParameter() || isa<ParmVarDecl>(D) ||
1559 (isa<FunctionDecl>(DC) && !SemaRef.getLangOpts().CPlusPlus))
1560 VisibleWithinParent = isVisible(SemaRef, cast<NamedDecl>(DC));
1561 else if (D->isModulePrivate()) {
1562 // A module-private declaration is only visible if an enclosing lexical
1563 // parent was merged with another definition in the current module.
1564 VisibleWithinParent = false;
1565 do {
1566 if (SemaRef.hasMergedDefinitionInCurrentModule(cast<NamedDecl>(DC))) {
1567 VisibleWithinParent = true;
1568 break;
1569 }
1570 DC = DC->getLexicalParent();
1571 } while (!IsEffectivelyFileContext(DC));
1572 } else {
1573 VisibleWithinParent = SemaRef.hasVisibleDefinition(cast<NamedDecl>(DC));
1574 }
1575
1576 if (VisibleWithinParent && SemaRef.CodeSynthesisContexts.empty() &&
1577 // FIXME: Do something better in this case.
1578 !SemaRef.getLangOpts().ModulesLocalVisibility) {
1579 // Cache the fact that this declaration is implicitly visible because
1580 // its parent has a visible definition.
1581 D->setVisibleDespiteOwningModule();
1582 }
1583 return VisibleWithinParent;
1584 }
1585
1586 // FIXME: All uses of DeclModule below this point should also check merged
1587 // modules.
1588 if (!DeclModule)
1589 return false;
1590
1591 // Find the extra places where we need to look.
1592 const auto &LookupModules = SemaRef.getLookupModules();
1593 if (LookupModules.empty())
1594 return false;
1595
1596 // If our lookup set contains the decl's module, it's visible.
1597 if (LookupModules.count(DeclModule))
1598 return true;
1599
1600 // If the declaration isn't exported, it's not visible in any other module.
1601 if (D->isModulePrivate())
1602 return false;
1603
1604 // Check whether DeclModule is transitively exported to an import of
1605 // the lookup set.
1606 return std::any_of(LookupModules.begin(), LookupModules.end(),
1607 [&](const Module *M) {
1608 return M->isModuleVisible(DeclModule); });
1609}
1610
1611bool Sema::isVisibleSlow(const NamedDecl *D) {
1612 return LookupResult::isVisible(*this, const_cast<NamedDecl*>(D));
1613}
1614
1615bool Sema::shouldLinkPossiblyHiddenDecl(LookupResult &R, const NamedDecl *New) {
1616 // FIXME: If there are both visible and hidden declarations, we need to take
1617 // into account whether redeclaration is possible. Example:
1618 //
1619 // Non-imported module:
1620 // int f(T); // #1
1621 // Some TU:
1622 // static int f(U); // #2, not a redeclaration of #1
1623 // int f(T); // #3, finds both, should link with #1 if T != U, but
1624 // // with #2 if T == U; neither should be ambiguous.
1625 for (auto *D : R) {
1626 if (isVisible(D))
1627 return true;
1628 assert(D->isExternallyDeclarable() &&(static_cast <bool> (D->isExternallyDeclarable() &&
"should not have hidden, non-externally-declarable result here"
) ? void (0) : __assert_fail ("D->isExternallyDeclarable() && \"should not have hidden, non-externally-declarable result here\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1629, __extension__ __PRETTY_FUNCTION__))
1629 "should not have hidden, non-externally-declarable result here")(static_cast <bool> (D->isExternallyDeclarable() &&
"should not have hidden, non-externally-declarable result here"
) ? void (0) : __assert_fail ("D->isExternallyDeclarable() && \"should not have hidden, non-externally-declarable result here\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1629, __extension__ __PRETTY_FUNCTION__))
;
1630 }
1631
1632 // This function is called once "New" is essentially complete, but before a
1633 // previous declaration is attached. We can't query the linkage of "New" in
1634 // general, because attaching the previous declaration can change the
1635 // linkage of New to match the previous declaration.
1636 //
1637 // However, because we've just determined that there is no *visible* prior
1638 // declaration, we can compute the linkage here. There are two possibilities:
1639 //
1640 // * This is not a redeclaration; it's safe to compute the linkage now.
1641 //
1642 // * This is a redeclaration of a prior declaration that is externally
1643 // redeclarable. In that case, the linkage of the declaration is not
1644 // changed by attaching the prior declaration, because both are externally
1645 // declarable (and thus ExternalLinkage or VisibleNoLinkage).
1646 //
1647 // FIXME: This is subtle and fragile.
1648 return New->isExternallyDeclarable();
1649}
1650
1651/// \brief Retrieve the visible declaration corresponding to D, if any.
1652///
1653/// This routine determines whether the declaration D is visible in the current
1654/// module, with the current imports. If not, it checks whether any
1655/// redeclaration of D is visible, and if so, returns that declaration.
1656///
1657/// \returns D, or a visible previous declaration of D, whichever is more recent
1658/// and visible. If no declaration of D is visible, returns null.
1659static NamedDecl *findAcceptableDecl(Sema &SemaRef, NamedDecl *D) {
1660 assert(!LookupResult::isVisible(SemaRef, D) && "not in slow case")(static_cast <bool> (!LookupResult::isVisible(SemaRef, D
) && "not in slow case") ? void (0) : __assert_fail (
"!LookupResult::isVisible(SemaRef, D) && \"not in slow case\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1660, __extension__ __PRETTY_FUNCTION__))
;
1661
1662 for (auto RD : D->redecls()) {
1663 // Don't bother with extra checks if we already know this one isn't visible.
1664 if (RD == D)
1665 continue;
1666
1667 auto ND = cast<NamedDecl>(RD);
1668 // FIXME: This is wrong in the case where the previous declaration is not
1669 // visible in the same scope as D. This needs to be done much more
1670 // carefully.
1671 if (LookupResult::isVisible(SemaRef, ND))
1672 return ND;
1673 }
1674
1675 return nullptr;
1676}
1677
1678bool Sema::hasVisibleDeclarationSlow(const NamedDecl *D,
1679 llvm::SmallVectorImpl<Module *> *Modules) {
1680 assert(!isVisible(D) && "not in slow case")(static_cast <bool> (!isVisible(D) && "not in slow case"
) ? void (0) : __assert_fail ("!isVisible(D) && \"not in slow case\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1680, __extension__ __PRETTY_FUNCTION__))
;
1681 return hasVisibleDeclarationImpl(*this, D, Modules,
1682 [](const NamedDecl *) { return true; });
1683}
1684
1685NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const {
1686 if (auto *ND = dyn_cast<NamespaceDecl>(D)) {
1687 // Namespaces are a bit of a special case: we expect there to be a lot of
1688 // redeclarations of some namespaces, all declarations of a namespace are
1689 // essentially interchangeable, all declarations are found by name lookup
1690 // if any is, and namespaces are never looked up during template
1691 // instantiation. So we benefit from caching the check in this case, and
1692 // it is correct to do so.
1693 auto *Key = ND->getCanonicalDecl();
1694 if (auto *Acceptable = getSema().VisibleNamespaceCache.lookup(Key))
1695 return Acceptable;
1696 auto *Acceptable =
1697 isVisible(getSema(), Key) ? Key : findAcceptableDecl(getSema(), Key);
1698 if (Acceptable)
1699 getSema().VisibleNamespaceCache.insert(std::make_pair(Key, Acceptable));
1700 return Acceptable;
1701 }
1702
1703 return findAcceptableDecl(getSema(), D);
1704}
1705
1706/// @brief Perform unqualified name lookup starting from a given
1707/// scope.
1708///
1709/// Unqualified name lookup (C++ [basic.lookup.unqual], C99 6.2.1) is
1710/// used to find names within the current scope. For example, 'x' in
1711/// @code
1712/// int x;
1713/// int f() {
1714/// return x; // unqualified name look finds 'x' in the global scope
1715/// }
1716/// @endcode
1717///
1718/// Different lookup criteria can find different names. For example, a
1719/// particular scope can have both a struct and a function of the same
1720/// name, and each can be found by certain lookup criteria. For more
1721/// information about lookup criteria, see the documentation for the
1722/// class LookupCriteria.
1723///
1724/// @param S The scope from which unqualified name lookup will
1725/// begin. If the lookup criteria permits, name lookup may also search
1726/// in the parent scopes.
1727///
1728/// @param [in,out] R Specifies the lookup to perform (e.g., the name to
1729/// look up and the lookup kind), and is updated with the results of lookup
1730/// including zero or more declarations and possibly additional information
1731/// used to diagnose ambiguities.
1732///
1733/// @returns \c true if lookup succeeded and false otherwise.
1734bool Sema::LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation) {
1735 DeclarationName Name = R.getLookupName();
1736 if (!Name) return false;
1737
1738 LookupNameKind NameKind = R.getLookupKind();
1739
1740 if (!getLangOpts().CPlusPlus) {
1741 // Unqualified name lookup in C/Objective-C is purely lexical, so
1742 // search in the declarations attached to the name.
1743 if (NameKind == Sema::LookupRedeclarationWithLinkage) {
1744 // Find the nearest non-transparent declaration scope.
1745 while (!(S->getFlags() & Scope::DeclScope) ||
1746 (S->getEntity() && S->getEntity()->isTransparentContext()))
1747 S = S->getParent();
1748 }
1749
1750 // When performing a scope lookup, we want to find local extern decls.
1751 FindLocalExternScope FindLocals(R);
1752
1753 // Scan up the scope chain looking for a decl that matches this
1754 // identifier that is in the appropriate namespace. This search
1755 // should not take long, as shadowing of names is uncommon, and
1756 // deep shadowing is extremely uncommon.
1757 bool LeftStartingScope = false;
1758
1759 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1760 IEnd = IdResolver.end();
1761 I != IEnd; ++I)
1762 if (NamedDecl *D = R.getAcceptableDecl(*I)) {
1763 if (NameKind == LookupRedeclarationWithLinkage) {
1764 // Determine whether this (or a previous) declaration is
1765 // out-of-scope.
1766 if (!LeftStartingScope && !S->isDeclScope(*I))
1767 LeftStartingScope = true;
1768
1769 // If we found something outside of our starting scope that
1770 // does not have linkage, skip it.
1771 if (LeftStartingScope && !((*I)->hasLinkage())) {
1772 R.setShadowed();
1773 continue;
1774 }
1775 }
1776 else if (NameKind == LookupObjCImplicitSelfParam &&
1777 !isa<ImplicitParamDecl>(*I))
1778 continue;
1779
1780 R.addDecl(D);
1781
1782 // Check whether there are any other declarations with the same name
1783 // and in the same scope.
1784 if (I != IEnd) {
1785 // Find the scope in which this declaration was declared (if it
1786 // actually exists in a Scope).
1787 while (S && !S->isDeclScope(D))
1788 S = S->getParent();
1789
1790 // If the scope containing the declaration is the translation unit,
1791 // then we'll need to perform our checks based on the matching
1792 // DeclContexts rather than matching scopes.
1793 if (S && isNamespaceOrTranslationUnitScope(S))
1794 S = nullptr;
1795
1796 // Compute the DeclContext, if we need it.
1797 DeclContext *DC = nullptr;
1798 if (!S)
1799 DC = (*I)->getDeclContext()->getRedeclContext();
1800
1801 IdentifierResolver::iterator LastI = I;
1802 for (++LastI; LastI != IEnd; ++LastI) {
1803 if (S) {
1804 // Match based on scope.
1805 if (!S->isDeclScope(*LastI))
1806 break;
1807 } else {
1808 // Match based on DeclContext.
1809 DeclContext *LastDC
1810 = (*LastI)->getDeclContext()->getRedeclContext();
1811 if (!LastDC->Equals(DC))
1812 break;
1813 }
1814
1815 // If the declaration is in the right namespace and visible, add it.
1816 if (NamedDecl *LastD = R.getAcceptableDecl(*LastI))
1817 R.addDecl(LastD);
1818 }
1819
1820 R.resolveKind();
1821 }
1822
1823 return true;
1824 }
1825 } else {
1826 // Perform C++ unqualified name lookup.
1827 if (CppLookupName(R, S))
1828 return true;
1829 }
1830
1831 // If we didn't find a use of this identifier, and if the identifier
1832 // corresponds to a compiler builtin, create the decl object for the builtin
1833 // now, injecting it into translation unit scope, and return it.
1834 if (AllowBuiltinCreation && LookupBuiltin(*this, R))
1835 return true;
1836
1837 // If we didn't find a use of this identifier, the ExternalSource
1838 // may be able to handle the situation.
1839 // Note: some lookup failures are expected!
1840 // See e.g. R.isForRedeclaration().
1841 return (ExternalSource && ExternalSource->LookupUnqualified(R, S));
1842}
1843
1844/// @brief Perform qualified name lookup in the namespaces nominated by
1845/// using directives by the given context.
1846///
1847/// C++98 [namespace.qual]p2:
1848/// Given X::m (where X is a user-declared namespace), or given \::m
1849/// (where X is the global namespace), let S be the set of all
1850/// declarations of m in X and in the transitive closure of all
1851/// namespaces nominated by using-directives in X and its used
1852/// namespaces, except that using-directives are ignored in any
1853/// namespace, including X, directly containing one or more
1854/// declarations of m. No namespace is searched more than once in
1855/// the lookup of a name. If S is the empty set, the program is
1856/// ill-formed. Otherwise, if S has exactly one member, or if the
1857/// context of the reference is a using-declaration
1858/// (namespace.udecl), S is the required set of declarations of
1859/// m. Otherwise if the use of m is not one that allows a unique
1860/// declaration to be chosen from S, the program is ill-formed.
1861///
1862/// C++98 [namespace.qual]p5:
1863/// During the lookup of a qualified namespace member name, if the
1864/// lookup finds more than one declaration of the member, and if one
1865/// declaration introduces a class name or enumeration name and the
1866/// other declarations either introduce the same object, the same
1867/// enumerator or a set of functions, the non-type name hides the
1868/// class or enumeration name if and only if the declarations are
1869/// from the same namespace; otherwise (the declarations are from
1870/// different namespaces), the program is ill-formed.
1871static bool LookupQualifiedNameInUsingDirectives(Sema &S, LookupResult &R,
1872 DeclContext *StartDC) {
1873 assert(StartDC->isFileContext() && "start context is not a file context")(static_cast <bool> (StartDC->isFileContext() &&
"start context is not a file context") ? void (0) : __assert_fail
("StartDC->isFileContext() && \"start context is not a file context\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1873, __extension__ __PRETTY_FUNCTION__))
;
1874
1875 // We have not yet looked into these namespaces, much less added
1876 // their "using-children" to the queue.
1877 SmallVector<NamespaceDecl*, 8> Queue;
1878
1879 // We have at least added all these contexts to the queue.
1880 llvm::SmallPtrSet<DeclContext*, 8> Visited;
1881 Visited.insert(StartDC);
1882
1883 // We have already looked into the initial namespace; seed the queue
1884 // with its using-children.
1885 for (auto *I : StartDC->using_directives()) {
1886 NamespaceDecl *ND = I->getNominatedNamespace()->getOriginalNamespace();
1887 if (S.isVisible(I) && Visited.insert(ND).second)
1888 Queue.push_back(ND);
1889 }
1890
1891 // The easiest way to implement the restriction in [namespace.qual]p5
1892 // is to check whether any of the individual results found a tag
1893 // and, if so, to declare an ambiguity if the final result is not
1894 // a tag.
1895 bool FoundTag = false;
1896 bool FoundNonTag = false;
1897
1898 LookupResult LocalR(LookupResult::Temporary, R);
1899
1900 bool Found = false;
1901 while (!Queue.empty()) {
1902 NamespaceDecl *ND = Queue.pop_back_val();
1903
1904 // We go through some convolutions here to avoid copying results
1905 // between LookupResults.
1906 bool UseLocal = !R.empty();
1907 LookupResult &DirectR = UseLocal ? LocalR : R;
1908 bool FoundDirect = LookupDirect(S, DirectR, ND);
1909
1910 if (FoundDirect) {
1911 // First do any local hiding.
1912 DirectR.resolveKind();
1913
1914 // If the local result is a tag, remember that.
1915 if (DirectR.isSingleTagDecl())
1916 FoundTag = true;
1917 else
1918 FoundNonTag = true;
1919
1920 // Append the local results to the total results if necessary.
1921 if (UseLocal) {
1922 R.addAllDecls(LocalR);
1923 LocalR.clear();
1924 }
1925 }
1926
1927 // If we find names in this namespace, ignore its using directives.
1928 if (FoundDirect) {
1929 Found = true;
1930 continue;
1931 }
1932
1933 for (auto I : ND->using_directives()) {
1934 NamespaceDecl *Nom = I->getNominatedNamespace();
1935 if (S.isVisible(I) && Visited.insert(Nom).second)
1936 Queue.push_back(Nom);
1937 }
1938 }
1939
1940 if (Found) {
1941 if (FoundTag && FoundNonTag)
1942 R.setAmbiguousQualifiedTagHiding();
1943 else
1944 R.resolveKind();
1945 }
1946
1947 return Found;
1948}
1949
1950/// \brief Callback that looks for any member of a class with the given name.
1951static bool LookupAnyMember(const CXXBaseSpecifier *Specifier,
1952 CXXBasePath &Path, DeclarationName Name) {
1953 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
1954
1955 Path.Decls = BaseRecord->lookup(Name);
1956 return !Path.Decls.empty();
1957}
1958
1959/// \brief Determine whether the given set of member declarations contains only
1960/// static members, nested types, and enumerators.
1961template<typename InputIterator>
1962static bool HasOnlyStaticMembers(InputIterator First, InputIterator Last) {
1963 Decl *D = (*First)->getUnderlyingDecl();
1964 if (isa<VarDecl>(D) || isa<TypeDecl>(D) || isa<EnumConstantDecl>(D))
1965 return true;
1966
1967 if (isa<CXXMethodDecl>(D)) {
1968 // Determine whether all of the methods are static.
1969 bool AllMethodsAreStatic = true;
1970 for(; First != Last; ++First) {
1971 D = (*First)->getUnderlyingDecl();
1972
1973 if (!isa<CXXMethodDecl>(D)) {
1974 assert(isa<TagDecl>(D) && "Non-function must be a tag decl")(static_cast <bool> (isa<TagDecl>(D) && "Non-function must be a tag decl"
) ? void (0) : __assert_fail ("isa<TagDecl>(D) && \"Non-function must be a tag decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 1974, __extension__ __PRETTY_FUNCTION__))
;
1975 break;
1976 }
1977
1978 if (!cast<CXXMethodDecl>(D)->isStatic()) {
1979 AllMethodsAreStatic = false;
1980 break;
1981 }
1982 }
1983
1984 if (AllMethodsAreStatic)
1985 return true;
1986 }
1987
1988 return false;
1989}
1990
1991/// \brief Perform qualified name lookup into a given context.
1992///
1993/// Qualified name lookup (C++ [basic.lookup.qual]) is used to find
1994/// names when the context of those names is explicit specified, e.g.,
1995/// "std::vector" or "x->member", or as part of unqualified name lookup.
1996///
1997/// Different lookup criteria can find different names. For example, a
1998/// particular scope can have both a struct and a function of the same
1999/// name, and each can be found by certain lookup criteria. For more
2000/// information about lookup criteria, see the documentation for the
2001/// class LookupCriteria.
2002///
2003/// \param R captures both the lookup criteria and any lookup results found.
2004///
2005/// \param LookupCtx The context in which qualified name lookup will
2006/// search. If the lookup criteria permits, name lookup may also search
2007/// in the parent contexts or (for C++ classes) base classes.
2008///
2009/// \param InUnqualifiedLookup true if this is qualified name lookup that
2010/// occurs as part of unqualified name lookup.
2011///
2012/// \returns true if lookup succeeded, false if it failed.
2013bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
2014 bool InUnqualifiedLookup) {
2015 assert(LookupCtx && "Sema::LookupQualifiedName requires a lookup context")(static_cast <bool> (LookupCtx && "Sema::LookupQualifiedName requires a lookup context"
) ? void (0) : __assert_fail ("LookupCtx && \"Sema::LookupQualifiedName requires a lookup context\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2015, __extension__ __PRETTY_FUNCTION__))
;
2016
2017 if (!R.getLookupName())
2018 return false;
2019
2020 // Make sure that the declaration context is complete.
2021 assert((!isa<TagDecl>(LookupCtx) ||(static_cast <bool> ((!isa<TagDecl>(LookupCtx) ||
LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx
)->isCompleteDefinition() || cast<TagDecl>(LookupCtx
)->isBeingDefined()) && "Declaration context must already be complete!"
) ? void (0) : __assert_fail ("(!isa<TagDecl>(LookupCtx) || LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx)->isCompleteDefinition() || cast<TagDecl>(LookupCtx)->isBeingDefined()) && \"Declaration context must already be complete!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2025, __extension__ __PRETTY_FUNCTION__))
2022 LookupCtx->isDependentContext() ||(static_cast <bool> ((!isa<TagDecl>(LookupCtx) ||
LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx
)->isCompleteDefinition() || cast<TagDecl>(LookupCtx
)->isBeingDefined()) && "Declaration context must already be complete!"
) ? void (0) : __assert_fail ("(!isa<TagDecl>(LookupCtx) || LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx)->isCompleteDefinition() || cast<TagDecl>(LookupCtx)->isBeingDefined()) && \"Declaration context must already be complete!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2025, __extension__ __PRETTY_FUNCTION__))
2023 cast<TagDecl>(LookupCtx)->isCompleteDefinition() ||(static_cast <bool> ((!isa<TagDecl>(LookupCtx) ||
LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx
)->isCompleteDefinition() || cast<TagDecl>(LookupCtx
)->isBeingDefined()) && "Declaration context must already be complete!"
) ? void (0) : __assert_fail ("(!isa<TagDecl>(LookupCtx) || LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx)->isCompleteDefinition() || cast<TagDecl>(LookupCtx)->isBeingDefined()) && \"Declaration context must already be complete!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2025, __extension__ __PRETTY_FUNCTION__))
2024 cast<TagDecl>(LookupCtx)->isBeingDefined()) &&(static_cast <bool> ((!isa<TagDecl>(LookupCtx) ||
LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx
)->isCompleteDefinition() || cast<TagDecl>(LookupCtx
)->isBeingDefined()) && "Declaration context must already be complete!"
) ? void (0) : __assert_fail ("(!isa<TagDecl>(LookupCtx) || LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx)->isCompleteDefinition() || cast<TagDecl>(LookupCtx)->isBeingDefined()) && \"Declaration context must already be complete!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2025, __extension__ __PRETTY_FUNCTION__))
2025 "Declaration context must already be complete!")(static_cast <bool> ((!isa<TagDecl>(LookupCtx) ||
LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx
)->isCompleteDefinition() || cast<TagDecl>(LookupCtx
)->isBeingDefined()) && "Declaration context must already be complete!"
) ? void (0) : __assert_fail ("(!isa<TagDecl>(LookupCtx) || LookupCtx->isDependentContext() || cast<TagDecl>(LookupCtx)->isCompleteDefinition() || cast<TagDecl>(LookupCtx)->isBeingDefined()) && \"Declaration context must already be complete!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2025, __extension__ __PRETTY_FUNCTION__))
;
2026
2027 struct QualifiedLookupInScope {
2028 bool oldVal;
2029 DeclContext *Context;
2030 // Set flag in DeclContext informing debugger that we're looking for qualified name
2031 QualifiedLookupInScope(DeclContext *ctx) : Context(ctx) {
2032 oldVal = ctx->setUseQualifiedLookup();
2033 }
2034 ~QualifiedLookupInScope() {
2035 Context->setUseQualifiedLookup(oldVal);
2036 }
2037 } QL(LookupCtx);
2038
2039 if (LookupDirect(*this, R, LookupCtx)) {
2040 R.resolveKind();
2041 if (isa<CXXRecordDecl>(LookupCtx))
2042 R.setNamingClass(cast<CXXRecordDecl>(LookupCtx));
2043 return true;
2044 }
2045
2046 // Don't descend into implied contexts for redeclarations.
2047 // C++98 [namespace.qual]p6:
2048 // In a declaration for a namespace member in which the
2049 // declarator-id is a qualified-id, given that the qualified-id
2050 // for the namespace member has the form
2051 // nested-name-specifier unqualified-id
2052 // the unqualified-id shall name a member of the namespace
2053 // designated by the nested-name-specifier.
2054 // See also [class.mfct]p5 and [class.static.data]p2.
2055 if (R.isForRedeclaration())
2056 return false;
2057
2058 // If this is a namespace, look it up in the implied namespaces.
2059 if (LookupCtx->isFileContext())
2060 return LookupQualifiedNameInUsingDirectives(*this, R, LookupCtx);
2061
2062 // If this isn't a C++ class, we aren't allowed to look into base
2063 // classes, we're done.
2064 CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(LookupCtx);
2065 if (!LookupRec || !LookupRec->getDefinition())
2066 return false;
2067
2068 // If we're performing qualified name lookup into a dependent class,
2069 // then we are actually looking into a current instantiation. If we have any
2070 // dependent base classes, then we either have to delay lookup until
2071 // template instantiation time (at which point all bases will be available)
2072 // or we have to fail.
2073 if (!InUnqualifiedLookup && LookupRec->isDependentContext() &&
2074 LookupRec->hasAnyDependentBases()) {
2075 R.setNotFoundInCurrentInstantiation();
2076 return false;
2077 }
2078
2079 // Perform lookup into our base classes.
2080 CXXBasePaths Paths;
2081 Paths.setOrigin(LookupRec);
2082
2083 // Look for this member in our base classes
2084 bool (*BaseCallback)(const CXXBaseSpecifier *Specifier, CXXBasePath &Path,
2085 DeclarationName Name) = nullptr;
2086 switch (R.getLookupKind()) {
2087 case LookupObjCImplicitSelfParam:
2088 case LookupOrdinaryName:
2089 case LookupMemberName:
2090 case LookupRedeclarationWithLinkage:
2091 case LookupLocalFriendName:
2092 BaseCallback = &CXXRecordDecl::FindOrdinaryMember;
2093 break;
2094
2095 case LookupTagName:
2096 BaseCallback = &CXXRecordDecl::FindTagMember;
2097 break;
2098
2099 case LookupAnyName:
2100 BaseCallback = &LookupAnyMember;
2101 break;
2102
2103 case LookupOMPReductionName:
2104 BaseCallback = &CXXRecordDecl::FindOMPReductionMember;
2105 break;
2106
2107 case LookupUsingDeclName:
2108 // This lookup is for redeclarations only.
2109
2110 case LookupOperatorName:
2111 case LookupNamespaceName:
2112 case LookupObjCProtocolName:
2113 case LookupLabel:
2114 // These lookups will never find a member in a C++ class (or base class).
2115 return false;
2116
2117 case LookupNestedNameSpecifierName:
2118 BaseCallback = &CXXRecordDecl::FindNestedNameSpecifierMember;
2119 break;
2120 }
2121
2122 DeclarationName Name = R.getLookupName();
2123 if (!LookupRec->lookupInBases(
2124 [=](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
2125 return BaseCallback(Specifier, Path, Name);
2126 },
2127 Paths))
2128 return false;
2129
2130 R.setNamingClass(LookupRec);
2131
2132 // C++ [class.member.lookup]p2:
2133 // [...] If the resulting set of declarations are not all from
2134 // sub-objects of the same type, or the set has a nonstatic member
2135 // and includes members from distinct sub-objects, there is an
2136 // ambiguity and the program is ill-formed. Otherwise that set is
2137 // the result of the lookup.
2138 QualType SubobjectType;
2139 int SubobjectNumber = 0;
2140 AccessSpecifier SubobjectAccess = AS_none;
2141
2142 for (CXXBasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end();
2143 Path != PathEnd; ++Path) {
2144 const CXXBasePathElement &PathElement = Path->back();
2145
2146 // Pick the best (i.e. most permissive i.e. numerically lowest) access
2147 // across all paths.
2148 SubobjectAccess = std::min(SubobjectAccess, Path->Access);
2149
2150 // Determine whether we're looking at a distinct sub-object or not.
2151 if (SubobjectType.isNull()) {
2152 // This is the first subobject we've looked at. Record its type.
2153 SubobjectType = Context.getCanonicalType(PathElement.Base->getType());
2154 SubobjectNumber = PathElement.SubobjectNumber;
2155 continue;
2156 }
2157
2158 if (SubobjectType
2159 != Context.getCanonicalType(PathElement.Base->getType())) {
2160 // We found members of the given name in two subobjects of
2161 // different types. If the declaration sets aren't the same, this
2162 // lookup is ambiguous.
2163 if (HasOnlyStaticMembers(Path->Decls.begin(), Path->Decls.end())) {
2164 CXXBasePaths::paths_iterator FirstPath = Paths.begin();
2165 DeclContext::lookup_iterator FirstD = FirstPath->Decls.begin();
2166 DeclContext::lookup_iterator CurrentD = Path->Decls.begin();
2167
2168 while (FirstD != FirstPath->Decls.end() &&
2169 CurrentD != Path->Decls.end()) {
2170 if ((*FirstD)->getUnderlyingDecl()->getCanonicalDecl() !=
2171 (*CurrentD)->getUnderlyingDecl()->getCanonicalDecl())
2172 break;
2173
2174 ++FirstD;
2175 ++CurrentD;
2176 }
2177
2178 if (FirstD == FirstPath->Decls.end() &&
2179 CurrentD == Path->Decls.end())
2180 continue;
2181 }
2182
2183 R.setAmbiguousBaseSubobjectTypes(Paths);
2184 return true;
2185 }
2186
2187 if (SubobjectNumber != PathElement.SubobjectNumber) {
2188 // We have a different subobject of the same type.
2189
2190 // C++ [class.member.lookup]p5:
2191 // A static member, a nested type or an enumerator defined in
2192 // a base class T can unambiguously be found even if an object
2193 // has more than one base class subobject of type T.
2194 if (HasOnlyStaticMembers(Path->Decls.begin(), Path->Decls.end()))
2195 continue;
2196
2197 // We have found a nonstatic member name in multiple, distinct
2198 // subobjects. Name lookup is ambiguous.
2199 R.setAmbiguousBaseSubobjects(Paths);
2200 return true;
2201 }
2202 }
2203
2204 // Lookup in a base class succeeded; return these results.
2205
2206 for (auto *D : Paths.front().Decls) {
2207 AccessSpecifier AS = CXXRecordDecl::MergeAccess(SubobjectAccess,
2208 D->getAccess());
2209 R.addDecl(D, AS);
2210 }
2211 R.resolveKind();
2212 return true;
2213}
2214
2215/// \brief Performs qualified name lookup or special type of lookup for
2216/// "__super::" scope specifier.
2217///
2218/// This routine is a convenience overload meant to be called from contexts
2219/// that need to perform a qualified name lookup with an optional C++ scope
2220/// specifier that might require special kind of lookup.
2221///
2222/// \param R captures both the lookup criteria and any lookup results found.
2223///
2224/// \param LookupCtx The context in which qualified name lookup will
2225/// search.
2226///
2227/// \param SS An optional C++ scope-specifier.
2228///
2229/// \returns true if lookup succeeded, false if it failed.
2230bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
2231 CXXScopeSpec &SS) {
2232 auto *NNS = SS.getScopeRep();
2233 if (NNS && NNS->getKind() == NestedNameSpecifier::Super)
2234 return LookupInSuper(R, NNS->getAsRecordDecl());
2235 else
2236
2237 return LookupQualifiedName(R, LookupCtx);
2238}
2239
2240/// @brief Performs name lookup for a name that was parsed in the
2241/// source code, and may contain a C++ scope specifier.
2242///
2243/// This routine is a convenience routine meant to be called from
2244/// contexts that receive a name and an optional C++ scope specifier
2245/// (e.g., "N::M::x"). It will then perform either qualified or
2246/// unqualified name lookup (with LookupQualifiedName or LookupName,
2247/// respectively) on the given name and return those results. It will
2248/// perform a special type of lookup for "__super::" scope specifier.
2249///
2250/// @param S The scope from which unqualified name lookup will
2251/// begin.
2252///
2253/// @param SS An optional C++ scope-specifier, e.g., "::N::M".
2254///
2255/// @param EnteringContext Indicates whether we are going to enter the
2256/// context of the scope-specifier SS (if present).
2257///
2258/// @returns True if any decls were found (but possibly ambiguous)
2259bool Sema::LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
2260 bool AllowBuiltinCreation, bool EnteringContext) {
2261 if (SS && SS->isInvalid()) {
2262 // When the scope specifier is invalid, don't even look for
2263 // anything.
2264 return false;
2265 }
2266
2267 if (SS && SS->isSet()) {
2268 NestedNameSpecifier *NNS = SS->getScopeRep();
2269 if (NNS->getKind() == NestedNameSpecifier::Super)
2270 return LookupInSuper(R, NNS->getAsRecordDecl());
2271
2272 if (DeclContext *DC = computeDeclContext(*SS, EnteringContext)) {
2273 // We have resolved the scope specifier to a particular declaration
2274 // contex, and will perform name lookup in that context.
2275 if (!DC->isDependentContext() && RequireCompleteDeclContext(*SS, DC))
2276 return false;
2277
2278 R.setContextRange(SS->getRange());
2279 return LookupQualifiedName(R, DC);
2280 }
2281
2282 // We could not resolve the scope specified to a specific declaration
2283 // context, which means that SS refers to an unknown specialization.
2284 // Name lookup can't find anything in this case.
2285 R.setNotFoundInCurrentInstantiation();
2286 R.setContextRange(SS->getRange());
2287 return false;
2288 }
2289
2290 // Perform unqualified name lookup starting in the given scope.
2291 return LookupName(R, S, AllowBuiltinCreation);
2292}
2293
2294/// \brief Perform qualified name lookup into all base classes of the given
2295/// class.
2296///
2297/// \param R captures both the lookup criteria and any lookup results found.
2298///
2299/// \param Class The context in which qualified name lookup will
2300/// search. Name lookup will search in all base classes merging the results.
2301///
2302/// @returns True if any decls were found (but possibly ambiguous)
2303bool Sema::LookupInSuper(LookupResult &R, CXXRecordDecl *Class) {
2304 // The access-control rules we use here are essentially the rules for
2305 // doing a lookup in Class that just magically skipped the direct
2306 // members of Class itself. That is, the naming class is Class, and the
2307 // access includes the access of the base.
2308 for (const auto &BaseSpec : Class->bases()) {
2309 CXXRecordDecl *RD = cast<CXXRecordDecl>(
2310 BaseSpec.getType()->castAs<RecordType>()->getDecl());
2311 LookupResult Result(*this, R.getLookupNameInfo(), R.getLookupKind());
2312 Result.setBaseObjectType(Context.getRecordType(Class));
2313 LookupQualifiedName(Result, RD);
2314
2315 // Copy the lookup results into the target, merging the base's access into
2316 // the path access.
2317 for (auto I = Result.begin(), E = Result.end(); I != E; ++I) {
2318 R.addDecl(I.getDecl(),
2319 CXXRecordDecl::MergeAccess(BaseSpec.getAccessSpecifier(),
2320 I.getAccess()));
2321 }
2322
2323 Result.suppressDiagnostics();
2324 }
2325
2326 R.resolveKind();
2327 R.setNamingClass(Class);
2328
2329 return !R.empty();
2330}
2331
2332/// \brief Produce a diagnostic describing the ambiguity that resulted
2333/// from name lookup.
2334///
2335/// \param Result The result of the ambiguous lookup to be diagnosed.
2336void Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {
2337 assert(Result.isAmbiguous() && "Lookup result must be ambiguous")(static_cast <bool> (Result.isAmbiguous() && "Lookup result must be ambiguous"
) ? void (0) : __assert_fail ("Result.isAmbiguous() && \"Lookup result must be ambiguous\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2337, __extension__ __PRETTY_FUNCTION__))
;
2338
2339 DeclarationName Name = Result.getLookupName();
2340 SourceLocation NameLoc = Result.getNameLoc();
2341 SourceRange LookupRange = Result.getContextRange();
2342
2343 switch (Result.getAmbiguityKind()) {
2344 case LookupResult::AmbiguousBaseSubobjects: {
2345 CXXBasePaths *Paths = Result.getBasePaths();
2346 QualType SubobjectType = Paths->front().back().Base->getType();
2347 Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects)
2348 << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths)
2349 << LookupRange;
2350
2351 DeclContext::lookup_iterator Found = Paths->front().Decls.begin();
2352 while (isa<CXXMethodDecl>(*Found) &&
2353 cast<CXXMethodDecl>(*Found)->isStatic())
2354 ++Found;
2355
2356 Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);
2357 break;
2358 }
2359
2360 case LookupResult::AmbiguousBaseSubobjectTypes: {
2361 Diag(NameLoc, diag::err_ambiguous_member_multiple_subobject_types)
2362 << Name << LookupRange;
2363
2364 CXXBasePaths *Paths = Result.getBasePaths();
2365 std::set<Decl *> DeclsPrinted;
2366 for (CXXBasePaths::paths_iterator Path = Paths->begin(),
2367 PathEnd = Paths->end();
2368 Path != PathEnd; ++Path) {
2369 Decl *D = Path->Decls.front();
2370 if (DeclsPrinted.insert(D).second)
2371 Diag(D->getLocation(), diag::note_ambiguous_member_found);
2372 }
2373 break;
2374 }
2375
2376 case LookupResult::AmbiguousTagHiding: {
2377 Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;
2378
2379 llvm::SmallPtrSet<NamedDecl*, 8> TagDecls;
2380
2381 for (auto *D : Result)
2382 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
2383 TagDecls.insert(TD);
2384 Diag(TD->getLocation(), diag::note_hidden_tag);
2385 }
2386
2387 for (auto *D : Result)
2388 if (!isa<TagDecl>(D))
2389 Diag(D->getLocation(), diag::note_hiding_object);
2390
2391 // For recovery purposes, go ahead and implement the hiding.
2392 LookupResult::Filter F = Result.makeFilter();
2393 while (F.hasNext()) {
2394 if (TagDecls.count(F.next()))
2395 F.erase();
2396 }
2397 F.done();
2398 break;
2399 }
2400
2401 case LookupResult::AmbiguousReference: {
2402 Diag(NameLoc, diag::err_ambiguous_reference) << Name << LookupRange;
2403
2404 for (auto *D : Result)
2405 Diag(D->getLocation(), diag::note_ambiguous_candidate) << D;
2406 break;
2407 }
2408 }
2409}
2410
2411namespace {
2412 struct AssociatedLookup {
2413 AssociatedLookup(Sema &S, SourceLocation InstantiationLoc,
2414 Sema::AssociatedNamespaceSet &Namespaces,
2415 Sema::AssociatedClassSet &Classes)
2416 : S(S), Namespaces(Namespaces), Classes(Classes),
2417 InstantiationLoc(InstantiationLoc) {
2418 }
2419
2420 Sema &S;
2421 Sema::AssociatedNamespaceSet &Namespaces;
2422 Sema::AssociatedClassSet &Classes;
2423 SourceLocation InstantiationLoc;
2424 };
2425} // end anonymous namespace
2426
2427static void
2428addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType T);
2429
2430static void CollectEnclosingNamespace(Sema::AssociatedNamespaceSet &Namespaces,
2431 DeclContext *Ctx) {
2432 // Add the associated namespace for this class.
2433
2434 // We don't use DeclContext::getEnclosingNamespaceContext() as this may
2435 // be a locally scoped record.
2436
2437 // We skip out of inline namespaces. The innermost non-inline namespace
2438 // contains all names of all its nested inline namespaces anyway, so we can
2439 // replace the entire inline namespace tree with its root.
2440 while (Ctx->isRecord() || Ctx->isTransparentContext() ||
2441 Ctx->isInlineNamespace())
2442 Ctx = Ctx->getParent();
2443
2444 if (Ctx->isFileContext())
2445 Namespaces.insert(Ctx->getPrimaryContext());
2446}
2447
2448// \brief Add the associated classes and namespaces for argument-dependent
2449// lookup that involves a template argument (C++ [basic.lookup.koenig]p2).
2450static void
2451addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
2452 const TemplateArgument &Arg) {
2453 // C++ [basic.lookup.koenig]p2, last bullet:
2454 // -- [...] ;
2455 switch (Arg.getKind()) {
2456 case TemplateArgument::Null:
2457 break;
2458
2459 case TemplateArgument::Type:
2460 // [...] the namespaces and classes associated with the types of the
2461 // template arguments provided for template type parameters (excluding
2462 // template template parameters)
2463 addAssociatedClassesAndNamespaces(Result, Arg.getAsType());
2464 break;
2465
2466 case TemplateArgument::Template:
2467 case TemplateArgument::TemplateExpansion: {
2468 // [...] the namespaces in which any template template arguments are
2469 // defined; and the classes in which any member templates used as
2470 // template template arguments are defined.
2471 TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
2472 if (ClassTemplateDecl *ClassTemplate
2473 = dyn_cast<ClassTemplateDecl>(Template.getAsTemplateDecl())) {
2474 DeclContext *Ctx = ClassTemplate->getDeclContext();
2475 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2476 Result.Classes.insert(EnclosingClass);
2477 // Add the associated namespace for this class.
2478 CollectEnclosingNamespace(Result.Namespaces, Ctx);
2479 }
2480 break;
2481 }
2482
2483 case TemplateArgument::Declaration:
2484 case TemplateArgument::Integral:
2485 case TemplateArgument::Expression:
2486 case TemplateArgument::NullPtr:
2487 // [Note: non-type template arguments do not contribute to the set of
2488 // associated namespaces. ]
2489 break;
2490
2491 case TemplateArgument::Pack:
2492 for (const auto &P : Arg.pack_elements())
2493 addAssociatedClassesAndNamespaces(Result, P);
2494 break;
2495 }
2496}
2497
2498// \brief Add the associated classes and namespaces for
2499// argument-dependent lookup with an argument of class type
2500// (C++ [basic.lookup.koenig]p2).
2501static void
2502addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
2503 CXXRecordDecl *Class) {
2504
2505 // Just silently ignore anything whose name is __va_list_tag.
2506 if (Class->getDeclName() == Result.S.VAListTagName)
2507 return;
2508
2509 // C++ [basic.lookup.koenig]p2:
2510 // [...]
2511 // -- If T is a class type (including unions), its associated
2512 // classes are: the class itself; the class of which it is a
2513 // member, if any; and its direct and indirect base
2514 // classes. Its associated namespaces are the namespaces in
2515 // which its associated classes are defined.
2516
2517 // Add the class of which it is a member, if any.
2518 DeclContext *Ctx = Class->getDeclContext();
2519 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2520 Result.Classes.insert(EnclosingClass);
2521 // Add the associated namespace for this class.
2522 CollectEnclosingNamespace(Result.Namespaces, Ctx);
2523
2524 // Add the class itself. If we've already seen this class, we don't
2525 // need to visit base classes.
2526 //
2527 // FIXME: That's not correct, we may have added this class only because it
2528 // was the enclosing class of another class, and in that case we won't have
2529 // added its base classes yet.
2530 if (!Result.Classes.insert(Class))
2531 return;
2532
2533 // -- If T is a template-id, its associated namespaces and classes are
2534 // the namespace in which the template is defined; for member
2535 // templates, the member template's class; the namespaces and classes
2536 // associated with the types of the template arguments provided for
2537 // template type parameters (excluding template template parameters); the
2538 // namespaces in which any template template arguments are defined; and
2539 // the classes in which any member templates used as template template
2540 // arguments are defined. [Note: non-type template arguments do not
2541 // contribute to the set of associated namespaces. ]
2542 if (ClassTemplateSpecializationDecl *Spec
2543 = dyn_cast<ClassTemplateSpecializationDecl>(Class)) {
2544 DeclContext *Ctx = Spec->getSpecializedTemplate()->getDeclContext();
2545 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2546 Result.Classes.insert(EnclosingClass);
2547 // Add the associated namespace for this class.
2548 CollectEnclosingNamespace(Result.Namespaces, Ctx);
2549
2550 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
2551 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
2552 addAssociatedClassesAndNamespaces(Result, TemplateArgs[I]);
2553 }
2554
2555 // Only recurse into base classes for complete types.
2556 if (!Result.S.isCompleteType(Result.InstantiationLoc,
2557 Result.S.Context.getRecordType(Class)))
2558 return;
2559
2560 // Add direct and indirect base classes along with their associated
2561 // namespaces.
2562 SmallVector<CXXRecordDecl *, 32> Bases;
2563 Bases.push_back(Class);
2564 while (!Bases.empty()) {
2565 // Pop this class off the stack.
2566 Class = Bases.pop_back_val();
2567
2568 // Visit the base classes.
2569 for (const auto &Base : Class->bases()) {
2570 const RecordType *BaseType = Base.getType()->getAs<RecordType>();
2571 // In dependent contexts, we do ADL twice, and the first time around,
2572 // the base type might be a dependent TemplateSpecializationType, or a
2573 // TemplateTypeParmType. If that happens, simply ignore it.
2574 // FIXME: If we want to support export, we probably need to add the
2575 // namespace of the template in a TemplateSpecializationType, or even
2576 // the classes and namespaces of known non-dependent arguments.
2577 if (!BaseType)
2578 continue;
2579 CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(BaseType->getDecl());
2580 if (Result.Classes.insert(BaseDecl)) {
2581 // Find the associated namespace for this base class.
2582 DeclContext *BaseCtx = BaseDecl->getDeclContext();
2583 CollectEnclosingNamespace(Result.Namespaces, BaseCtx);
2584
2585 // Make sure we visit the bases of this base class.
2586 if (BaseDecl->bases_begin() != BaseDecl->bases_end())
2587 Bases.push_back(BaseDecl);
2588 }
2589 }
2590 }
2591}
2592
2593// \brief Add the associated classes and namespaces for
2594// argument-dependent lookup with an argument of type T
2595// (C++ [basic.lookup.koenig]p2).
2596static void
2597addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) {
2598 // C++ [basic.lookup.koenig]p2:
2599 //
2600 // For each argument type T in the function call, there is a set
2601 // of zero or more associated namespaces and a set of zero or more
2602 // associated classes to be considered. The sets of namespaces and
2603 // classes is determined entirely by the types of the function
2604 // arguments (and the namespace of any template template
2605 // argument). Typedef names and using-declarations used to specify
2606 // the types do not contribute to this set. The sets of namespaces
2607 // and classes are determined in the following way:
2608
2609 SmallVector<const Type *, 16> Queue;
2610 const Type *T = Ty->getCanonicalTypeInternal().getTypePtr();
2611
2612 while (true) {
2613 switch (T->getTypeClass()) {
2614
2615#define TYPE(Class, Base)
2616#define DEPENDENT_TYPE(Class, Base) case Type::Class:
2617#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2618#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
2619#define ABSTRACT_TYPE(Class, Base)
2620#include "clang/AST/TypeNodes.def"
2621 // T is canonical. We can also ignore dependent types because
2622 // we don't need to do ADL at the definition point, but if we
2623 // wanted to implement template export (or if we find some other
2624 // use for associated classes and namespaces...) this would be
2625 // wrong.
2626 break;
2627
2628 // -- If T is a pointer to U or an array of U, its associated
2629 // namespaces and classes are those associated with U.
2630 case Type::Pointer:
2631 T = cast<PointerType>(T)->getPointeeType().getTypePtr();
2632 continue;
2633 case Type::ConstantArray:
2634 case Type::IncompleteArray:
2635 case Type::VariableArray:
2636 T = cast<ArrayType>(T)->getElementType().getTypePtr();
2637 continue;
2638
2639 // -- If T is a fundamental type, its associated sets of
2640 // namespaces and classes are both empty.
2641 case Type::Builtin:
2642 break;
2643
2644 // -- If T is a class type (including unions), its associated
2645 // classes are: the class itself; the class of which it is a
2646 // member, if any; and its direct and indirect base
2647 // classes. Its associated namespaces are the namespaces in
2648 // which its associated classes are defined.
2649 case Type::Record: {
2650 CXXRecordDecl *Class =
2651 cast<CXXRecordDecl>(cast<RecordType>(T)->getDecl());
2652 addAssociatedClassesAndNamespaces(Result, Class);
2653 break;
2654 }
2655
2656 // -- If T is an enumeration type, its associated namespace is
2657 // the namespace in which it is defined. If it is class
2658 // member, its associated class is the member's class; else
2659 // it has no associated class.
2660 case Type::Enum: {
2661 EnumDecl *Enum = cast<EnumType>(T)->getDecl();
2662
2663 DeclContext *Ctx = Enum->getDeclContext();
2664 if (CXXRecordDecl *EnclosingClass = dyn_cast<CXXRecordDecl>(Ctx))
2665 Result.Classes.insert(EnclosingClass);
2666
2667 // Add the associated namespace for this class.
2668 CollectEnclosingNamespace(Result.Namespaces, Ctx);
2669
2670 break;
2671 }
2672
2673 // -- If T is a function type, its associated namespaces and
2674 // classes are those associated with the function parameter
2675 // types and those associated with the return type.
2676 case Type::FunctionProto: {
2677 const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
2678 for (const auto &Arg : Proto->param_types())
2679 Queue.push_back(Arg.getTypePtr());
2680 // fallthrough
2681 LLVM_FALLTHROUGH[[clang::fallthrough]];
2682 }
2683 case Type::FunctionNoProto: {
2684 const FunctionType *FnType = cast<FunctionType>(T);
2685 T = FnType->getReturnType().getTypePtr();
2686 continue;
2687 }
2688
2689 // -- If T is a pointer to a member function of a class X, its
2690 // associated namespaces and classes are those associated
2691 // with the function parameter types and return type,
2692 // together with those associated with X.
2693 //
2694 // -- If T is a pointer to a data member of class X, its
2695 // associated namespaces and classes are those associated
2696 // with the member type together with those associated with
2697 // X.
2698 case Type::MemberPointer: {
2699 const MemberPointerType *MemberPtr = cast<MemberPointerType>(T);
2700
2701 // Queue up the class type into which this points.
2702 Queue.push_back(MemberPtr->getClass());
2703
2704 // And directly continue with the pointee type.
2705 T = MemberPtr->getPointeeType().getTypePtr();
2706 continue;
2707 }
2708
2709 // As an extension, treat this like a normal pointer.
2710 case Type::BlockPointer:
2711 T = cast<BlockPointerType>(T)->getPointeeType().getTypePtr();
2712 continue;
2713
2714 // References aren't covered by the standard, but that's such an
2715 // obvious defect that we cover them anyway.
2716 case Type::LValueReference:
2717 case Type::RValueReference:
2718 T = cast<ReferenceType>(T)->getPointeeType().getTypePtr();
2719 continue;
2720
2721 // These are fundamental types.
2722 case Type::Vector:
2723 case Type::ExtVector:
2724 case Type::Complex:
2725 break;
2726
2727 // Non-deduced auto types only get here for error cases.
2728 case Type::Auto:
2729 case Type::DeducedTemplateSpecialization:
2730 break;
2731
2732 // If T is an Objective-C object or interface type, or a pointer to an
2733 // object or interface type, the associated namespace is the global
2734 // namespace.
2735 case Type::ObjCObject:
2736 case Type::ObjCInterface:
2737 case Type::ObjCObjectPointer:
2738 Result.Namespaces.insert(Result.S.Context.getTranslationUnitDecl());
2739 break;
2740
2741 // Atomic types are just wrappers; use the associations of the
2742 // contained type.
2743 case Type::Atomic:
2744 T = cast<AtomicType>(T)->getValueType().getTypePtr();
2745 continue;
2746 case Type::Pipe:
2747 T = cast<PipeType>(T)->getElementType().getTypePtr();
2748 continue;
2749 }
2750
2751 if (Queue.empty())
2752 break;
2753 T = Queue.pop_back_val();
2754 }
2755}
2756
2757/// \brief Find the associated classes and namespaces for
2758/// argument-dependent lookup for a call with the given set of
2759/// arguments.
2760///
2761/// This routine computes the sets of associated classes and associated
2762/// namespaces searched by argument-dependent lookup
2763/// (C++ [basic.lookup.argdep]) for a given set of arguments.
2764void Sema::FindAssociatedClassesAndNamespaces(
2765 SourceLocation InstantiationLoc, ArrayRef<Expr *> Args,
2766 AssociatedNamespaceSet &AssociatedNamespaces,
2767 AssociatedClassSet &AssociatedClasses) {
2768 AssociatedNamespaces.clear();
2769 AssociatedClasses.clear();
2770
2771 AssociatedLookup Result(*this, InstantiationLoc,
2772 AssociatedNamespaces, AssociatedClasses);
2773
2774 // C++ [basic.lookup.koenig]p2:
2775 // For each argument type T in the function call, there is a set
2776 // of zero or more associated namespaces and a set of zero or more
2777 // associated classes to be considered. The sets of namespaces and
2778 // classes is determined entirely by the types of the function
2779 // arguments (and the namespace of any template template
2780 // argument).
2781 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
2782 Expr *Arg = Args[ArgIdx];
2783
2784 if (Arg->getType() != Context.OverloadTy) {
2785 addAssociatedClassesAndNamespaces(Result, Arg->getType());
2786 continue;
2787 }
2788
2789 // [...] In addition, if the argument is the name or address of a
2790 // set of overloaded functions and/or function templates, its
2791 // associated classes and namespaces are the union of those
2792 // associated with each of the members of the set: the namespace
2793 // in which the function or function template is defined and the
2794 // classes and namespaces associated with its (non-dependent)
2795 // parameter types and return type.
2796 Arg = Arg->IgnoreParens();
2797 if (UnaryOperator *unaryOp = dyn_cast<UnaryOperator>(Arg))
2798 if (unaryOp->getOpcode() == UO_AddrOf)
2799 Arg = unaryOp->getSubExpr();
2800
2801 UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Arg);
2802 if (!ULE) continue;
2803
2804 for (const auto *D : ULE->decls()) {
2805 // Look through any using declarations to find the underlying function.
2806 const FunctionDecl *FDecl = D->getUnderlyingDecl()->getAsFunction();
2807
2808 // Add the classes and namespaces associated with the parameter
2809 // types and return type of this function.
2810 addAssociatedClassesAndNamespaces(Result, FDecl->getType());
2811 }
2812 }
2813}
2814
2815NamedDecl *Sema::LookupSingleName(Scope *S, DeclarationName Name,
2816 SourceLocation Loc,
2817 LookupNameKind NameKind,
2818 RedeclarationKind Redecl) {
2819 LookupResult R(*this, Name, Loc, NameKind, Redecl);
2820 LookupName(R, S);
2821 return R.getAsSingle<NamedDecl>();
2822}
2823
2824/// \brief Find the protocol with the given name, if any.
2825ObjCProtocolDecl *Sema::LookupProtocol(IdentifierInfo *II,
2826 SourceLocation IdLoc,
2827 RedeclarationKind Redecl) {
2828 Decl *D = LookupSingleName(TUScope, II, IdLoc,
2829 LookupObjCProtocolName, Redecl);
2830 return cast_or_null<ObjCProtocolDecl>(D);
2831}
2832
2833void Sema::LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
2834 QualType T1, QualType T2,
2835 UnresolvedSetImpl &Functions) {
2836 // C++ [over.match.oper]p3:
2837 // -- The set of non-member candidates is the result of the
2838 // unqualified lookup of operator@ in the context of the
2839 // expression according to the usual rules for name lookup in
2840 // unqualified function calls (3.4.2) except that all member
2841 // functions are ignored.
2842 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
2843 LookupResult Operators(*this, OpName, SourceLocation(), LookupOperatorName);
2844 LookupName(Operators, S);
2845
2846 assert(!Operators.isAmbiguous() && "Operator lookup cannot be ambiguous")(static_cast <bool> (!Operators.isAmbiguous() &&
"Operator lookup cannot be ambiguous") ? void (0) : __assert_fail
("!Operators.isAmbiguous() && \"Operator lookup cannot be ambiguous\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2846, __extension__ __PRETTY_FUNCTION__))
;
2847 Functions.append(Operators.begin(), Operators.end());
2848}
2849
2850Sema::SpecialMemberOverloadResult Sema::LookupSpecialMember(CXXRecordDecl *RD,
2851 CXXSpecialMember SM,
2852 bool ConstArg,
2853 bool VolatileArg,
2854 bool RValueThis,
2855 bool ConstThis,
2856 bool VolatileThis) {
2857 assert(CanDeclareSpecialMemberFunction(RD) &&(static_cast <bool> (CanDeclareSpecialMemberFunction(RD
) && "doing special member lookup into record that isn't fully complete"
) ? void (0) : __assert_fail ("CanDeclareSpecialMemberFunction(RD) && \"doing special member lookup into record that isn't fully complete\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2858, __extension__ __PRETTY_FUNCTION__))
2858 "doing special member lookup into record that isn't fully complete")(static_cast <bool> (CanDeclareSpecialMemberFunction(RD
) && "doing special member lookup into record that isn't fully complete"
) ? void (0) : __assert_fail ("CanDeclareSpecialMemberFunction(RD) && \"doing special member lookup into record that isn't fully complete\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2858, __extension__ __PRETTY_FUNCTION__))
;
2859 RD = RD->getDefinition();
2860 if (RValueThis || ConstThis || VolatileThis)
2861 assert((SM == CXXCopyAssignment || SM == CXXMoveAssignment) &&(static_cast <bool> ((SM == CXXCopyAssignment || SM == CXXMoveAssignment
) && "constructors and destructors always have unqualified lvalue this"
) ? void (0) : __assert_fail ("(SM == CXXCopyAssignment || SM == CXXMoveAssignment) && \"constructors and destructors always have unqualified lvalue this\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2862, __extension__ __PRETTY_FUNCTION__))
2862 "constructors and destructors always have unqualified lvalue this")(static_cast <bool> ((SM == CXXCopyAssignment || SM == CXXMoveAssignment
) && "constructors and destructors always have unqualified lvalue this"
) ? void (0) : __assert_fail ("(SM == CXXCopyAssignment || SM == CXXMoveAssignment) && \"constructors and destructors always have unqualified lvalue this\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2862, __extension__ __PRETTY_FUNCTION__))
;
2863 if (ConstArg || VolatileArg)
2864 assert((SM != CXXDefaultConstructor && SM != CXXDestructor) &&(static_cast <bool> ((SM != CXXDefaultConstructor &&
SM != CXXDestructor) && "parameter-less special members can't have qualified arguments"
) ? void (0) : __assert_fail ("(SM != CXXDefaultConstructor && SM != CXXDestructor) && \"parameter-less special members can't have qualified arguments\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2865, __extension__ __PRETTY_FUNCTION__))
2865 "parameter-less special members can't have qualified arguments")(static_cast <bool> ((SM != CXXDefaultConstructor &&
SM != CXXDestructor) && "parameter-less special members can't have qualified arguments"
) ? void (0) : __assert_fail ("(SM != CXXDefaultConstructor && SM != CXXDestructor) && \"parameter-less special members can't have qualified arguments\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2865, __extension__ __PRETTY_FUNCTION__))
;
2866
2867 // FIXME: Get the caller to pass in a location for the lookup.
2868 SourceLocation LookupLoc = RD->getLocation();
2869
2870 llvm::FoldingSetNodeID ID;
2871 ID.AddPointer(RD);
2872 ID.AddInteger(SM);
2873 ID.AddInteger(ConstArg);
2874 ID.AddInteger(VolatileArg);
2875 ID.AddInteger(RValueThis);
2876 ID.AddInteger(ConstThis);
2877 ID.AddInteger(VolatileThis);
2878
2879 void *InsertPoint;
2880 SpecialMemberOverloadResultEntry *Result =
2881 SpecialMemberCache.FindNodeOrInsertPos(ID, InsertPoint);
2882
2883 // This was already cached
2884 if (Result)
2885 return *Result;
2886
2887 Result = BumpAlloc.Allocate<SpecialMemberOverloadResultEntry>();
2888 Result = new (Result) SpecialMemberOverloadResultEntry(ID);
2889 SpecialMemberCache.InsertNode(Result, InsertPoint);
2890
2891 if (SM == CXXDestructor) {
2892 if (RD->needsImplicitDestructor())
2893 DeclareImplicitDestructor(RD);
2894 CXXDestructorDecl *DD = RD->getDestructor();
2895 assert(DD && "record without a destructor")(static_cast <bool> (DD && "record without a destructor"
) ? void (0) : __assert_fail ("DD && \"record without a destructor\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2895, __extension__ __PRETTY_FUNCTION__))
;
2896 Result->setMethod(DD);
2897 Result->setKind(DD->isDeleted() ?
2898 SpecialMemberOverloadResult::NoMemberOrDeleted :
2899 SpecialMemberOverloadResult::Success);
2900 return *Result;
2901 }
2902
2903 // Prepare for overload resolution. Here we construct a synthetic argument
2904 // if necessary and make sure that implicit functions are declared.
2905 CanQualType CanTy = Context.getCanonicalType(Context.getTagDeclType(RD));
2906 DeclarationName Name;
2907 Expr *Arg = nullptr;
2908 unsigned NumArgs;
2909
2910 QualType ArgType = CanTy;
2911 ExprValueKind VK = VK_LValue;
2912
2913 if (SM == CXXDefaultConstructor) {
2914 Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
2915 NumArgs = 0;
2916 if (RD->needsImplicitDefaultConstructor())
2917 DeclareImplicitDefaultConstructor(RD);
2918 } else {
2919 if (SM == CXXCopyConstructor || SM == CXXMoveConstructor) {
2920 Name = Context.DeclarationNames.getCXXConstructorName(CanTy);
2921 if (RD->needsImplicitCopyConstructor())
2922 DeclareImplicitCopyConstructor(RD);
2923 if (getLangOpts().CPlusPlus11 && RD->needsImplicitMoveConstructor())
2924 DeclareImplicitMoveConstructor(RD);
2925 } else {
2926 Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
2927 if (RD->needsImplicitCopyAssignment())
2928 DeclareImplicitCopyAssignment(RD);
2929 if (getLangOpts().CPlusPlus11 && RD->needsImplicitMoveAssignment())
2930 DeclareImplicitMoveAssignment(RD);
2931 }
2932
2933 if (ConstArg)
2934 ArgType.addConst();
2935 if (VolatileArg)
2936 ArgType.addVolatile();
2937
2938 // This isn't /really/ specified by the standard, but it's implied
2939 // we should be working from an RValue in the case of move to ensure
2940 // that we prefer to bind to rvalue references, and an LValue in the
2941 // case of copy to ensure we don't bind to rvalue references.
2942 // Possibly an XValue is actually correct in the case of move, but
2943 // there is no semantic difference for class types in this restricted
2944 // case.
2945 if (SM == CXXCopyConstructor || SM == CXXCopyAssignment)
2946 VK = VK_LValue;
2947 else
2948 VK = VK_RValue;
2949 }
2950
2951 OpaqueValueExpr FakeArg(LookupLoc, ArgType, VK);
2952
2953 if (SM != CXXDefaultConstructor) {
2954 NumArgs = 1;
2955 Arg = &FakeArg;
2956 }
2957
2958 // Create the object argument
2959 QualType ThisTy = CanTy;
2960 if (ConstThis)
2961 ThisTy.addConst();
2962 if (VolatileThis)
2963 ThisTy.addVolatile();
2964 Expr::Classification Classification =
2965 OpaqueValueExpr(LookupLoc, ThisTy,
2966 RValueThis ? VK_RValue : VK_LValue).Classify(Context);
2967
2968 // Now we perform lookup on the name we computed earlier and do overload
2969 // resolution. Lookup is only performed directly into the class since there
2970 // will always be a (possibly implicit) declaration to shadow any others.
2971 OverloadCandidateSet OCS(LookupLoc, OverloadCandidateSet::CSK_Normal);
2972 DeclContext::lookup_result R = RD->lookup(Name);
2973
2974 if (R.empty()) {
2975 // We might have no default constructor because we have a lambda's closure
2976 // type, rather than because there's some other declared constructor.
2977 // Every class has a copy/move constructor, copy/move assignment, and
2978 // destructor.
2979 assert(SM == CXXDefaultConstructor &&(static_cast <bool> (SM == CXXDefaultConstructor &&
"lookup for a constructor or assignment operator was empty")
? void (0) : __assert_fail ("SM == CXXDefaultConstructor && \"lookup for a constructor or assignment operator was empty\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2980, __extension__ __PRETTY_FUNCTION__))
2980 "lookup for a constructor or assignment operator was empty")(static_cast <bool> (SM == CXXDefaultConstructor &&
"lookup for a constructor or assignment operator was empty")
? void (0) : __assert_fail ("SM == CXXDefaultConstructor && \"lookup for a constructor or assignment operator was empty\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 2980, __extension__ __PRETTY_FUNCTION__))
;
2981 Result->setMethod(nullptr);
2982 Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
2983 return *Result;
2984 }
2985
2986 // Copy the candidates as our processing of them may load new declarations
2987 // from an external source and invalidate lookup_result.
2988 SmallVector<NamedDecl *, 8> Candidates(R.begin(), R.end());
2989
2990 for (NamedDecl *CandDecl : Candidates) {
2991 if (CandDecl->isInvalidDecl())
2992 continue;
2993
2994 DeclAccessPair Cand = DeclAccessPair::make(CandDecl, AS_public);
2995 auto CtorInfo = getConstructorInfo(Cand);
2996 if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
2997 if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
2998 AddMethodCandidate(M, Cand, RD, ThisTy, Classification,
2999 llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
3000 else if (CtorInfo)
3001 AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl,
3002 llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
3003 else
3004 AddOverloadCandidate(M, Cand, llvm::makeArrayRef(&Arg, NumArgs), OCS,
3005 true);
3006 } else if (FunctionTemplateDecl *Tmpl =
3007 dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) {
3008 if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
3009 AddMethodTemplateCandidate(
3010 Tmpl, Cand, RD, nullptr, ThisTy, Classification,
3011 llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
3012 else if (CtorInfo)
3013 AddTemplateOverloadCandidate(
3014 CtorInfo.ConstructorTmpl, CtorInfo.FoundDecl, nullptr,
3015 llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
3016 else
3017 AddTemplateOverloadCandidate(
3018 Tmpl, Cand, nullptr, llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
3019 } else {
3020 assert(isa<UsingDecl>(Cand.getDecl()) &&(static_cast <bool> (isa<UsingDecl>(Cand.getDecl(
)) && "illegal Kind of operator = Decl") ? void (0) :
__assert_fail ("isa<UsingDecl>(Cand.getDecl()) && \"illegal Kind of operator = Decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3021, __extension__ __PRETTY_FUNCTION__))
3021 "illegal Kind of operator = Decl")(static_cast <bool> (isa<UsingDecl>(Cand.getDecl(
)) && "illegal Kind of operator = Decl") ? void (0) :
__assert_fail ("isa<UsingDecl>(Cand.getDecl()) && \"illegal Kind of operator = Decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3021, __extension__ __PRETTY_FUNCTION__))
;
3022 }
3023 }
3024
3025 OverloadCandidateSet::iterator Best;
3026 switch (OCS.BestViableFunction(*this, LookupLoc, Best)) {
3027 case OR_Success:
3028 Result->setMethod(cast<CXXMethodDecl>(Best->Function));
3029 Result->setKind(SpecialMemberOverloadResult::Success);
3030 break;
3031
3032 case OR_Deleted:
3033 Result->setMethod(cast<CXXMethodDecl>(Best->Function));
3034 Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
3035 break;
3036
3037 case OR_Ambiguous:
3038 Result->setMethod(nullptr);
3039 Result->setKind(SpecialMemberOverloadResult::Ambiguous);
3040 break;
3041
3042 case OR_No_Viable_Function:
3043 Result->setMethod(nullptr);
3044 Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
3045 break;
3046 }
3047
3048 return *Result;
3049}
3050
3051/// \brief Look up the default constructor for the given class.
3052CXXConstructorDecl *Sema::LookupDefaultConstructor(CXXRecordDecl *Class) {
3053 SpecialMemberOverloadResult Result =
3054 LookupSpecialMember(Class, CXXDefaultConstructor, false, false, false,
3055 false, false);
3056
3057 return cast_or_null<CXXConstructorDecl>(Result.getMethod());
3058}
3059
3060/// \brief Look up the copying constructor for the given class.
3061CXXConstructorDecl *Sema::LookupCopyingConstructor(CXXRecordDecl *Class,
3062 unsigned Quals) {
3063 assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&(static_cast <bool> (!(Quals & ~(Qualifiers::Const |
Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy ctor arg"
) ? void (0) : __assert_fail ("!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy ctor arg\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3064, __extension__ __PRETTY_FUNCTION__))
3064 "non-const, non-volatile qualifiers for copy ctor arg")(static_cast <bool> (!(Quals & ~(Qualifiers::Const |
Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy ctor arg"
) ? void (0) : __assert_fail ("!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy ctor arg\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3064, __extension__ __PRETTY_FUNCTION__))
;
3065 SpecialMemberOverloadResult Result =
3066 LookupSpecialMember(Class, CXXCopyConstructor, Quals & Qualifiers::Const,
3067 Quals & Qualifiers::Volatile, false, false, false);
3068
3069 return cast_or_null<CXXConstructorDecl>(Result.getMethod());
3070}
3071
3072/// \brief Look up the moving constructor for the given class.
3073CXXConstructorDecl *Sema::LookupMovingConstructor(CXXRecordDecl *Class,
3074 unsigned Quals) {
3075 SpecialMemberOverloadResult Result =
3076 LookupSpecialMember(Class, CXXMoveConstructor, Quals & Qualifiers::Const,
3077 Quals & Qualifiers::Volatile, false, false, false);
3078
3079 return cast_or_null<CXXConstructorDecl>(Result.getMethod());
3080}
3081
3082/// \brief Look up the constructors for the given class.
3083DeclContext::lookup_result Sema::LookupConstructors(CXXRecordDecl *Class) {
3084 // If the implicit constructors have not yet been declared, do so now.
3085 if (CanDeclareSpecialMemberFunction(Class)) {
3086 if (Class->needsImplicitDefaultConstructor())
3087 DeclareImplicitDefaultConstructor(Class);
3088 if (Class->needsImplicitCopyConstructor())
3089 DeclareImplicitCopyConstructor(Class);
3090 if (getLangOpts().CPlusPlus11 && Class->needsImplicitMoveConstructor())
3091 DeclareImplicitMoveConstructor(Class);
3092 }
3093
3094 CanQualType T = Context.getCanonicalType(Context.getTypeDeclType(Class));
3095 DeclarationName Name = Context.DeclarationNames.getCXXConstructorName(T);
3096 return Class->lookup(Name);
3097}
3098
3099/// \brief Look up the copying assignment operator for the given class.
3100CXXMethodDecl *Sema::LookupCopyingAssignment(CXXRecordDecl *Class,
3101 unsigned Quals, bool RValueThis,
3102 unsigned ThisQuals) {
3103 assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&(static_cast <bool> (!(Quals & ~(Qualifiers::Const |
Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy assignment arg"
) ? void (0) : __assert_fail ("!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy assignment arg\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3104, __extension__ __PRETTY_FUNCTION__))
3104 "non-const, non-volatile qualifiers for copy assignment arg")(static_cast <bool> (!(Quals & ~(Qualifiers::Const |
Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy assignment arg"
) ? void (0) : __assert_fail ("!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy assignment arg\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3104, __extension__ __PRETTY_FUNCTION__))
;
3105 assert(!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&(static_cast <bool> (!(ThisQuals & ~(Qualifiers::Const
| Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy assignment this"
) ? void (0) : __assert_fail ("!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy assignment this\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3106, __extension__ __PRETTY_FUNCTION__))
3106 "non-const, non-volatile qualifiers for copy assignment this")(static_cast <bool> (!(ThisQuals & ~(Qualifiers::Const
| Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy assignment this"
) ? void (0) : __assert_fail ("!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy assignment this\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3106, __extension__ __PRETTY_FUNCTION__))
;
3107 SpecialMemberOverloadResult Result =
3108 LookupSpecialMember(Class, CXXCopyAssignment, Quals & Qualifiers::Const,
3109 Quals & Qualifiers::Volatile, RValueThis,
3110 ThisQuals & Qualifiers::Const,
3111 ThisQuals & Qualifiers::Volatile);
3112
3113 return Result.getMethod();
3114}
3115
3116/// \brief Look up the moving assignment operator for the given class.
3117CXXMethodDecl *Sema::LookupMovingAssignment(CXXRecordDecl *Class,
3118 unsigned Quals,
3119 bool RValueThis,
3120 unsigned ThisQuals) {
3121 assert(!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) &&(static_cast <bool> (!(ThisQuals & ~(Qualifiers::Const
| Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy assignment this"
) ? void (0) : __assert_fail ("!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy assignment this\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3122, __extension__ __PRETTY_FUNCTION__))
3122 "non-const, non-volatile qualifiers for copy assignment this")(static_cast <bool> (!(ThisQuals & ~(Qualifiers::Const
| Qualifiers::Volatile)) && "non-const, non-volatile qualifiers for copy assignment this"
) ? void (0) : __assert_fail ("!(ThisQuals & ~(Qualifiers::Const | Qualifiers::Volatile)) && \"non-const, non-volatile qualifiers for copy assignment this\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3122, __extension__ __PRETTY_FUNCTION__))
;
3123 SpecialMemberOverloadResult Result =
3124 LookupSpecialMember(Class, CXXMoveAssignment, Quals & Qualifiers::Const,
3125 Quals & Qualifiers::Volatile, RValueThis,
3126 ThisQuals & Qualifiers::Const,
3127 ThisQuals & Qualifiers::Volatile);
3128
3129 return Result.getMethod();
3130}
3131
3132/// \brief Look for the destructor of the given class.
3133///
3134/// During semantic analysis, this routine should be used in lieu of
3135/// CXXRecordDecl::getDestructor().
3136///
3137/// \returns The destructor for this class.
3138CXXDestructorDecl *Sema::LookupDestructor(CXXRecordDecl *Class) {
3139 return cast<CXXDestructorDecl>(LookupSpecialMember(Class, CXXDestructor,
3140 false, false, false,
3141 false, false).getMethod());
3142}
3143
3144/// LookupLiteralOperator - Determine which literal operator should be used for
3145/// a user-defined literal, per C++11 [lex.ext].
3146///
3147/// Normal overload resolution is not used to select which literal operator to
3148/// call for a user-defined literal. Look up the provided literal operator name,
3149/// and filter the results to the appropriate set for the given argument types.
3150Sema::LiteralOperatorLookupResult
3151Sema::LookupLiteralOperator(Scope *S, LookupResult &R,
3152 ArrayRef<QualType> ArgTys,
3153 bool AllowRaw, bool AllowTemplate,
3154 bool AllowStringTemplate, bool DiagnoseMissing) {
3155 LookupName(R, S);
3156 assert(R.getResultKind() != LookupResult::Ambiguous &&(static_cast <bool> (R.getResultKind() != LookupResult::
Ambiguous && "literal operator lookup can't be ambiguous"
) ? void (0) : __assert_fail ("R.getResultKind() != LookupResult::Ambiguous && \"literal operator lookup can't be ambiguous\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3157, __extension__ __PRETTY_FUNCTION__))
3157 "literal operator lookup can't be ambiguous")(static_cast <bool> (R.getResultKind() != LookupResult::
Ambiguous && "literal operator lookup can't be ambiguous"
) ? void (0) : __assert_fail ("R.getResultKind() != LookupResult::Ambiguous && \"literal operator lookup can't be ambiguous\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3157, __extension__ __PRETTY_FUNCTION__))
;
3158
3159 // Filter the lookup results appropriately.
3160 LookupResult::Filter F = R.makeFilter();
3161
3162 bool FoundRaw = false;
3163 bool FoundTemplate = false;
3164 bool FoundStringTemplate = false;
3165 bool FoundExactMatch = false;
3166
3167 while (F.hasNext()) {
3168 Decl *D = F.next();
3169 if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
3170 D = USD->getTargetDecl();
3171
3172 // If the declaration we found is invalid, skip it.
3173 if (D->isInvalidDecl()) {
3174 F.erase();
3175 continue;
3176 }
3177
3178 bool IsRaw = false;
3179 bool IsTemplate = false;
3180 bool IsStringTemplate = false;
3181 bool IsExactMatch = false;
3182
3183 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
3184 if (FD->getNumParams() == 1 &&
3185 FD->getParamDecl(0)->getType()->getAs<PointerType>())
3186 IsRaw = true;
3187 else if (FD->getNumParams() == ArgTys.size()) {
3188 IsExactMatch = true;
3189 for (unsigned ArgIdx = 0; ArgIdx != ArgTys.size(); ++ArgIdx) {
3190 QualType ParamTy = FD->getParamDecl(ArgIdx)->getType();
3191 if (!Context.hasSameUnqualifiedType(ArgTys[ArgIdx], ParamTy)) {
3192 IsExactMatch = false;
3193 break;
3194 }
3195 }
3196 }
3197 }
3198 if (FunctionTemplateDecl *FD = dyn_cast<FunctionTemplateDecl>(D)) {
3199 TemplateParameterList *Params = FD->getTemplateParameters();
3200 if (Params->size() == 1)
3201 IsTemplate = true;
3202 else
3203 IsStringTemplate = true;
3204 }
3205
3206 if (IsExactMatch) {
3207 FoundExactMatch = true;
3208 AllowRaw = false;
3209 AllowTemplate = false;
3210 AllowStringTemplate = false;
3211 if (FoundRaw || FoundTemplate || FoundStringTemplate) {
3212 // Go through again and remove the raw and template decls we've
3213 // already found.
3214 F.restart();
3215 FoundRaw = FoundTemplate = FoundStringTemplate = false;
3216 }
3217 } else if (AllowRaw && IsRaw) {
3218 FoundRaw = true;
3219 } else if (AllowTemplate && IsTemplate) {
3220 FoundTemplate = true;
3221 } else if (AllowStringTemplate && IsStringTemplate) {
3222 FoundStringTemplate = true;
3223 } else {
3224 F.erase();
3225 }
3226 }
3227
3228 F.done();
3229
3230 // C++11 [lex.ext]p3, p4: If S contains a literal operator with a matching
3231 // parameter type, that is used in preference to a raw literal operator
3232 // or literal operator template.
3233 if (FoundExactMatch)
3234 return LOLR_Cooked;
3235
3236 // C++11 [lex.ext]p3, p4: S shall contain a raw literal operator or a literal
3237 // operator template, but not both.
3238 if (FoundRaw && FoundTemplate) {
3239 Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();
3240 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
3241 NoteOverloadCandidate(*I, (*I)->getUnderlyingDecl()->getAsFunction());
3242 return LOLR_Error;
3243 }
3244
3245 if (FoundRaw)
3246 return LOLR_Raw;
3247
3248 if (FoundTemplate)
3249 return LOLR_Template;
3250
3251 if (FoundStringTemplate)
3252 return LOLR_StringTemplate;
3253
3254 // Didn't find anything we could use.
3255 if (DiagnoseMissing) {
3256 Diag(R.getNameLoc(), diag::err_ovl_no_viable_literal_operator)
3257 << R.getLookupName() << (int)ArgTys.size() << ArgTys[0]
3258 << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw
3259 << (AllowTemplate || AllowStringTemplate);
3260 return LOLR_Error;
3261 }
3262
3263 return LOLR_ErrorNoDiagnostic;
3264}
3265
3266void ADLResult::insert(NamedDecl *New) {
3267 NamedDecl *&Old = Decls[cast<NamedDecl>(New->getCanonicalDecl())];
3268
3269 // If we haven't yet seen a decl for this key, or the last decl
3270 // was exactly this one, we're done.
3271 if (Old == nullptr || Old == New) {
3272 Old = New;
3273 return;
3274 }
3275
3276 // Otherwise, decide which is a more recent redeclaration.
3277 FunctionDecl *OldFD = Old->getAsFunction();
3278 FunctionDecl *NewFD = New->getAsFunction();
3279
3280 FunctionDecl *Cursor = NewFD;
3281 while (true) {
3282 Cursor = Cursor->getPreviousDecl();
3283
3284 // If we got to the end without finding OldFD, OldFD is the newer
3285 // declaration; leave things as they are.
3286 if (!Cursor) return;
3287
3288 // If we do find OldFD, then NewFD is newer.
3289 if (Cursor == OldFD) break;
3290
3291 // Otherwise, keep looking.
3292 }
3293
3294 Old = New;
3295}
3296
3297void Sema::ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
3298 ArrayRef<Expr *> Args, ADLResult &Result) {
3299 // Find all of the associated namespaces and classes based on the
3300 // arguments we have.
3301 AssociatedNamespaceSet AssociatedNamespaces;
3302 AssociatedClassSet AssociatedClasses;
3303 FindAssociatedClassesAndNamespaces(Loc, Args,
3304 AssociatedNamespaces,
3305 AssociatedClasses);
3306
3307 // C++ [basic.lookup.argdep]p3:
3308 // Let X be the lookup set produced by unqualified lookup (3.4.1)
3309 // and let Y be the lookup set produced by argument dependent
3310 // lookup (defined as follows). If X contains [...] then Y is
3311 // empty. Otherwise Y is the set of declarations found in the
3312 // namespaces associated with the argument types as described
3313 // below. The set of declarations found by the lookup of the name
3314 // is the union of X and Y.
3315 //
3316 // Here, we compute Y and add its members to the overloaded
3317 // candidate set.
3318 for (auto *NS : AssociatedNamespaces) {
3319 // When considering an associated namespace, the lookup is the
3320 // same as the lookup performed when the associated namespace is
3321 // used as a qualifier (3.4.3.2) except that:
3322 //
3323 // -- Any using-directives in the associated namespace are
3324 // ignored.
3325 //
3326 // -- Any namespace-scope friend functions declared in
3327 // associated classes are visible within their respective
3328 // namespaces even if they are not visible during an ordinary
3329 // lookup (11.4).
3330 DeclContext::lookup_result R = NS->lookup(Name);
3331 for (auto *D : R) {
3332 // If the only declaration here is an ordinary friend, consider
3333 // it only if it was declared in an associated classes.
3334 if ((D->getIdentifierNamespace() & Decl::IDNS_Ordinary) == 0) {
3335 // If it's neither ordinarily visible nor a friend, we can't find it.
3336 if ((D->getIdentifierNamespace() & Decl::IDNS_OrdinaryFriend) == 0)
3337 continue;
3338
3339 bool DeclaredInAssociatedClass = false;
3340 for (Decl *DI = D; DI; DI = DI->getPreviousDecl()) {
3341 DeclContext *LexDC = DI->getLexicalDeclContext();
3342 if (isa<CXXRecordDecl>(LexDC) &&
3343 AssociatedClasses.count(cast<CXXRecordDecl>(LexDC)) &&
3344 isVisible(cast<NamedDecl>(DI))) {
3345 DeclaredInAssociatedClass = true;
3346 break;
3347 }
3348 }
3349 if (!DeclaredInAssociatedClass)
3350 continue;
3351 }
3352
3353 auto *Underlying = D;
3354 if (auto *USD = dyn_cast<UsingShadowDecl>(D))
3355 Underlying = USD->getTargetDecl();
3356
3357 if (!isa<FunctionDecl>(Underlying) &&
3358 !isa<FunctionTemplateDecl>(Underlying))
3359 continue;
3360
3361 if (!isVisible(D)) {
3362 D = findAcceptableDecl(*this, D);
3363 if (!D)
3364 continue;
3365 if (auto *USD = dyn_cast<UsingShadowDecl>(D))
3366 Underlying = USD->getTargetDecl();
3367 }
3368
3369 // FIXME: Preserve D as the FoundDecl.
3370 Result.insert(Underlying);
3371 }
3372 }
3373}
3374
3375//----------------------------------------------------------------------------
3376// Search for all visible declarations.
3377//----------------------------------------------------------------------------
3378VisibleDeclConsumer::~VisibleDeclConsumer() { }
3379
3380bool VisibleDeclConsumer::includeHiddenDecls() const { return false; }
3381
3382namespace {
3383
3384class ShadowContextRAII;
3385
3386class VisibleDeclsRecord {
3387public:
3388 /// \brief An entry in the shadow map, which is optimized to store a
3389 /// single declaration (the common case) but can also store a list
3390 /// of declarations.
3391 typedef llvm::TinyPtrVector<NamedDecl*> ShadowMapEntry;
3392
3393private:
3394 /// \brief A mapping from declaration names to the declarations that have
3395 /// this name within a particular scope.
3396 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
3397
3398 /// \brief A list of shadow maps, which is used to model name hiding.
3399 std::list<ShadowMap> ShadowMaps;
3400
3401 /// \brief The declaration contexts we have already visited.
3402 llvm::SmallPtrSet<DeclContext *, 8> VisitedContexts;
3403
3404 friend class ShadowContextRAII;
3405
3406public:
3407 /// \brief Determine whether we have already visited this context
3408 /// (and, if not, note that we are going to visit that context now).
3409 bool visitedContext(DeclContext *Ctx) {
3410 return !VisitedContexts.insert(Ctx).second;
3411 }
3412
3413 bool alreadyVisitedContext(DeclContext *Ctx) {
3414 return VisitedContexts.count(Ctx);
3415 }
3416
3417 /// \brief Determine whether the given declaration is hidden in the
3418 /// current scope.
3419 ///
3420 /// \returns the declaration that hides the given declaration, or
3421 /// NULL if no such declaration exists.
3422 NamedDecl *checkHidden(NamedDecl *ND);
3423
3424 /// \brief Add a declaration to the current shadow map.
3425 void add(NamedDecl *ND) {
3426 ShadowMaps.back()[ND->getDeclName()].push_back(ND);
3427 }
3428};
3429
3430/// \brief RAII object that records when we've entered a shadow context.
3431class ShadowContextRAII {
3432 VisibleDeclsRecord &Visible;
3433
3434 typedef VisibleDeclsRecord::ShadowMap ShadowMap;
3435
3436public:
3437 ShadowContextRAII(VisibleDeclsRecord &Visible) : Visible(Visible) {
3438 Visible.ShadowMaps.emplace_back();
3439 }
3440
3441 ~ShadowContextRAII() {
3442 Visible.ShadowMaps.pop_back();
3443 }
3444};
3445
3446} // end anonymous namespace
3447
3448NamedDecl *VisibleDeclsRecord::checkHidden(NamedDecl *ND) {
3449 unsigned IDNS = ND->getIdentifierNamespace();
3450 std::list<ShadowMap>::reverse_iterator SM = ShadowMaps.rbegin();
3451 for (std::list<ShadowMap>::reverse_iterator SMEnd = ShadowMaps.rend();
3452 SM != SMEnd; ++SM) {
3453 ShadowMap::iterator Pos = SM->find(ND->getDeclName());
3454 if (Pos == SM->end())
3455 continue;
3456
3457 for (auto *D : Pos->second) {
3458 // A tag declaration does not hide a non-tag declaration.
3459 if (D->hasTagIdentifierNamespace() &&
3460 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
3461 Decl::IDNS_ObjCProtocol)))
3462 continue;
3463
3464 // Protocols are in distinct namespaces from everything else.
3465 if (((D->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
3466 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
3467 D->getIdentifierNamespace() != IDNS)
3468 continue;
3469
3470 // Functions and function templates in the same scope overload
3471 // rather than hide. FIXME: Look for hiding based on function
3472 // signatures!
3473 if (D->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
3474 ND->getUnderlyingDecl()->isFunctionOrFunctionTemplate() &&
3475 SM == ShadowMaps.rbegin())
3476 continue;
3477
3478 // A shadow declaration that's created by a resolved using declaration
3479 // is not hidden by the same using declaration.
3480 if (isa<UsingShadowDecl>(ND) && isa<UsingDecl>(D) &&
3481 cast<UsingShadowDecl>(ND)->getUsingDecl() == D)
3482 continue;
3483
3484 // We've found a declaration that hides this one.
3485 return D;
3486 }
3487 }
3488
3489 return nullptr;
3490}
3491
3492static void LookupVisibleDecls(DeclContext *Ctx, LookupResult &Result,
3493 bool QualifiedNameLookup,
3494 bool InBaseClass,
3495 VisibleDeclConsumer &Consumer,
3496 VisibleDeclsRecord &Visited,
3497 bool IncludeDependentBases = false) {
3498 if (!Ctx)
3499 return;
3500
3501 // Make sure we don't visit the same context twice.
3502 if (Visited.visitedContext(Ctx->getPrimaryContext()))
3503 return;
3504
3505 // Outside C++, lookup results for the TU live on identifiers.
3506 if (isa<TranslationUnitDecl>(Ctx) &&
3507 !Result.getSema().getLangOpts().CPlusPlus) {
3508 auto &S = Result.getSema();
3509 auto &Idents = S.Context.Idents;
3510
3511 // Ensure all external identifiers are in the identifier table.
3512 if (IdentifierInfoLookup *External = Idents.getExternalIdentifierLookup()) {
3513 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
3514 for (StringRef Name = Iter->Next(); !Name.empty(); Name = Iter->Next())
3515 Idents.get(Name);
3516 }
3517
3518 // Walk all lookup results in the TU for each identifier.
3519 for (const auto &Ident : Idents) {
3520 for (auto I = S.IdResolver.begin(Ident.getValue()),
3521 E = S.IdResolver.end();
3522 I != E; ++I) {
3523 if (S.IdResolver.isDeclInScope(*I, Ctx)) {
3524 if (NamedDecl *ND = Result.getAcceptableDecl(*I)) {
3525 Consumer.FoundDecl(ND, Visited.checkHidden(ND), Ctx, InBaseClass);
3526 Visited.add(ND);
3527 }
3528 }
3529 }
3530 }
3531
3532 return;
3533 }
3534
3535 if (CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(Ctx))
3536 Result.getSema().ForceDeclarationOfImplicitMembers(Class);
3537
3538 // Enumerate all of the results in this context.
3539 for (DeclContextLookupResult R : Ctx->lookups()) {
3540 for (auto *D : R) {
3541 if (auto *ND = Result.getAcceptableDecl(D)) {
3542 Consumer.FoundDecl(ND, Visited.checkHidden(ND), Ctx, InBaseClass);
3543 Visited.add(ND);
3544 }
3545 }
3546 }
3547
3548 // Traverse using directives for qualified name lookup.
3549 if (QualifiedNameLookup) {
3550 ShadowContextRAII Shadow(Visited);
3551 for (auto I : Ctx->using_directives()) {
3552 if (!Result.getSema().isVisible(I))
3553 continue;
3554 LookupVisibleDecls(I->getNominatedNamespace(), Result,
3555 QualifiedNameLookup, InBaseClass, Consumer, Visited,
3556 IncludeDependentBases);
3557 }
3558 }
3559
3560 // Traverse the contexts of inherited C++ classes.
3561 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx)) {
3562 if (!Record->hasDefinition())
3563 return;
3564
3565 for (const auto &B : Record->bases()) {
3566 QualType BaseType = B.getType();
3567
3568 RecordDecl *RD;
3569 if (BaseType->isDependentType()) {
3570 if (!IncludeDependentBases) {
3571 // Don't look into dependent bases, because name lookup can't look
3572 // there anyway.
3573 continue;
3574 }
3575 const auto *TST = BaseType->getAs<TemplateSpecializationType>();
3576 if (!TST)
3577 continue;
3578 TemplateName TN = TST->getTemplateName();
3579 const auto *TD =
3580 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
3581 if (!TD)
3582 continue;
3583 RD = TD->getTemplatedDecl();
3584 } else {
3585 const auto *Record = BaseType->getAs<RecordType>();
3586 if (!Record)
3587 continue;
3588 RD = Record->getDecl();
3589 }
3590
3591 // FIXME: It would be nice to be able to determine whether referencing
3592 // a particular member would be ambiguous. For example, given
3593 //
3594 // struct A { int member; };
3595 // struct B { int member; };
3596 // struct C : A, B { };
3597 //
3598 // void f(C *c) { c->### }
3599 //
3600 // accessing 'member' would result in an ambiguity. However, we
3601 // could be smart enough to qualify the member with the base
3602 // class, e.g.,
3603 //
3604 // c->B::member
3605 //
3606 // or
3607 //
3608 // c->A::member
3609
3610 // Find results in this base class (and its bases).
3611 ShadowContextRAII Shadow(Visited);
3612 LookupVisibleDecls(RD, Result, QualifiedNameLookup, true, Consumer,
3613 Visited, IncludeDependentBases);
3614 }
3615 }
3616
3617 // Traverse the contexts of Objective-C classes.
3618 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Ctx)) {
3619 // Traverse categories.
3620 for (auto *Cat : IFace->visible_categories()) {
3621 ShadowContextRAII Shadow(Visited);
3622 LookupVisibleDecls(Cat, Result, QualifiedNameLookup, false,
3623 Consumer, Visited);
3624 }
3625
3626 // Traverse protocols.
3627 for (auto *I : IFace->all_referenced_protocols()) {
3628 ShadowContextRAII Shadow(Visited);
3629 LookupVisibleDecls(I, Result, QualifiedNameLookup, false, Consumer,
3630 Visited);
3631 }
3632
3633 // Traverse the superclass.
3634 if (IFace->getSuperClass()) {
3635 ShadowContextRAII Shadow(Visited);
3636 LookupVisibleDecls(IFace->getSuperClass(), Result, QualifiedNameLookup,
3637 true, Consumer, Visited);
3638 }
3639
3640 // If there is an implementation, traverse it. We do this to find
3641 // synthesized ivars.
3642 if (IFace->getImplementation()) {
3643 ShadowContextRAII Shadow(Visited);
3644 LookupVisibleDecls(IFace->getImplementation(), Result,
3645 QualifiedNameLookup, InBaseClass, Consumer, Visited);
3646 }
3647 } else if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Ctx)) {
3648 for (auto *I : Protocol->protocols()) {
3649 ShadowContextRAII Shadow(Visited);
3650 LookupVisibleDecls(I, Result, QualifiedNameLookup, false, Consumer,
3651 Visited);
3652 }
3653 } else if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Ctx)) {
3654 for (auto *I : Category->protocols()) {
3655 ShadowContextRAII Shadow(Visited);
3656 LookupVisibleDecls(I, Result, QualifiedNameLookup, false, Consumer,
3657 Visited);
3658 }
3659
3660 // If there is an implementation, traverse it.
3661 if (Category->getImplementation()) {
3662 ShadowContextRAII Shadow(Visited);
3663 LookupVisibleDecls(Category->getImplementation(), Result,
3664 QualifiedNameLookup, true, Consumer, Visited);
3665 }
3666 }
3667}
3668
3669static void LookupVisibleDecls(Scope *S, LookupResult &Result,
3670 UnqualUsingDirectiveSet &UDirs,
3671 VisibleDeclConsumer &Consumer,
3672 VisibleDeclsRecord &Visited) {
3673 if (!S)
3674 return;
3675
3676 if (!S->getEntity() ||
3677 (!S->getParent() &&
3678 !Visited.alreadyVisitedContext(S->getEntity())) ||
3679 (S->getEntity())->isFunctionOrMethod()) {
3680 FindLocalExternScope FindLocals(Result);
3681 // Walk through the declarations in this Scope. The consumer might add new
3682 // decls to the scope as part of deserialization, so make a copy first.
3683 SmallVector<Decl *, 8> ScopeDecls(S->decls().begin(), S->decls().end());
3684 for (Decl *D : ScopeDecls) {
3685 if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
3686 if ((ND = Result.getAcceptableDecl(ND))) {
3687 Consumer.FoundDecl(ND, Visited.checkHidden(ND), nullptr, false);
3688 Visited.add(ND);
3689 }
3690 }
3691 }
3692
3693 // FIXME: C++ [temp.local]p8
3694 DeclContext *Entity = nullptr;
3695 if (S->getEntity()) {
3696 // Look into this scope's declaration context, along with any of its
3697 // parent lookup contexts (e.g., enclosing classes), up to the point
3698 // where we hit the context stored in the next outer scope.
3699 Entity = S->getEntity();
3700 DeclContext *OuterCtx = findOuterContext(S).first; // FIXME
3701
3702 for (DeclContext *Ctx = Entity; Ctx && !Ctx->Equals(OuterCtx);
3703 Ctx = Ctx->getLookupParent()) {
3704 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(Ctx)) {
3705 if (Method->isInstanceMethod()) {
3706 // For instance methods, look for ivars in the method's interface.
3707 LookupResult IvarResult(Result.getSema(), Result.getLookupName(),
3708 Result.getNameLoc(), Sema::LookupMemberName);
3709 if (ObjCInterfaceDecl *IFace = Method->getClassInterface()) {
3710 LookupVisibleDecls(IFace, IvarResult, /*QualifiedNameLookup=*/false,
3711 /*InBaseClass=*/false, Consumer, Visited);
3712 }
3713 }
3714
3715 // We've already performed all of the name lookup that we need
3716 // to for Objective-C methods; the next context will be the
3717 // outer scope.
3718 break;
3719 }
3720
3721 if (Ctx->isFunctionOrMethod())
3722 continue;
3723
3724 LookupVisibleDecls(Ctx, Result, /*QualifiedNameLookup=*/false,
3725 /*InBaseClass=*/false, Consumer, Visited);
3726 }
3727 } else if (!S->getParent()) {
3728 // Look into the translation unit scope. We walk through the translation
3729 // unit's declaration context, because the Scope itself won't have all of
3730 // the declarations if we loaded a precompiled header.
3731 // FIXME: We would like the translation unit's Scope object to point to the
3732 // translation unit, so we don't need this special "if" branch. However,
3733 // doing so would force the normal C++ name-lookup code to look into the
3734 // translation unit decl when the IdentifierInfo chains would suffice.
3735 // Once we fix that problem (which is part of a more general "don't look
3736 // in DeclContexts unless we have to" optimization), we can eliminate this.
3737 Entity = Result.getSema().Context.getTranslationUnitDecl();
3738 LookupVisibleDecls(Entity, Result, /*QualifiedNameLookup=*/false,
3739 /*InBaseClass=*/false, Consumer, Visited);
3740 }
3741
3742 if (Entity) {
3743 // Lookup visible declarations in any namespaces found by using
3744 // directives.
3745 for (const UnqualUsingEntry &UUE : UDirs.getNamespacesFor(Entity))
3746 LookupVisibleDecls(const_cast<DeclContext *>(UUE.getNominatedNamespace()),
3747 Result, /*QualifiedNameLookup=*/false,
3748 /*InBaseClass=*/false, Consumer, Visited);
3749 }
3750
3751 // Lookup names in the parent scope.
3752 ShadowContextRAII Shadow(Visited);
3753 LookupVisibleDecls(S->getParent(), Result, UDirs, Consumer, Visited);
3754}
3755
3756void Sema::LookupVisibleDecls(Scope *S, LookupNameKind Kind,
3757 VisibleDeclConsumer &Consumer,
3758 bool IncludeGlobalScope) {
3759 // Determine the set of using directives available during
3760 // unqualified name lookup.
3761 Scope *Initial = S;
3762 UnqualUsingDirectiveSet UDirs(*this);
3763 if (getLangOpts().CPlusPlus) {
3764 // Find the first namespace or translation-unit scope.
3765 while (S && !isNamespaceOrTranslationUnitScope(S))
3766 S = S->getParent();
3767
3768 UDirs.visitScopeChain(Initial, S);
3769 }
3770 UDirs.done();
3771
3772 // Look for visible declarations.
3773 LookupResult Result(*this, DeclarationName(), SourceLocation(), Kind);
3774 Result.setAllowHidden(Consumer.includeHiddenDecls());
3775 VisibleDeclsRecord Visited;
3776 if (!IncludeGlobalScope)
3777 Visited.visitedContext(Context.getTranslationUnitDecl());
3778 ShadowContextRAII Shadow(Visited);
3779 ::LookupVisibleDecls(Initial, Result, UDirs, Consumer, Visited);
3780}
3781
3782void Sema::LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
3783 VisibleDeclConsumer &Consumer,
3784 bool IncludeGlobalScope,
3785 bool IncludeDependentBases) {
3786 LookupResult Result(*this, DeclarationName(), SourceLocation(), Kind);
3787 Result.setAllowHidden(Consumer.includeHiddenDecls());
3788 VisibleDeclsRecord Visited;
3789 if (!IncludeGlobalScope)
3790 Visited.visitedContext(Context.getTranslationUnitDecl());
3791 ShadowContextRAII Shadow(Visited);
3792 ::LookupVisibleDecls(Ctx, Result, /*QualifiedNameLookup=*/true,
3793 /*InBaseClass=*/false, Consumer, Visited,
3794 IncludeDependentBases);
3795}
3796
3797/// LookupOrCreateLabel - Do a name lookup of a label with the specified name.
3798/// If GnuLabelLoc is a valid source location, then this is a definition
3799/// of an __label__ label name, otherwise it is a normal label definition
3800/// or use.
3801LabelDecl *Sema::LookupOrCreateLabel(IdentifierInfo *II, SourceLocation Loc,
3802 SourceLocation GnuLabelLoc) {
3803 // Do a lookup to see if we have a label with this name already.
3804 NamedDecl *Res = nullptr;
3805
3806 if (GnuLabelLoc.isValid()) {
3807 // Local label definitions always shadow existing labels.
3808 Res = LabelDecl::Create(Context, CurContext, Loc, II, GnuLabelLoc);
3809 Scope *S = CurScope;
3810 PushOnScopeChains(Res, S, true);
3811 return cast<LabelDecl>(Res);
3812 }
3813
3814 // Not a GNU local label.
3815 Res = LookupSingleName(CurScope, II, Loc, LookupLabel, NotForRedeclaration);
3816 // If we found a label, check to see if it is in the same context as us.
3817 // When in a Block, we don't want to reuse a label in an enclosing function.
3818 if (Res && Res->getDeclContext() != CurContext)
3819 Res = nullptr;
3820 if (!Res) {
3821 // If not forward referenced or defined already, create the backing decl.
3822 Res = LabelDecl::Create(Context, CurContext, Loc, II);
3823 Scope *S = CurScope->getFnParent();
3824 assert(S && "Not in a function?")(static_cast <bool> (S && "Not in a function?")
? void (0) : __assert_fail ("S && \"Not in a function?\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 3824, __extension__ __PRETTY_FUNCTION__))
;
3825 PushOnScopeChains(Res, S, true);
3826 }
3827 return cast<LabelDecl>(Res);
3828}
3829
3830//===----------------------------------------------------------------------===//
3831// Typo correction
3832//===----------------------------------------------------------------------===//
3833
3834static bool isCandidateViable(CorrectionCandidateCallback &CCC,
3835 TypoCorrection &Candidate) {
3836 Candidate.setCallbackDistance(CCC.RankCandidate(Candidate));
3837 return Candidate.getEditDistance(false) != TypoCorrection::InvalidDistance;
3838}
3839
3840static void LookupPotentialTypoResult(Sema &SemaRef,
3841 LookupResult &Res,
3842 IdentifierInfo *Name,
3843 Scope *S, CXXScopeSpec *SS,
3844 DeclContext *MemberContext,
3845 bool EnteringContext,
3846 bool isObjCIvarLookup,
3847 bool FindHidden);
3848
3849/// \brief Check whether the declarations found for a typo correction are
3850/// visible. Set the correction's RequiresImport flag to true if none of the
3851/// declarations are visible, false otherwise.
3852static void checkCorrectionVisibility(Sema &SemaRef, TypoCorrection &TC) {
3853 TypoCorrection::decl_iterator DI = TC.begin(), DE = TC.end();
3854
3855 for (/**/; DI != DE; ++DI)
3856 if (!LookupResult::isVisible(SemaRef, *DI))
3857 break;
3858 // No filtering needed if all decls are visible.
3859 if (DI == DE) {
3860 TC.setRequiresImport(false);
3861 return;
3862 }
3863
3864 llvm::SmallVector<NamedDecl*, 4> NewDecls(TC.begin(), DI);
3865 bool AnyVisibleDecls = !NewDecls.empty();
3866
3867 for (/**/; DI != DE; ++DI) {
3868 NamedDecl *VisibleDecl = *DI;
3869 if (!LookupResult::isVisible(SemaRef, *DI))
3870 VisibleDecl = findAcceptableDecl(SemaRef, *DI);
3871
3872 if (VisibleDecl) {
3873 if (!AnyVisibleDecls) {
3874 // Found a visible decl, discard all hidden ones.
3875 AnyVisibleDecls = true;
3876 NewDecls.clear();
3877 }
3878 NewDecls.push_back(VisibleDecl);
3879 } else if (!AnyVisibleDecls && !(*DI)->isModulePrivate())
3880 NewDecls.push_back(*DI);
3881 }
3882
3883 if (NewDecls.empty())
3884 TC = TypoCorrection();
3885 else {
3886 TC.setCorrectionDecls(NewDecls);
3887 TC.setRequiresImport(!AnyVisibleDecls);
3888 }
3889}
3890
3891// Fill the supplied vector with the IdentifierInfo pointers for each piece of
3892// the given NestedNameSpecifier (i.e. given a NestedNameSpecifier "foo::bar::",
3893// fill the vector with the IdentifierInfo pointers for "foo" and "bar").
3894static void getNestedNameSpecifierIdentifiers(
3895 NestedNameSpecifier *NNS,
3896 SmallVectorImpl<const IdentifierInfo*> &Identifiers) {
3897 if (NestedNameSpecifier *Prefix = NNS->getPrefix())
3898 getNestedNameSpecifierIdentifiers(Prefix, Identifiers);
3899 else
3900 Identifiers.clear();
3901
3902 const IdentifierInfo *II = nullptr;
3903
3904 switch (NNS->getKind()) {
3905 case NestedNameSpecifier::Identifier:
3906 II = NNS->getAsIdentifier();
3907 break;
3908
3909 case NestedNameSpecifier::Namespace:
3910 if (NNS->getAsNamespace()->isAnonymousNamespace())
3911 return;
3912 II = NNS->getAsNamespace()->getIdentifier();
3913 break;
3914
3915 case NestedNameSpecifier::NamespaceAlias:
3916 II = NNS->getAsNamespaceAlias()->getIdentifier();
3917 break;
3918
3919 case NestedNameSpecifier::TypeSpecWithTemplate:
3920 case NestedNameSpecifier::TypeSpec:
3921 II = QualType(NNS->getAsType(), 0).getBaseTypeIdentifier();
3922 break;
3923
3924 case NestedNameSpecifier::Global:
3925 case NestedNameSpecifier::Super:
3926 return;
3927 }
3928
3929 if (II)
3930 Identifiers.push_back(II);
3931}
3932
3933void TypoCorrectionConsumer::FoundDecl(NamedDecl *ND, NamedDecl *Hiding,
3934 DeclContext *Ctx, bool InBaseClass) {
3935 // Don't consider hidden names for typo correction.
3936 if (Hiding)
3937 return;
3938
3939 // Only consider entities with identifiers for names, ignoring
3940 // special names (constructors, overloaded operators, selectors,
3941 // etc.).
3942 IdentifierInfo *Name = ND->getIdentifier();
3943 if (!Name)
3944 return;
3945
3946 // Only consider visible declarations and declarations from modules with
3947 // names that exactly match.
3948 if (!LookupResult::isVisible(SemaRef, ND) && Name != Typo &&
3949 !findAcceptableDecl(SemaRef, ND))
3950 return;
3951
3952 FoundName(Name->getName());
3953}
3954
3955void TypoCorrectionConsumer::FoundName(StringRef Name) {
3956 // Compute the edit distance between the typo and the name of this
3957 // entity, and add the identifier to the list of results.
3958 addName(Name, nullptr);
3959}
3960
3961void TypoCorrectionConsumer::addKeywordResult(StringRef Keyword) {
3962 // Compute the edit distance between the typo and this keyword,
3963 // and add the keyword to the list of results.
3964 addName(Keyword, nullptr, nullptr, true);
3965}
3966
3967void TypoCorrectionConsumer::addName(StringRef Name, NamedDecl *ND,
3968 NestedNameSpecifier *NNS, bool isKeyword) {
3969 // Use a simple length-based heuristic to determine the minimum possible
3970 // edit distance. If the minimum isn't good enough, bail out early.
3971 StringRef TypoStr = Typo->getName();
3972 unsigned MinED = abs((int)Name.size() - (int)TypoStr.size());
3973 if (MinED && TypoStr.size() / MinED < 3)
3974 return;
3975
3976 // Compute an upper bound on the allowable edit distance, so that the
3977 // edit-distance algorithm can short-circuit.
3978 unsigned UpperBound = (TypoStr.size() + 2) / 3 + 1;
3979 unsigned ED = TypoStr.edit_distance(Name, true, UpperBound);
3980 if (ED >= UpperBound) return;
3981
3982 TypoCorrection TC(&SemaRef.Context.Idents.get(Name), ND, NNS, ED);
3983 if (isKeyword) TC.makeKeyword();
3984 TC.setCorrectionRange(nullptr, Result.getLookupNameInfo());
3985 addCorrection(TC);
3986}
3987
3988static const unsigned MaxTypoDistanceResultSets = 5;
3989
3990void TypoCorrectionConsumer::addCorrection(TypoCorrection Correction) {
3991 StringRef TypoStr = Typo->getName();
3992 StringRef Name = Correction.getCorrectionAsIdentifierInfo()->getName();
3993
3994 // For very short typos, ignore potential corrections that have a different
3995 // base identifier from the typo or which have a normalized edit distance
3996 // longer than the typo itself.
3997 if (TypoStr.size() < 3 &&
3998 (Name != TypoStr || Correction.getEditDistance(true) > TypoStr.size()))
3999 return;
4000
4001 // If the correction is resolved but is not viable, ignore it.
4002 if (Correction.isResolved()) {
4003 checkCorrectionVisibility(SemaRef, Correction);
4004 if (!Correction || !isCandidateViable(*CorrectionValidator, Correction))
4005 return;
4006 }
4007
4008 TypoResultList &CList =
4009 CorrectionResults[Correction.getEditDistance(false)][Name];
4010
4011 if (!CList.empty() && !CList.back().isResolved())
4012 CList.pop_back();
4013 if (NamedDecl *NewND = Correction.getCorrectionDecl()) {
4014 std::string CorrectionStr = Correction.getAsString(SemaRef.getLangOpts());
4015 for (TypoResultList::iterator RI = CList.begin(), RIEnd = CList.end();
4016 RI != RIEnd; ++RI) {
4017 // If the Correction refers to a decl already in the result list,
4018 // replace the existing result if the string representation of Correction
4019 // comes before the current result alphabetically, then stop as there is
4020 // nothing more to be done to add Correction to the candidate set.
4021 if (RI->getCorrectionDecl() == NewND) {
4022 if (CorrectionStr < RI->getAsString(SemaRef.getLangOpts()))
4023 *RI = Correction;
4024 return;
4025 }
4026 }
4027 }
4028 if (CList.empty() || Correction.isResolved())
4029 CList.push_back(Correction);
4030
4031 while (CorrectionResults.size() > MaxTypoDistanceResultSets)
4032 CorrectionResults.erase(std::prev(CorrectionResults.end()));
4033}
4034
4035void TypoCorrectionConsumer::addNamespaces(
4036 const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces) {
4037 SearchNamespaces = true;
4038
4039 for (auto KNPair : KnownNamespaces)
4040 Namespaces.addNameSpecifier(KNPair.first);
4041
4042 bool SSIsTemplate = false;
4043 if (NestedNameSpecifier *NNS =
2
Taking false branch
4044 (SS && SS->isValid()) ? SS->getScopeRep() : nullptr) {
1
'?' condition is false
4045 if (const Type *T = NNS->getAsType())
4046 SSIsTemplate = T->getTypeClass() == Type::TemplateSpecialization;
4047 }
4048 // Do not transform this into an iterator-based loop. The loop body can
4049 // trigger the creation of further types (through lazy deserialization) and
4050 // invalide iterators into this list.
4051 auto &Types = SemaRef.getASTContext().getTypes();
4052 for (unsigned I = 0; I != Types.size(); ++I) {
3
Assuming the condition is true
4
Loop condition is true. Entering loop body
7
Assuming the condition is true
8
Loop condition is true. Entering loop body
11
Assuming the condition is true
12
Loop condition is true. Entering loop body
15
Assuming the condition is true
16
Loop condition is true. Entering loop body
4053 const auto *TI = Types[I];
4054 if (CXXRecordDecl *CD = TI->getAsCXXRecordDecl()) {
5
Assuming 'CD' is null
6
Taking false branch
9
Assuming 'CD' is null
10
Taking false branch
13
Assuming 'CD' is null
14
Taking false branch
17
Assuming 'CD' is non-null
18
Taking true branch
4055 CD = CD->getCanonicalDecl();
4056 if (!CD->isDependentType() && !CD->isAnonymousStructOrUnion() &&
19
Assuming the condition is true
20
Assuming the condition is true
23
Taking true branch
4057 !CD->isUnion() && CD->getIdentifier() &&
4058 (SSIsTemplate || !isa<ClassTemplateSpecializationDecl>(CD)) &&
4059 (CD->isBeingDefined() || CD->isCompleteDefinition()))
21
Assuming the condition is false
22
Assuming the condition is true
4060 Namespaces.addNameSpecifier(CD);
24
Calling 'NamespaceSpecifierSet::addNameSpecifier'
4061 }
4062 }
4063}
4064
4065const TypoCorrection &TypoCorrectionConsumer::getNextCorrection() {
4066 if (++CurrentTCIndex < ValidatedCorrections.size())
4067 return ValidatedCorrections[CurrentTCIndex];
4068
4069 CurrentTCIndex = ValidatedCorrections.size();
4070 while (!CorrectionResults.empty()) {
4071 auto DI = CorrectionResults.begin();
4072 if (DI->second.empty()) {
4073 CorrectionResults.erase(DI);
4074 continue;
4075 }
4076
4077 auto RI = DI->second.begin();
4078 if (RI->second.empty()) {
4079 DI->second.erase(RI);
4080 performQualifiedLookups();
4081 continue;
4082 }
4083
4084 TypoCorrection TC = RI->second.pop_back_val();
4085 if (TC.isResolved() || TC.requiresImport() || resolveCorrection(TC)) {
4086 ValidatedCorrections.push_back(TC);
4087 return ValidatedCorrections[CurrentTCIndex];
4088 }
4089 }
4090 return ValidatedCorrections[0]; // The empty correction.
4091}
4092
4093bool TypoCorrectionConsumer::resolveCorrection(TypoCorrection &Candidate) {
4094 IdentifierInfo *Name = Candidate.getCorrectionAsIdentifierInfo();
4095 DeclContext *TempMemberContext = MemberContext;
4096 CXXScopeSpec *TempSS = SS.get();
4097retry_lookup:
4098 LookupPotentialTypoResult(SemaRef, Result, Name, S, TempSS, TempMemberContext,
4099 EnteringContext,
4100 CorrectionValidator->IsObjCIvarLookup,
4101 Name == Typo && !Candidate.WillReplaceSpecifier());
4102 switch (Result.getResultKind()) {
4103 case LookupResult::NotFound:
4104 case LookupResult::NotFoundInCurrentInstantiation:
4105 case LookupResult::FoundUnresolvedValue:
4106 if (TempSS) {
4107 // Immediately retry the lookup without the given CXXScopeSpec
4108 TempSS = nullptr;
4109 Candidate.WillReplaceSpecifier(true);
4110 goto retry_lookup;
4111 }
4112 if (TempMemberContext) {
4113 if (SS && !TempSS)
4114 TempSS = SS.get();
4115 TempMemberContext = nullptr;
4116 goto retry_lookup;
4117 }
4118 if (SearchNamespaces)
4119 QualifiedResults.push_back(Candidate);
4120 break;
4121
4122 case LookupResult::Ambiguous:
4123 // We don't deal with ambiguities.
4124 break;
4125
4126 case LookupResult::Found:
4127 case LookupResult::FoundOverloaded:
4128 // Store all of the Decls for overloaded symbols
4129 for (auto *TRD : Result)
4130 Candidate.addCorrectionDecl(TRD);
4131 checkCorrectionVisibility(SemaRef, Candidate);
4132 if (!isCandidateViable(*CorrectionValidator, Candidate)) {
4133 if (SearchNamespaces)
4134 QualifiedResults.push_back(Candidate);
4135 break;
4136 }
4137 Candidate.setCorrectionRange(SS.get(), Result.getLookupNameInfo());
4138 return true;
4139 }
4140 return false;
4141}
4142
4143void TypoCorrectionConsumer::performQualifiedLookups() {
4144 unsigned TypoLen = Typo->getName().size();
4145 for (const TypoCorrection &QR : QualifiedResults) {
4146 for (const auto &NSI : Namespaces) {
4147 DeclContext *Ctx = NSI.DeclCtx;
4148 const Type *NSType = NSI.NameSpecifier->getAsType();
4149
4150 // If the current NestedNameSpecifier refers to a class and the
4151 // current correction candidate is the name of that class, then skip
4152 // it as it is unlikely a qualified version of the class' constructor
4153 // is an appropriate correction.
4154 if (CXXRecordDecl *NSDecl = NSType ? NSType->getAsCXXRecordDecl() :
4155 nullptr) {
4156 if (NSDecl->getIdentifier() == QR.getCorrectionAsIdentifierInfo())
4157 continue;
4158 }
4159
4160 TypoCorrection TC(QR);
4161 TC.ClearCorrectionDecls();
4162 TC.setCorrectionSpecifier(NSI.NameSpecifier);
4163 TC.setQualifierDistance(NSI.EditDistance);
4164 TC.setCallbackDistance(0); // Reset the callback distance
4165
4166 // If the current correction candidate and namespace combination are
4167 // too far away from the original typo based on the normalized edit
4168 // distance, then skip performing a qualified name lookup.
4169 unsigned TmpED = TC.getEditDistance(true);
4170 if (QR.getCorrectionAsIdentifierInfo() != Typo && TmpED &&
4171 TypoLen / TmpED < 3)
4172 continue;
4173
4174 Result.clear();
4175 Result.setLookupName(QR.getCorrectionAsIdentifierInfo());
4176 if (!SemaRef.LookupQualifiedName(Result, Ctx))
4177 continue;
4178
4179 // Any corrections added below will be validated in subsequent
4180 // iterations of the main while() loop over the Consumer's contents.
4181 switch (Result.getResultKind()) {
4182 case LookupResult::Found:
4183 case LookupResult::FoundOverloaded: {
4184 if (SS && SS->isValid()) {
4185 std::string NewQualified = TC.getAsString(SemaRef.getLangOpts());
4186 std::string OldQualified;
4187 llvm::raw_string_ostream OldOStream(OldQualified);
4188 SS->getScopeRep()->print(OldOStream, SemaRef.getPrintingPolicy());
4189 OldOStream << Typo->getName();
4190 // If correction candidate would be an identical written qualified
4191 // identifer, then the existing CXXScopeSpec probably included a
4192 // typedef that didn't get accounted for properly.
4193 if (OldOStream.str() == NewQualified)
4194 break;
4195 }
4196 for (LookupResult::iterator TRD = Result.begin(), TRDEnd = Result.end();
4197 TRD != TRDEnd; ++TRD) {
4198 if (SemaRef.CheckMemberAccess(TC.getCorrectionRange().getBegin(),
4199 NSType ? NSType->getAsCXXRecordDecl()
4200 : nullptr,
4201 TRD.getPair()) == Sema::AR_accessible)
4202 TC.addCorrectionDecl(*TRD);
4203 }
4204 if (TC.isResolved()) {
4205 TC.setCorrectionRange(SS.get(), Result.getLookupNameInfo());
4206 addCorrection(TC);
4207 }
4208 break;
4209 }
4210 case LookupResult::NotFound:
4211 case LookupResult::NotFoundInCurrentInstantiation:
4212 case LookupResult::Ambiguous:
4213 case LookupResult::FoundUnresolvedValue:
4214 break;
4215 }
4216 }
4217 }
4218 QualifiedResults.clear();
4219}
4220
4221TypoCorrectionConsumer::NamespaceSpecifierSet::NamespaceSpecifierSet(
4222 ASTContext &Context, DeclContext *CurContext, CXXScopeSpec *CurScopeSpec)
4223 : Context(Context), CurContextChain(buildContextChain(CurContext)) {
4224 if (NestedNameSpecifier *NNS =
4225 CurScopeSpec ? CurScopeSpec->getScopeRep() : nullptr) {
4226 llvm::raw_string_ostream SpecifierOStream(CurNameSpecifier);
4227 NNS->print(SpecifierOStream, Context.getPrintingPolicy());
4228
4229 getNestedNameSpecifierIdentifiers(NNS, CurNameSpecifierIdentifiers);
4230 }
4231 // Build the list of identifiers that would be used for an absolute
4232 // (from the global context) NestedNameSpecifier referring to the current
4233 // context.
4234 for (DeclContext *C : llvm::reverse(CurContextChain)) {
4235 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C))
4236 CurContextIdentifiers.push_back(ND->getIdentifier());
4237 }
4238
4239 // Add the global context as a NestedNameSpecifier
4240 SpecifierInfo SI = {cast<DeclContext>(Context.getTranslationUnitDecl()),
4241 NestedNameSpecifier::GlobalSpecifier(Context), 1};
4242 DistanceMap[1].push_back(SI);
4243}
4244
4245auto TypoCorrectionConsumer::NamespaceSpecifierSet::buildContextChain(
4246 DeclContext *Start) -> DeclContextList {
4247 assert(Start && "Building a context chain from a null context")(static_cast <bool> (Start && "Building a context chain from a null context"
) ? void (0) : __assert_fail ("Start && \"Building a context chain from a null context\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 4247, __extension__ __PRETTY_FUNCTION__))
;
4248 DeclContextList Chain;
4249 for (DeclContext *DC = Start->getPrimaryContext(); DC != nullptr;
4250 DC = DC->getLookupParent()) {
4251 NamespaceDecl *ND = dyn_cast_or_null<NamespaceDecl>(DC);
4252 if (!DC->isInlineNamespace() && !DC->isTransparentContext() &&
4253 !(ND && ND->isAnonymousNamespace()))
4254 Chain.push_back(DC->getPrimaryContext());
4255 }
4256 return Chain;
4257}
4258
4259unsigned
4260TypoCorrectionConsumer::NamespaceSpecifierSet::buildNestedNameSpecifier(
4261 DeclContextList &DeclChain, NestedNameSpecifier *&NNS) {
4262 unsigned NumSpecifiers = 0;
4263 for (DeclContext *C : llvm::reverse(DeclChain)) {
4264 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C)) {
4265 NNS = NestedNameSpecifier::Create(Context, NNS, ND);
4266 ++NumSpecifiers;
4267 } else if (auto *RD = dyn_cast_or_null<RecordDecl>(C)) {
4268 NNS = NestedNameSpecifier::Create(Context, NNS, RD->isTemplateDecl(),
4269 RD->getTypeForDecl());
4270 ++NumSpecifiers;
4271 }
4272 }
4273 return NumSpecifiers;
4274}
4275
4276void TypoCorrectionConsumer::NamespaceSpecifierSet::addNameSpecifier(
4277 DeclContext *Ctx) {
4278 NestedNameSpecifier *NNS = nullptr;
4279 unsigned NumSpecifiers = 0;
4280 DeclContextList NamespaceDeclChain(buildContextChain(Ctx));
4281 DeclContextList FullNamespaceDeclChain(NamespaceDeclChain);
4282
4283 // Eliminate common elements from the two DeclContext chains.
4284 for (DeclContext *C : llvm::reverse(CurContextChain)) {
4285 if (NamespaceDeclChain.empty() || NamespaceDeclChain.back() != C)
25
Assuming the condition is false
26
Taking false branch
27
Assuming the condition is false
28
Taking false branch
29
Assuming the condition is false
30
Taking false branch
31
Assuming the condition is true
32
Taking true branch
4286 break;
33
Execution continues on line 4291
4287 NamespaceDeclChain.pop_back();
4288 }
4289
4290 // Build the NestedNameSpecifier from what is left of the NamespaceDeclChain
4291 NumSpecifiers = buildNestedNameSpecifier(NamespaceDeclChain, NNS);
4292
4293 // Add an explicit leading '::' specifier if needed.
4294 if (NamespaceDeclChain.empty()) {
34
Taking false branch
4295 // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
4296 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
4297 NumSpecifiers =
4298 buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);
4299 } else if (NamedDecl *ND =
35
Taking false branch
4300 dyn_cast_or_null<NamedDecl>(NamespaceDeclChain.back())) {
4301 IdentifierInfo *Name = ND->getIdentifier();
4302 bool SameNameSpecifier = false;
4303 if (std::find(CurNameSpecifierIdentifiers.begin(),
4304 CurNameSpecifierIdentifiers.end(),
4305 Name) != CurNameSpecifierIdentifiers.end()) {
4306 std::string NewNameSpecifier;
4307 llvm::raw_string_ostream SpecifierOStream(NewNameSpecifier);
4308 SmallVector<const IdentifierInfo *, 4> NewNameSpecifierIdentifiers;
4309 getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
4310 NNS->print(SpecifierOStream, Context.getPrintingPolicy());
4311 SpecifierOStream.flush();
4312 SameNameSpecifier = NewNameSpecifier == CurNameSpecifier;
4313 }
4314 if (SameNameSpecifier ||
4315 std::find(CurContextIdentifiers.begin(), CurContextIdentifiers.end(),
4316 Name) != CurContextIdentifiers.end()) {
4317 // Rebuild the NestedNameSpecifier as a globally-qualified specifier.
4318 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
4319 NumSpecifiers =
4320 buildNestedNameSpecifier(FullNamespaceDeclChain, NNS);
4321 }
4322 }
4323
4324 // If the built NestedNameSpecifier would be replacing an existing
4325 // NestedNameSpecifier, use the number of component identifiers that
4326 // would need to be changed as the edit distance instead of the number
4327 // of components in the built NestedNameSpecifier.
4328 if (NNS && !CurNameSpecifierIdentifiers.empty()) {
36
Assuming 'NNS' is non-null
37
Taking true branch
4329 SmallVector<const IdentifierInfo*, 4> NewNameSpecifierIdentifiers;
4330 getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
4331 NumSpecifiers = llvm::ComputeEditDistance(
38
Calling 'ComputeEditDistance'
4332 llvm::makeArrayRef(CurNameSpecifierIdentifiers),
4333 llvm::makeArrayRef(NewNameSpecifierIdentifiers));
4334 }
4335
4336 SpecifierInfo SI = {Ctx, NNS, NumSpecifiers};
4337 DistanceMap[NumSpecifiers].push_back(SI);
4338}
4339
4340/// \brief Perform name lookup for a possible result for typo correction.
4341static void LookupPotentialTypoResult(Sema &SemaRef,
4342 LookupResult &Res,
4343 IdentifierInfo *Name,
4344 Scope *S, CXXScopeSpec *SS,
4345 DeclContext *MemberContext,
4346 bool EnteringContext,
4347 bool isObjCIvarLookup,
4348 bool FindHidden) {
4349 Res.suppressDiagnostics();
4350 Res.clear();
4351 Res.setLookupName(Name);
4352 Res.setAllowHidden(FindHidden);
4353 if (MemberContext) {
4354 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(MemberContext)) {
4355 if (isObjCIvarLookup) {
4356 if (ObjCIvarDecl *Ivar = Class->lookupInstanceVariable(Name)) {
4357 Res.addDecl(Ivar);
4358 Res.resolveKind();
4359 return;
4360 }
4361 }
4362
4363 if (ObjCPropertyDecl *Prop = Class->FindPropertyDeclaration(
4364 Name, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
4365 Res.addDecl(Prop);
4366 Res.resolveKind();
4367 return;
4368 }
4369 }
4370
4371 SemaRef.LookupQualifiedName(Res, MemberContext);
4372 return;
4373 }
4374
4375 SemaRef.LookupParsedName(Res, S, SS, /*AllowBuiltinCreation=*/false,
4376 EnteringContext);
4377
4378 // Fake ivar lookup; this should really be part of
4379 // LookupParsedName.
4380 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
4381 if (Method->isInstanceMethod() && Method->getClassInterface() &&
4382 (Res.empty() ||
4383 (Res.isSingleResult() &&
4384 Res.getFoundDecl()->isDefinedOutsideFunctionOrMethod()))) {
4385 if (ObjCIvarDecl *IV
4386 = Method->getClassInterface()->lookupInstanceVariable(Name)) {
4387 Res.addDecl(IV);
4388 Res.resolveKind();
4389 }
4390 }
4391 }
4392}
4393
4394/// \brief Add keywords to the consumer as possible typo corrections.
4395static void AddKeywordsToConsumer(Sema &SemaRef,
4396 TypoCorrectionConsumer &Consumer,
4397 Scope *S, CorrectionCandidateCallback &CCC,
4398 bool AfterNestedNameSpecifier) {
4399 if (AfterNestedNameSpecifier) {
4400 // For 'X::', we know exactly which keywords can appear next.
4401 Consumer.addKeywordResult("template");
4402 if (CCC.WantExpressionKeywords)
4403 Consumer.addKeywordResult("operator");
4404 return;
4405 }
4406
4407 if (CCC.WantObjCSuper)
4408 Consumer.addKeywordResult("super");
4409
4410 if (CCC.WantTypeSpecifiers) {
4411 // Add type-specifier keywords to the set of results.
4412 static const char *const CTypeSpecs[] = {
4413 "char", "const", "double", "enum", "float", "int", "long", "short",
4414 "signed", "struct", "union", "unsigned", "void", "volatile",
4415 "_Complex", "_Imaginary",
4416 // storage-specifiers as well
4417 "extern", "inline", "static", "typedef"
4418 };
4419
4420 const unsigned NumCTypeSpecs = llvm::array_lengthof(CTypeSpecs);
4421 for (unsigned I = 0; I != NumCTypeSpecs; ++I)
4422 Consumer.addKeywordResult(CTypeSpecs[I]);
4423
4424 if (SemaRef.getLangOpts().C99)
4425 Consumer.addKeywordResult("restrict");
4426 if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus)
4427 Consumer.addKeywordResult("bool");
4428 else if (SemaRef.getLangOpts().C99)
4429 Consumer.addKeywordResult("_Bool");
4430
4431 if (SemaRef.getLangOpts().CPlusPlus) {
4432 Consumer.addKeywordResult("class");
4433 Consumer.addKeywordResult("typename");
4434 Consumer.addKeywordResult("wchar_t");
4435
4436 if (SemaRef.getLangOpts().CPlusPlus11) {
4437 Consumer.addKeywordResult("char16_t");
4438 Consumer.addKeywordResult("char32_t");
4439 Consumer.addKeywordResult("constexpr");
4440 Consumer.addKeywordResult("decltype");
4441 Consumer.addKeywordResult("thread_local");
4442 }
4443 }
4444
4445 if (SemaRef.getLangOpts().GNUMode)
4446 Consumer.addKeywordResult("typeof");
4447 } else if (CCC.WantFunctionLikeCasts) {
4448 static const char *const CastableTypeSpecs[] = {
4449 "char", "double", "float", "int", "long", "short",
4450 "signed", "unsigned", "void"
4451 };
4452 for (auto *kw : CastableTypeSpecs)
4453 Consumer.addKeywordResult(kw);
4454 }
4455
4456 if (CCC.WantCXXNamedCasts && SemaRef.getLangOpts().CPlusPlus) {
4457 Consumer.addKeywordResult("const_cast");
4458 Consumer.addKeywordResult("dynamic_cast");
4459 Consumer.addKeywordResult("reinterpret_cast");
4460 Consumer.addKeywordResult("static_cast");
4461 }
4462
4463 if (CCC.WantExpressionKeywords) {
4464 Consumer.addKeywordResult("sizeof");
4465 if (SemaRef.getLangOpts().Bool || SemaRef.getLangOpts().CPlusPlus) {
4466 Consumer.addKeywordResult("false");
4467 Consumer.addKeywordResult("true");
4468 }
4469
4470 if (SemaRef.getLangOpts().CPlusPlus) {
4471 static const char *const CXXExprs[] = {
4472 "delete", "new", "operator", "throw", "typeid"
4473 };
4474 const unsigned NumCXXExprs = llvm::array_lengthof(CXXExprs);
4475 for (unsigned I = 0; I != NumCXXExprs; ++I)
4476 Consumer.addKeywordResult(CXXExprs[I]);
4477
4478 if (isa<CXXMethodDecl>(SemaRef.CurContext) &&
4479 cast<CXXMethodDecl>(SemaRef.CurContext)->isInstance())
4480 Consumer.addKeywordResult("this");
4481
4482 if (SemaRef.getLangOpts().CPlusPlus11) {
4483 Consumer.addKeywordResult("alignof");
4484 Consumer.addKeywordResult("nullptr");
4485 }
4486 }
4487
4488 if (SemaRef.getLangOpts().C11) {
4489 // FIXME: We should not suggest _Alignof if the alignof macro
4490 // is present.
4491 Consumer.addKeywordResult("_Alignof");
4492 }
4493 }
4494
4495 if (CCC.WantRemainingKeywords) {
4496 if (SemaRef.getCurFunctionOrMethodDecl() || SemaRef.getCurBlock()) {
4497 // Statements.
4498 static const char *const CStmts[] = {
4499 "do", "else", "for", "goto", "if", "return", "switch", "while" };
4500 const unsigned NumCStmts = llvm::array_lengthof(CStmts);
4501 for (unsigned I = 0; I != NumCStmts; ++I)
4502 Consumer.addKeywordResult(CStmts[I]);
4503
4504 if (SemaRef.getLangOpts().CPlusPlus) {
4505 Consumer.addKeywordResult("catch");
4506 Consumer.addKeywordResult("try");
4507 }
4508
4509 if (S && S->getBreakParent())
4510 Consumer.addKeywordResult("break");
4511
4512 if (S && S->getContinueParent())
4513 Consumer.addKeywordResult("continue");
4514
4515 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
4516 Consumer.addKeywordResult("case");
4517 Consumer.addKeywordResult("default");
4518 }
4519 } else {
4520 if (SemaRef.getLangOpts().CPlusPlus) {
4521 Consumer.addKeywordResult("namespace");
4522 Consumer.addKeywordResult("template");
4523 }
4524
4525 if (S && S->isClassScope()) {
4526 Consumer.addKeywordResult("explicit");
4527 Consumer.addKeywordResult("friend");
4528 Consumer.addKeywordResult("mutable");
4529 Consumer.addKeywordResult("private");
4530 Consumer.addKeywordResult("protected");
4531 Consumer.addKeywordResult("public");
4532 Consumer.addKeywordResult("virtual");
4533 }
4534 }
4535
4536 if (SemaRef.getLangOpts().CPlusPlus) {
4537 Consumer.addKeywordResult("using");
4538
4539 if (SemaRef.getLangOpts().CPlusPlus11)
4540 Consumer.addKeywordResult("static_assert");
4541 }
4542 }
4543}
4544
4545std::unique_ptr<TypoCorrectionConsumer> Sema::makeTypoCorrectionConsumer(
4546 const DeclarationNameInfo &TypoName, Sema::LookupNameKind LookupKind,
4547 Scope *S, CXXScopeSpec *SS,
4548 std::unique_ptr<CorrectionCandidateCallback> CCC,
4549 DeclContext *MemberContext, bool EnteringContext,
4550 const ObjCObjectPointerType *OPT, bool ErrorRecovery) {
4551
4552 if (Diags.hasFatalErrorOccurred() || !getLangOpts().SpellChecking ||
4553 DisableTypoCorrection)
4554 return nullptr;
4555
4556 // In Microsoft mode, don't perform typo correction in a template member
4557 // function dependent context because it interferes with the "lookup into
4558 // dependent bases of class templates" feature.
4559 if (getLangOpts().MSVCCompat && CurContext->isDependentContext() &&
4560 isa<CXXMethodDecl>(CurContext))
4561 return nullptr;
4562
4563 // We only attempt to correct typos for identifiers.
4564 IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
4565 if (!Typo)
4566 return nullptr;
4567
4568 // If the scope specifier itself was invalid, don't try to correct
4569 // typos.
4570 if (SS && SS->isInvalid())
4571 return nullptr;
4572
4573 // Never try to correct typos during any kind of code synthesis.
4574 if (!CodeSynthesisContexts.empty())
4575 return nullptr;
4576
4577 // Don't try to correct 'super'.
4578 if (S && S->isInObjcMethodScope() && Typo == getSuperIdentifier())
4579 return nullptr;
4580
4581 // Abort if typo correction already failed for this specific typo.
4582 IdentifierSourceLocations::iterator locs = TypoCorrectionFailures.find(Typo);
4583 if (locs != TypoCorrectionFailures.end() &&
4584 locs->second.count(TypoName.getLoc()))
4585 return nullptr;
4586
4587 // Don't try to correct the identifier "vector" when in AltiVec mode.
4588 // TODO: Figure out why typo correction misbehaves in this case, fix it, and
4589 // remove this workaround.
4590 if ((getLangOpts().AltiVec || getLangOpts().ZVector) && Typo->isStr("vector"))
4591 return nullptr;
4592
4593 // Provide a stop gap for files that are just seriously broken. Trying
4594 // to correct all typos can turn into a HUGE performance penalty, causing
4595 // some files to take minutes to get rejected by the parser.
4596 unsigned Limit = getDiagnostics().getDiagnosticOptions().SpellCheckingLimit;
4597 if (Limit && TyposCorrected >= Limit)
4598 return nullptr;
4599 ++TyposCorrected;
4600
4601 // If we're handling a missing symbol error, using modules, and the
4602 // special search all modules option is used, look for a missing import.
4603 if (ErrorRecovery && getLangOpts().Modules &&
4604 getLangOpts().ModulesSearchAll) {
4605 // The following has the side effect of loading the missing module.
4606 getModuleLoader().lookupMissingImports(Typo->getName(),
4607 TypoName.getLocStart());
4608 }
4609
4610 CorrectionCandidateCallback &CCCRef = *CCC;
4611 auto Consumer = llvm::make_unique<TypoCorrectionConsumer>(
4612 *this, TypoName, LookupKind, S, SS, std::move(CCC), MemberContext,
4613 EnteringContext);
4614
4615 // Perform name lookup to find visible, similarly-named entities.
4616 bool IsUnqualifiedLookup = false;
4617 DeclContext *QualifiedDC = MemberContext;
4618 if (MemberContext) {
4619 LookupVisibleDecls(MemberContext, LookupKind, *Consumer);
4620
4621 // Look in qualified interfaces.
4622 if (OPT) {
4623 for (auto *I : OPT->quals())
4624 LookupVisibleDecls(I, LookupKind, *Consumer);
4625 }
4626 } else if (SS && SS->isSet()) {
4627 QualifiedDC = computeDeclContext(*SS, EnteringContext);
4628 if (!QualifiedDC)
4629 return nullptr;
4630
4631 LookupVisibleDecls(QualifiedDC, LookupKind, *Consumer);
4632 } else {
4633 IsUnqualifiedLookup = true;
4634 }
4635
4636 // Determine whether we are going to search in the various namespaces for
4637 // corrections.
4638 bool SearchNamespaces
4639 = getLangOpts().CPlusPlus &&
4640 (IsUnqualifiedLookup || (SS && SS->isSet()));
4641
4642 if (IsUnqualifiedLookup || SearchNamespaces) {
4643 // For unqualified lookup, look through all of the names that we have
4644 // seen in this translation unit.
4645 // FIXME: Re-add the ability to skip very unlikely potential corrections.
4646 for (const auto &I : Context.Idents)
4647 Consumer->FoundName(I.getKey());
4648
4649 // Walk through identifiers in external identifier sources.
4650 // FIXME: Re-add the ability to skip very unlikely potential corrections.
4651 if (IdentifierInfoLookup *External
4652 = Context.Idents.getExternalIdentifierLookup()) {
4653 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
4654 do {
4655 StringRef Name = Iter->Next();
4656 if (Name.empty())
4657 break;
4658
4659 Consumer->FoundName(Name);
4660 } while (true);
4661 }
4662 }
4663
4664 AddKeywordsToConsumer(*this, *Consumer, S, CCCRef, SS && SS->isNotEmpty());
4665
4666 // Build the NestedNameSpecifiers for the KnownNamespaces, if we're going
4667 // to search those namespaces.
4668 if (SearchNamespaces) {
4669 // Load any externally-known namespaces.
4670 if (ExternalSource && !LoadedExternalKnownNamespaces) {
4671 SmallVector<NamespaceDecl *, 4> ExternalKnownNamespaces;
4672 LoadedExternalKnownNamespaces = true;
4673 ExternalSource->ReadKnownNamespaces(ExternalKnownNamespaces);
4674 for (auto *N : ExternalKnownNamespaces)
4675 KnownNamespaces[N] = true;
4676 }
4677
4678 Consumer->addNamespaces(KnownNamespaces);
4679 }
4680
4681 return Consumer;
4682}
4683
4684/// \brief Try to "correct" a typo in the source code by finding
4685/// visible declarations whose names are similar to the name that was
4686/// present in the source code.
4687///
4688/// \param TypoName the \c DeclarationNameInfo structure that contains
4689/// the name that was present in the source code along with its location.
4690///
4691/// \param LookupKind the name-lookup criteria used to search for the name.
4692///
4693/// \param S the scope in which name lookup occurs.
4694///
4695/// \param SS the nested-name-specifier that precedes the name we're
4696/// looking for, if present.
4697///
4698/// \param CCC A CorrectionCandidateCallback object that provides further
4699/// validation of typo correction candidates. It also provides flags for
4700/// determining the set of keywords permitted.
4701///
4702/// \param MemberContext if non-NULL, the context in which to look for
4703/// a member access expression.
4704///
4705/// \param EnteringContext whether we're entering the context described by
4706/// the nested-name-specifier SS.
4707///
4708/// \param OPT when non-NULL, the search for visible declarations will
4709/// also walk the protocols in the qualified interfaces of \p OPT.
4710///
4711/// \returns a \c TypoCorrection containing the corrected name if the typo
4712/// along with information such as the \c NamedDecl where the corrected name
4713/// was declared, and any additional \c NestedNameSpecifier needed to access
4714/// it (C++ only). The \c TypoCorrection is empty if there is no correction.
4715TypoCorrection Sema::CorrectTypo(const DeclarationNameInfo &TypoName,
4716 Sema::LookupNameKind LookupKind,
4717 Scope *S, CXXScopeSpec *SS,
4718 std::unique_ptr<CorrectionCandidateCallback> CCC,
4719 CorrectTypoKind Mode,
4720 DeclContext *MemberContext,
4721 bool EnteringContext,
4722 const ObjCObjectPointerType *OPT,
4723 bool RecordFailure) {
4724 assert(CCC && "CorrectTypo requires a CorrectionCandidateCallback")(static_cast <bool> (CCC && "CorrectTypo requires a CorrectionCandidateCallback"
) ? void (0) : __assert_fail ("CCC && \"CorrectTypo requires a CorrectionCandidateCallback\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 4724, __extension__ __PRETTY_FUNCTION__))
;
4725
4726 // Always let the ExternalSource have the first chance at correction, even
4727 // if we would otherwise have given up.
4728 if (ExternalSource) {
4729 if (TypoCorrection Correction = ExternalSource->CorrectTypo(
4730 TypoName, LookupKind, S, SS, *CCC, MemberContext, EnteringContext, OPT))
4731 return Correction;
4732 }
4733
4734 // Ugly hack equivalent to CTC == CTC_ObjCMessageReceiver;
4735 // WantObjCSuper is only true for CTC_ObjCMessageReceiver and for
4736 // some instances of CTC_Unknown, while WantRemainingKeywords is true
4737 // for CTC_Unknown but not for CTC_ObjCMessageReceiver.
4738 bool ObjCMessageReceiver = CCC->WantObjCSuper && !CCC->WantRemainingKeywords;
4739
4740 IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
4741 auto Consumer = makeTypoCorrectionConsumer(
4742 TypoName, LookupKind, S, SS, std::move(CCC), MemberContext,
4743 EnteringContext, OPT, Mode == CTK_ErrorRecovery);
4744
4745 if (!Consumer)
4746 return TypoCorrection();
4747
4748 // If we haven't found anything, we're done.
4749 if (Consumer->empty())
4750 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4751
4752 // Make sure the best edit distance (prior to adding any namespace qualifiers)
4753 // is not more that about a third of the length of the typo's identifier.
4754 unsigned ED = Consumer->getBestEditDistance(true);
4755 unsigned TypoLen = Typo->getName().size();
4756 if (ED > 0 && TypoLen / ED < 3)
4757 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4758
4759 TypoCorrection BestTC = Consumer->getNextCorrection();
4760 TypoCorrection SecondBestTC = Consumer->getNextCorrection();
4761 if (!BestTC)
4762 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4763
4764 ED = BestTC.getEditDistance();
4765
4766 if (TypoLen >= 3 && ED > 0 && TypoLen / ED < 3) {
4767 // If this was an unqualified lookup and we believe the callback
4768 // object wouldn't have filtered out possible corrections, note
4769 // that no correction was found.
4770 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4771 }
4772
4773 // If only a single name remains, return that result.
4774 if (!SecondBestTC ||
4775 SecondBestTC.getEditDistance(false) > BestTC.getEditDistance(false)) {
4776 const TypoCorrection &Result = BestTC;
4777
4778 // Don't correct to a keyword that's the same as the typo; the keyword
4779 // wasn't actually in scope.
4780 if (ED == 0 && Result.isKeyword())
4781 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4782
4783 TypoCorrection TC = Result;
4784 TC.setCorrectionRange(SS, TypoName);
4785 checkCorrectionVisibility(*this, TC);
4786 return TC;
4787 } else if (SecondBestTC && ObjCMessageReceiver) {
4788 // Prefer 'super' when we're completing in a message-receiver
4789 // context.
4790
4791 if (BestTC.getCorrection().getAsString() != "super") {
4792 if (SecondBestTC.getCorrection().getAsString() == "super")
4793 BestTC = SecondBestTC;
4794 else if ((*Consumer)["super"].front().isKeyword())
4795 BestTC = (*Consumer)["super"].front();
4796 }
4797 // Don't correct to a keyword that's the same as the typo; the keyword
4798 // wasn't actually in scope.
4799 if (BestTC.getEditDistance() == 0 ||
4800 BestTC.getCorrection().getAsString() != "super")
4801 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure);
4802
4803 BestTC.setCorrectionRange(SS, TypoName);
4804 return BestTC;
4805 }
4806
4807 // Record the failure's location if needed and return an empty correction. If
4808 // this was an unqualified lookup and we believe the callback object did not
4809 // filter out possible corrections, also cache the failure for the typo.
4810 return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure && !SecondBestTC);
4811}
4812
4813/// \brief Try to "correct" a typo in the source code by finding
4814/// visible declarations whose names are similar to the name that was
4815/// present in the source code.
4816///
4817/// \param TypoName the \c DeclarationNameInfo structure that contains
4818/// the name that was present in the source code along with its location.
4819///
4820/// \param LookupKind the name-lookup criteria used to search for the name.
4821///
4822/// \param S the scope in which name lookup occurs.
4823///
4824/// \param SS the nested-name-specifier that precedes the name we're
4825/// looking for, if present.
4826///
4827/// \param CCC A CorrectionCandidateCallback object that provides further
4828/// validation of typo correction candidates. It also provides flags for
4829/// determining the set of keywords permitted.
4830///
4831/// \param TDG A TypoDiagnosticGenerator functor that will be used to print
4832/// diagnostics when the actual typo correction is attempted.
4833///
4834/// \param TRC A TypoRecoveryCallback functor that will be used to build an
4835/// Expr from a typo correction candidate.
4836///
4837/// \param MemberContext if non-NULL, the context in which to look for
4838/// a member access expression.
4839///
4840/// \param EnteringContext whether we're entering the context described by
4841/// the nested-name-specifier SS.
4842///
4843/// \param OPT when non-NULL, the search for visible declarations will
4844/// also walk the protocols in the qualified interfaces of \p OPT.
4845///
4846/// \returns a new \c TypoExpr that will later be replaced in the AST with an
4847/// Expr representing the result of performing typo correction, or nullptr if
4848/// typo correction is not possible. If nullptr is returned, no diagnostics will
4849/// be emitted and it is the responsibility of the caller to emit any that are
4850/// needed.
4851TypoExpr *Sema::CorrectTypoDelayed(
4852 const DeclarationNameInfo &TypoName, Sema::LookupNameKind LookupKind,
4853 Scope *S, CXXScopeSpec *SS,
4854 std::unique_ptr<CorrectionCandidateCallback> CCC,
4855 TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode,
4856 DeclContext *MemberContext, bool EnteringContext,
4857 const ObjCObjectPointerType *OPT) {
4858 assert(CCC && "CorrectTypoDelayed requires a CorrectionCandidateCallback")(static_cast <bool> (CCC && "CorrectTypoDelayed requires a CorrectionCandidateCallback"
) ? void (0) : __assert_fail ("CCC && \"CorrectTypoDelayed requires a CorrectionCandidateCallback\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 4858, __extension__ __PRETTY_FUNCTION__))
;
4859
4860 auto Consumer = makeTypoCorrectionConsumer(
4861 TypoName, LookupKind, S, SS, std::move(CCC), MemberContext,
4862 EnteringContext, OPT, Mode == CTK_ErrorRecovery);
4863
4864 // Give the external sema source a chance to correct the typo.
4865 TypoCorrection ExternalTypo;
4866 if (ExternalSource && Consumer) {
4867 ExternalTypo = ExternalSource->CorrectTypo(
4868 TypoName, LookupKind, S, SS, *Consumer->getCorrectionValidator(),
4869 MemberContext, EnteringContext, OPT);
4870 if (ExternalTypo)
4871 Consumer->addCorrection(ExternalTypo);
4872 }
4873
4874 if (!Consumer || Consumer->empty())
4875 return nullptr;
4876
4877 // Make sure the best edit distance (prior to adding any namespace qualifiers)
4878 // is not more that about a third of the length of the typo's identifier.
4879 unsigned ED = Consumer->getBestEditDistance(true);
4880 IdentifierInfo *Typo = TypoName.getName().getAsIdentifierInfo();
4881 if (!ExternalTypo && ED > 0 && Typo->getName().size() / ED < 3)
4882 return nullptr;
4883
4884 ExprEvalContexts.back().NumTypos++;
4885 return createDelayedTypo(std::move(Consumer), std::move(TDG), std::move(TRC));
4886}
4887
4888void TypoCorrection::addCorrectionDecl(NamedDecl *CDecl) {
4889 if (!CDecl) return;
4890
4891 if (isKeyword())
4892 CorrectionDecls.clear();
4893
4894 CorrectionDecls.push_back(CDecl);
4895
4896 if (!CorrectionName)
4897 CorrectionName = CDecl->getDeclName();
4898}
4899
4900std::string TypoCorrection::getAsString(const LangOptions &LO) const {
4901 if (CorrectionNameSpec) {
4902 std::string tmpBuffer;
4903 llvm::raw_string_ostream PrefixOStream(tmpBuffer);
4904 CorrectionNameSpec->print(PrefixOStream, PrintingPolicy(LO));
4905 PrefixOStream << CorrectionName;
4906 return PrefixOStream.str();
4907 }
4908
4909 return CorrectionName.getAsString();
4910}
4911
4912bool CorrectionCandidateCallback::ValidateCandidate(
4913 const TypoCorrection &candidate) {
4914 if (!candidate.isResolved())
4915 return true;
4916
4917 if (candidate.isKeyword())
4918 return WantTypeSpecifiers || WantExpressionKeywords || WantCXXNamedCasts ||
4919 WantRemainingKeywords || WantObjCSuper;
4920
4921 bool HasNonType = false;
4922 bool HasStaticMethod = false;
4923 bool HasNonStaticMethod = false;
4924 for (Decl *D : candidate) {
4925 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
4926 D = FTD->getTemplatedDecl();
4927 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
4928 if (Method->isStatic())
4929 HasStaticMethod = true;
4930 else
4931 HasNonStaticMethod = true;
4932 }
4933 if (!isa<TypeDecl>(D))
4934 HasNonType = true;
4935 }
4936
4937 if (IsAddressOfOperand && HasNonStaticMethod && !HasStaticMethod &&
4938 !candidate.getCorrectionSpecifier())
4939 return false;
4940
4941 return WantTypeSpecifiers || HasNonType;
4942}
4943
4944FunctionCallFilterCCC::FunctionCallFilterCCC(Sema &SemaRef, unsigned NumArgs,
4945 bool HasExplicitTemplateArgs,
4946 MemberExpr *ME)
4947 : NumArgs(NumArgs), HasExplicitTemplateArgs(HasExplicitTemplateArgs),
4948 CurContext(SemaRef.CurContext), MemberFn(ME) {
4949 WantTypeSpecifiers = false;
4950 WantFunctionLikeCasts = SemaRef.getLangOpts().CPlusPlus && NumArgs == 1;
4951 WantRemainingKeywords = false;
4952}
4953
4954bool FunctionCallFilterCCC::ValidateCandidate(const TypoCorrection &candidate) {
4955 if (!candidate.getCorrectionDecl())
4956 return candidate.isKeyword();
4957
4958 for (auto *C : candidate) {
4959 FunctionDecl *FD = nullptr;
4960 NamedDecl *ND = C->getUnderlyingDecl();
4961 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
4962 FD = FTD->getTemplatedDecl();
4963 if (!HasExplicitTemplateArgs && !FD) {
4964 if (!(FD = dyn_cast<FunctionDecl>(ND)) && isa<ValueDecl>(ND)) {
4965 // If the Decl is neither a function nor a template function,
4966 // determine if it is a pointer or reference to a function. If so,
4967 // check against the number of arguments expected for the pointee.
4968 QualType ValType = cast<ValueDecl>(ND)->getType();
4969 if (ValType->isAnyPointerType() || ValType->isReferenceType())
4970 ValType = ValType->getPointeeType();
4971 if (const FunctionProtoType *FPT = ValType->getAs<FunctionProtoType>())
4972 if (FPT->getNumParams() == NumArgs)
4973 return true;
4974 }
4975 }
4976
4977 // Skip the current candidate if it is not a FunctionDecl or does not accept
4978 // the current number of arguments.
4979 if (!FD || !(FD->getNumParams() >= NumArgs &&
4980 FD->getMinRequiredArguments() <= NumArgs))
4981 continue;
4982
4983 // If the current candidate is a non-static C++ method, skip the candidate
4984 // unless the method being corrected--or the current DeclContext, if the
4985 // function being corrected is not a method--is a method in the same class
4986 // or a descendent class of the candidate's parent class.
4987 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
4988 if (MemberFn || !MD->isStatic()) {
4989 CXXMethodDecl *CurMD =
4990 MemberFn
4991 ? dyn_cast_or_null<CXXMethodDecl>(MemberFn->getMemberDecl())
4992 : dyn_cast_or_null<CXXMethodDecl>(CurContext);
4993 CXXRecordDecl *CurRD =
4994 CurMD ? CurMD->getParent()->getCanonicalDecl() : nullptr;
4995 CXXRecordDecl *RD = MD->getParent()->getCanonicalDecl();
4996 if (!CurRD || (CurRD != RD && !CurRD->isDerivedFrom(RD)))
4997 continue;
4998 }
4999 }
5000 return true;
5001 }
5002 return false;
5003}
5004
5005void Sema::diagnoseTypo(const TypoCorrection &Correction,
5006 const PartialDiagnostic &TypoDiag,
5007 bool ErrorRecovery) {
5008 diagnoseTypo(Correction, TypoDiag, PDiag(diag::note_previous_decl),
5009 ErrorRecovery);
5010}
5011
5012/// Find which declaration we should import to provide the definition of
5013/// the given declaration.
5014static NamedDecl *getDefinitionToImport(NamedDecl *D) {
5015 if (VarDecl *VD = dyn_cast<VarDecl>(D))
5016 return VD->getDefinition();
5017 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
5018 return FD->getDefinition();
5019 if (TagDecl *TD = dyn_cast<TagDecl>(D))
5020 return TD->getDefinition();
5021 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
5022 return ID->getDefinition();
5023 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D))
5024 return PD->getDefinition();
5025 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
5026 return getDefinitionToImport(TD->getTemplatedDecl());
5027 return nullptr;
5028}
5029
5030void Sema::diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
5031 MissingImportKind MIK, bool Recover) {
5032 // Suggest importing a module providing the definition of this entity, if
5033 // possible.
5034 NamedDecl *Def = getDefinitionToImport(Decl);
5035 if (!Def)
5036 Def = Decl;
5037
5038 Module *Owner = getOwningModule(Decl);
5039 assert(Owner && "definition of hidden declaration is not in a module")(static_cast <bool> (Owner && "definition of hidden declaration is not in a module"
) ? void (0) : __assert_fail ("Owner && \"definition of hidden declaration is not in a module\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 5039, __extension__ __PRETTY_FUNCTION__))
;
5040
5041 llvm::SmallVector<Module*, 8> OwningModules;
5042 OwningModules.push_back(Owner);
5043 auto Merged = Context.getModulesWithMergedDefinition(Decl);
5044 OwningModules.insert(OwningModules.end(), Merged.begin(), Merged.end());
5045
5046 diagnoseMissingImport(Loc, Decl, Decl->getLocation(), OwningModules, MIK,
5047 Recover);
5048}
5049
5050/// \brief Get a "quoted.h" or <angled.h> include path to use in a diagnostic
5051/// suggesting the addition of a #include of the specified file.
5052static std::string getIncludeStringForHeader(Preprocessor &PP,
5053 const FileEntry *E) {
5054 bool IsSystem;
5055 auto Path =
5056 PP.getHeaderSearchInfo().suggestPathToFileForDiagnostics(E, &IsSystem);
5057 return (IsSystem ? '<' : '"') + Path + (IsSystem ? '>' : '"');
5058}
5059
5060void Sema::diagnoseMissingImport(SourceLocation UseLoc, NamedDecl *Decl,
5061 SourceLocation DeclLoc,
5062 ArrayRef<Module *> Modules,
5063 MissingImportKind MIK, bool Recover) {
5064 assert(!Modules.empty())(static_cast <bool> (!Modules.empty()) ? void (0) : __assert_fail
("!Modules.empty()", "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 5064, __extension__ __PRETTY_FUNCTION__))
;
5065
5066 // Weed out duplicates from module list.
5067 llvm::SmallVector<Module*, 8> UniqueModules;
5068 llvm::SmallDenseSet<Module*, 8> UniqueModuleSet;
5069 for (auto *M : Modules)
5070 if (UniqueModuleSet.insert(M).second)
5071 UniqueModules.push_back(M);
5072 Modules = UniqueModules;
5073
5074 if (Modules.size() > 1) {
5075 std::string ModuleList;
5076 unsigned N = 0;
5077 for (Module *M : Modules) {
5078 ModuleList += "\n ";
5079 if (++N == 5 && N != Modules.size()) {
5080 ModuleList += "[...]";
5081 break;
5082 }
5083 ModuleList += M->getFullModuleName();
5084 }
5085
5086 Diag(UseLoc, diag::err_module_unimported_use_multiple)
5087 << (int)MIK << Decl << ModuleList;
5088 } else if (const FileEntry *E = PP.getModuleHeaderToIncludeForDiagnostics(
5089 UseLoc, Modules[0], DeclLoc)) {
5090 // The right way to make the declaration visible is to include a header;
5091 // suggest doing so.
5092 //
5093 // FIXME: Find a smart place to suggest inserting a #include, and add
5094 // a FixItHint there.
5095 Diag(UseLoc, diag::err_module_unimported_use_header)
5096 << (int)MIK << Decl << Modules[0]->getFullModuleName()
5097 << getIncludeStringForHeader(PP, E);
5098 } else {
5099 // FIXME: Add a FixItHint that imports the corresponding module.
5100 Diag(UseLoc, diag::err_module_unimported_use)
5101 << (int)MIK << Decl << Modules[0]->getFullModuleName();
5102 }
5103
5104 unsigned DiagID;
5105 switch (MIK) {
5106 case MissingImportKind::Declaration:
5107 DiagID = diag::note_previous_declaration;
5108 break;
5109 case MissingImportKind::Definition:
5110 DiagID = diag::note_previous_definition;
5111 break;
5112 case MissingImportKind::DefaultArgument:
5113 DiagID = diag::note_default_argument_declared_here;
5114 break;
5115 case MissingImportKind::ExplicitSpecialization:
5116 DiagID = diag::note_explicit_specialization_declared_here;
5117 break;
5118 case MissingImportKind::PartialSpecialization:
5119 DiagID = diag::note_partial_specialization_declared_here;
5120 break;
5121 }
5122 Diag(DeclLoc, DiagID);
5123
5124 // Try to recover by implicitly importing this module.
5125 if (Recover)
5126 createImplicitModuleImportForErrorRecovery(UseLoc, Modules[0]);
5127}
5128
5129/// \brief Diagnose a successfully-corrected typo. Separated from the correction
5130/// itself to allow external validation of the result, etc.
5131///
5132/// \param Correction The result of performing typo correction.
5133/// \param TypoDiag The diagnostic to produce. This will have the corrected
5134/// string added to it (and usually also a fixit).
5135/// \param PrevNote A note to use when indicating the location of the entity to
5136/// which we are correcting. Will have the correction string added to it.
5137/// \param ErrorRecovery If \c true (the default), the caller is going to
5138/// recover from the typo as if the corrected string had been typed.
5139/// In this case, \c PDiag must be an error, and we will attach a fixit
5140/// to it.
5141void Sema::diagnoseTypo(const TypoCorrection &Correction,
5142 const PartialDiagnostic &TypoDiag,
5143 const PartialDiagnostic &PrevNote,
5144 bool ErrorRecovery) {
5145 std::string CorrectedStr = Correction.getAsString(getLangOpts());
5146 std::string CorrectedQuotedStr = Correction.getQuoted(getLangOpts());
5147 FixItHint FixTypo = FixItHint::CreateReplacement(
5148 Correction.getCorrectionRange(), CorrectedStr);
5149
5150 // Maybe we're just missing a module import.
5151 if (Correction.requiresImport()) {
5152 NamedDecl *Decl = Correction.getFoundDecl();
5153 assert(Decl && "import required but no declaration to import")(static_cast <bool> (Decl && "import required but no declaration to import"
) ? void (0) : __assert_fail ("Decl && \"import required but no declaration to import\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 5153, __extension__ __PRETTY_FUNCTION__))
;
5154
5155 diagnoseMissingImport(Correction.getCorrectionRange().getBegin(), Decl,
5156 MissingImportKind::Declaration, ErrorRecovery);
5157 return;
5158 }
5159
5160 Diag(Correction.getCorrectionRange().getBegin(), TypoDiag)
5161 << CorrectedQuotedStr << (ErrorRecovery ? FixTypo : FixItHint());
5162
5163 NamedDecl *ChosenDecl =
5164 Correction.isKeyword() ? nullptr : Correction.getFoundDecl();
5165 if (PrevNote.getDiagID() && ChosenDecl)
5166 Diag(ChosenDecl->getLocation(), PrevNote)
5167 << CorrectedQuotedStr << (ErrorRecovery ? FixItHint() : FixTypo);
5168
5169 // Add any extra diagnostics.
5170 for (const PartialDiagnostic &PD : Correction.getExtraDiagnostics())
5171 Diag(Correction.getCorrectionRange().getBegin(), PD);
5172}
5173
5174TypoExpr *Sema::createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
5175 TypoDiagnosticGenerator TDG,
5176 TypoRecoveryCallback TRC) {
5177 assert(TCC && "createDelayedTypo requires a valid TypoCorrectionConsumer")(static_cast <bool> (TCC && "createDelayedTypo requires a valid TypoCorrectionConsumer"
) ? void (0) : __assert_fail ("TCC && \"createDelayedTypo requires a valid TypoCorrectionConsumer\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 5177, __extension__ __PRETTY_FUNCTION__))
;
5178 auto TE = new (Context) TypoExpr(Context.DependentTy);
5179 auto &State = DelayedTypos[TE];
5180 State.Consumer = std::move(TCC);
5181 State.DiagHandler = std::move(TDG);
5182 State.RecoveryHandler = std::move(TRC);
5183 return TE;
5184}
5185
5186const Sema::TypoExprState &Sema::getTypoExprState(TypoExpr *TE) const {
5187 auto Entry = DelayedTypos.find(TE);
5188 assert(Entry != DelayedTypos.end() &&(static_cast <bool> (Entry != DelayedTypos.end() &&
"Failed to get the state for a TypoExpr!") ? void (0) : __assert_fail
("Entry != DelayedTypos.end() && \"Failed to get the state for a TypoExpr!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 5189, __extension__ __PRETTY_FUNCTION__))
5189 "Failed to get the state for a TypoExpr!")(static_cast <bool> (Entry != DelayedTypos.end() &&
"Failed to get the state for a TypoExpr!") ? void (0) : __assert_fail
("Entry != DelayedTypos.end() && \"Failed to get the state for a TypoExpr!\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/tools/clang/lib/Sema/SemaLookup.cpp"
, 5189, __extension__ __PRETTY_FUNCTION__))
;
5190 return Entry->second;
5191}
5192
5193void Sema::clearDelayedTypo(TypoExpr *TE) {
5194 DelayedTypos.erase(TE);
5195}
5196
5197void Sema::ActOnPragmaDump(Scope *S, SourceLocation IILoc, IdentifierInfo *II) {
5198 DeclarationNameInfo Name(II, IILoc);
5199 LookupResult R(*this, Name, LookupAnyName, Sema::NotForRedeclaration);
5200 R.suppressDiagnostics();
5201 R.setHideTags(false);
5202 LookupName(R, S);
5203 R.dump();
5204}

/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/edit_distance.h

1//===-- llvm/ADT/edit_distance.h - Array edit distance function --- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines a Levenshtein distance function that works for any two
11// sequences, with each element of each sequence being analogous to a character
12// in a string.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_ADT_EDIT_DISTANCE_H
17#define LLVM_ADT_EDIT_DISTANCE_H
18
19#include "llvm/ADT/ArrayRef.h"
20#include <algorithm>
21#include <memory>
22
23namespace llvm {
24
25/// \brief Determine the edit distance between two sequences.
26///
27/// \param FromArray the first sequence to compare.
28///
29/// \param ToArray the second sequence to compare.
30///
31/// \param AllowReplacements whether to allow element replacements (change one
32/// element into another) as a single operation, rather than as two operations
33/// (an insertion and a removal).
34///
35/// \param MaxEditDistance If non-zero, the maximum edit distance that this
36/// routine is allowed to compute. If the edit distance will exceed that
37/// maximum, returns \c MaxEditDistance+1.
38///
39/// \returns the minimum number of element insertions, removals, or (if
40/// \p AllowReplacements is \c true) replacements needed to transform one of
41/// the given sequences into the other. If zero, the sequences are identical.
42template<typename T>
43unsigned ComputeEditDistance(ArrayRef<T> FromArray, ArrayRef<T> ToArray,
44 bool AllowReplacements = true,
45 unsigned MaxEditDistance = 0) {
46 // The algorithm implemented below is the "classic"
47 // dynamic-programming algorithm for computing the Levenshtein
48 // distance, which is described here:
49 //
50 // http://en.wikipedia.org/wiki/Levenshtein_distance
51 //
52 // Although the algorithm is typically described using an m x n
53 // array, only one row plus one element are used at a time, so this
54 // implementation just keeps one vector for the row. To update one entry,
55 // only the entries to the left, top, and top-left are needed. The left
56 // entry is in Row[x-1], the top entry is what's in Row[x] from the last
57 // iteration, and the top-left entry is stored in Previous.
58 typename ArrayRef<T>::size_type m = FromArray.size();
59 typename ArrayRef<T>::size_type n = ToArray.size();
60
61 const unsigned SmallBufferSize = 64;
62 unsigned SmallBuffer[SmallBufferSize];
63 std::unique_ptr<unsigned[]> Allocated;
64 unsigned *Row = SmallBuffer;
65 if (n + 1 > SmallBufferSize) {
39
Assuming the condition is false
40
Taking false branch
66 Row = new unsigned[n + 1];
67 Allocated.reset(Row);
68 }
69
70 for (unsigned i = 1; i <= n; ++i)
41
Assuming 'i' is > 'n'
42
Loop condition is false. Execution continues on line 73
71 Row[i] = i;
72
73 for (typename ArrayRef<T>::size_type y = 1; y <= m; ++y) {
43
Assuming 'y' is > 'm'
44
Loop condition is false. Execution continues on line 97
74 Row[0] = y;
75 unsigned BestThisRow = Row[0];
76
77 unsigned Previous = y - 1;
78 for (typename ArrayRef<T>::size_type x = 1; x <= n; ++x) {
79 int OldRow = Row[x];
80 if (AllowReplacements) {
81 Row[x] = std::min(
82 Previous + (FromArray[y-1] == ToArray[x-1] ? 0u : 1u),
83 std::min(Row[x-1], Row[x])+1);
84 }
85 else {
86 if (FromArray[y-1] == ToArray[x-1]) Row[x] = Previous;
87 else Row[x] = std::min(Row[x-1], Row[x]) + 1;
88 }
89 Previous = OldRow;
90 BestThisRow = std::min(BestThisRow, Row[x]);
91 }
92
93 if (MaxEditDistance && BestThisRow > MaxEditDistance)
94 return MaxEditDistance + 1;
95 }
96
97 unsigned Result = Row[n];
45
Assigned value is garbage or undefined
98 return Result;
99}
100
101} // End llvm namespace
102
103#endif