Bug Summary

File:tools/clang/lib/Sema/SemaLookup.cpp
Warning:line 3897, column 37
Called C++ object pointer is null

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())
81
Called C++ object pointer is null
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)) {
36
Calling 'reverse'
43
Returning from 'reverse'
44
Calling 'operator!='
48
Returning from 'operator!='
56
Calling 'operator!='
60
Returning from 'operator!='
68
Calling 'operator!='
72
Returning from 'operator!='
4264 if (auto *ND = dyn_cast_or_null<NamespaceDecl>(C)) {
49
Calling 'dyn_cast_or_null'
51
Returning from 'dyn_cast_or_null'
52
Taking false branch
61
Calling 'dyn_cast_or_null'
63
Returning from 'dyn_cast_or_null'
64
Taking false branch
4265 NNS = NestedNameSpecifier::Create(Context, NNS, ND);
4266 ++NumSpecifiers;
4267 } else if (auto *RD = dyn_cast_or_null<RecordDecl>(C)) {
53
Calling 'dyn_cast_or_null'
54
Returning from 'dyn_cast_or_null'
55
Taking false branch
65
Calling 'dyn_cast_or_null'
66
Returning from 'dyn_cast_or_null'
67
Taking false branch
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;
25
'NNS' initialized to a null pointer value
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)
26
Assuming the condition is false
27
Taking false branch
28
Assuming the condition is false
29
Taking false branch
30
Assuming the condition is false
31
Taking false branch
32
Assuming the condition is true
33
Taking true branch
4286 break;
34
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);
35
Calling 'NamespaceSpecifierSet::buildNestedNameSpecifier'
73
Returning from 'NamespaceSpecifierSet::buildNestedNameSpecifier'
4292
4293 // Add an explicit leading '::' specifier if needed.
4294 if (NamespaceDeclChain.empty()) {
74
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 =
75
Assuming 'ND' is non-null
76
Taking true branch
4300 dyn_cast_or_null<NamedDecl>(NamespaceDeclChain.back())) {
4301 IdentifierInfo *Name = ND->getIdentifier();
4302 bool SameNameSpecifier = false;
4303 if (std::find(CurNameSpecifierIdentifiers.begin(),
77
Assuming the condition is true
78
Taking true branch
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);
79
Passing null pointer value via 1st parameter 'NNS'
80
Calling 'getNestedNameSpecifierIdentifiers'
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()) {
4329 SmallVector<const IdentifierInfo*, 4> NewNameSpecifierIdentifiers;
4330 getNestedNameSpecifierIdentifiers(NNS, NewNameSpecifierIdentifiers);
4331 NumSpecifiers = llvm::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/STLExtras.h

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- 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 contains some templates that are useful if you are working with the
11// STL at all.
12//
13// No library is required when using these functions.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_ADT_STLEXTRAS_H
18#define LLVM_ADT_STLEXTRAS_H
19
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <algorithm>
26#include <cassert>
27#include <cstddef>
28#include <cstdint>
29#include <cstdlib>
30#include <functional>
31#include <initializer_list>
32#include <iterator>
33#include <limits>
34#include <memory>
35#include <tuple>
36#include <type_traits>
37#include <utility>
38
39namespace llvm {
40
41// Only used by compiler if both template types are the same. Useful when
42// using SFINAE to test for the existence of member functions.
43template <typename T, T> struct SameType;
44
45namespace detail {
46
47template <typename RangeT>
48using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
49
50template <typename RangeT>
51using ValueOfRange = typename std::remove_reference<decltype(
52 *std::begin(std::declval<RangeT &>()))>::type;
53
54} // end namespace detail
55
56//===----------------------------------------------------------------------===//
57// Extra additions to <functional>
58//===----------------------------------------------------------------------===//
59
60template <class Ty> struct identity {
61 using argument_type = Ty;
62
63 Ty &operator()(Ty &self) const {
64 return self;
65 }
66 const Ty &operator()(const Ty &self) const {
67 return self;
68 }
69};
70
71template <class Ty> struct less_ptr {
72 bool operator()(const Ty* left, const Ty* right) const {
73 return *left < *right;
74 }
75};
76
77template <class Ty> struct greater_ptr {
78 bool operator()(const Ty* left, const Ty* right) const {
79 return *right < *left;
80 }
81};
82
83/// An efficient, type-erasing, non-owning reference to a callable. This is
84/// intended for use as the type of a function parameter that is not used
85/// after the function in question returns.
86///
87/// This class does not own the callable, so it is not in general safe to store
88/// a function_ref.
89template<typename Fn> class function_ref;
90
91template<typename Ret, typename ...Params>
92class function_ref<Ret(Params...)> {
93 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
94 intptr_t callable;
95
96 template<typename Callable>
97 static Ret callback_fn(intptr_t callable, Params ...params) {
98 return (*reinterpret_cast<Callable*>(callable))(
99 std::forward<Params>(params)...);
100 }
101
102public:
103 function_ref() = default;
104
105 template <typename Callable>
106 function_ref(Callable &&callable,
107 typename std::enable_if<
108 !std::is_same<typename std::remove_reference<Callable>::type,
109 function_ref>::value>::type * = nullptr)
110 : callback(callback_fn<typename std::remove_reference<Callable>::type>),
111 callable(reinterpret_cast<intptr_t>(&callable)) {}
112
113 Ret operator()(Params ...params) const {
114 return callback(callable, std::forward<Params>(params)...);
115 }
116
117 operator bool() const { return callback; }
118};
119
120// deleter - Very very very simple method that is used to invoke operator
121// delete on something. It is used like this:
122//
123// for_each(V.begin(), B.end(), deleter<Interval>);
124template <class T>
125inline void deleter(T *Ptr) {
126 delete Ptr;
127}
128
129//===----------------------------------------------------------------------===//
130// Extra additions to <iterator>
131//===----------------------------------------------------------------------===//
132
133namespace adl_detail {
134
135using std::begin;
136
137template <typename ContainerTy>
138auto adl_begin(ContainerTy &&container)
139 -> decltype(begin(std::forward<ContainerTy>(container))) {
140 return begin(std::forward<ContainerTy>(container));
141}
142
143using std::end;
144
145template <typename ContainerTy>
146auto adl_end(ContainerTy &&container)
147 -> decltype(end(std::forward<ContainerTy>(container))) {
148 return end(std::forward<ContainerTy>(container));
149}
150
151using std::swap;
152
153template <typename T>
154void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
155 std::declval<T>()))) {
156 swap(std::forward<T>(lhs), std::forward<T>(rhs));
157}
158
159} // end namespace adl_detail
160
161template <typename ContainerTy>
162auto adl_begin(ContainerTy &&container)
163 -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
164 return adl_detail::adl_begin(std::forward<ContainerTy>(container));
165}
166
167template <typename ContainerTy>
168auto adl_end(ContainerTy &&container)
169 -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
170 return adl_detail::adl_end(std::forward<ContainerTy>(container));
171}
172
173template <typename T>
174void adl_swap(T &&lhs, T &&rhs) noexcept(
175 noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
176 adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
177}
178
179// mapped_iterator - This is a simple iterator adapter that causes a function to
180// be applied whenever operator* is invoked on the iterator.
181
182template <typename ItTy, typename FuncTy,
183 typename FuncReturnTy =
184 decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
185class mapped_iterator
186 : public iterator_adaptor_base<
187 mapped_iterator<ItTy, FuncTy>, ItTy,
188 typename std::iterator_traits<ItTy>::iterator_category,
189 typename std::remove_reference<FuncReturnTy>::type> {
190public:
191 mapped_iterator(ItTy U, FuncTy F)
192 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
193
194 ItTy getCurrent() { return this->I; }
195
196 FuncReturnTy operator*() { return F(*this->I); }
197
198private:
199 FuncTy F;
200};
201
202// map_iterator - Provide a convenient way to create mapped_iterators, just like
203// make_pair is useful for creating pairs...
204template <class ItTy, class FuncTy>
205inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
206 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
207}
208
209/// Helper to determine if type T has a member called rbegin().
210template <typename Ty> class has_rbegin_impl {
211 using yes = char[1];
212 using no = char[2];
213
214 template <typename Inner>
215 static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
216
217 template <typename>
218 static no& test(...);
219
220public:
221 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
222};
223
224/// Metafunction to determine if T& or T has a member called rbegin().
225template <typename Ty>
226struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
227};
228
229// Returns an iterator_range over the given container which iterates in reverse.
230// Note that the container must have rbegin()/rend() methods for this to work.
231template <typename ContainerTy>
232auto reverse(ContainerTy &&C,
233 typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
234 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
235 return make_range(C.rbegin(), C.rend());
37
Calling 'make_range'
42
Returning from 'make_range'
236}
237
238// Returns a std::reverse_iterator wrapped around the given iterator.
239template <typename IteratorTy>
240std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
241 return std::reverse_iterator<IteratorTy>(It);
242}
243
244// Returns an iterator_range over the given container which iterates in reverse.
245// Note that the container must have begin()/end() methods which return
246// bidirectional iterators for this to work.
247template <typename ContainerTy>
248auto reverse(
249 ContainerTy &&C,
250 typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
251 -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
252 llvm::make_reverse_iterator(std::begin(C)))) {
253 return make_range(llvm::make_reverse_iterator(std::end(C)),
254 llvm::make_reverse_iterator(std::begin(C)));
255}
256
257/// An iterator adaptor that filters the elements of given inner iterators.
258///
259/// The predicate parameter should be a callable object that accepts the wrapped
260/// iterator's reference type and returns a bool. When incrementing or
261/// decrementing the iterator, it will call the predicate on each element and
262/// skip any where it returns false.
263///
264/// \code
265/// int A[] = { 1, 2, 3, 4 };
266/// auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
267/// // R contains { 1, 3 }.
268/// \endcode
269template <typename WrappedIteratorT, typename PredicateT>
270class filter_iterator
271 : public iterator_adaptor_base<
272 filter_iterator<WrappedIteratorT, PredicateT>, WrappedIteratorT,
273 typename std::common_type<
274 std::forward_iterator_tag,
275 typename std::iterator_traits<
276 WrappedIteratorT>::iterator_category>::type> {
277 using BaseT = iterator_adaptor_base<
278 filter_iterator<WrappedIteratorT, PredicateT>, WrappedIteratorT,
279 typename std::common_type<
280 std::forward_iterator_tag,
281 typename std::iterator_traits<WrappedIteratorT>::iterator_category>::
282 type>;
283
284 struct PayloadType {
285 WrappedIteratorT End;
286 PredicateT Pred;
287 };
288
289 Optional<PayloadType> Payload;
290
291 void findNextValid() {
292 assert(Payload && "Payload should be engaged when findNextValid is called")(static_cast <bool> (Payload && "Payload should be engaged when findNextValid is called"
) ? void (0) : __assert_fail ("Payload && \"Payload should be engaged when findNextValid is called\""
, "/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/STLExtras.h"
, 292, __extension__ __PRETTY_FUNCTION__))
;
293 while (this->I != Payload->End && !Payload->Pred(*this->I))
294 BaseT::operator++();
295 }
296
297 // Construct the begin iterator. The begin iterator requires to know where end
298 // is, so that it can properly stop when it hits end.
299 filter_iterator(WrappedIteratorT Begin, WrappedIteratorT End, PredicateT Pred)
300 : BaseT(std::move(Begin)),
301 Payload(PayloadType{std::move(End), std::move(Pred)}) {
302 findNextValid();
303 }
304
305 // Construct the end iterator. It's not incrementable, so Payload doesn't
306 // have to be engaged.
307 filter_iterator(WrappedIteratorT End) : BaseT(End) {}
308
309public:
310 using BaseT::operator++;
311
312 filter_iterator &operator++() {
313 BaseT::operator++();
314 findNextValid();
315 return *this;
316 }
317
318 template <typename RT, typename PT>
319 friend iterator_range<filter_iterator<detail::IterOfRange<RT>, PT>>
320 make_filter_range(RT &&, PT);
321};
322
323/// Convenience function that takes a range of elements and a predicate,
324/// and return a new filter_iterator range.
325///
326/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
327/// lifetime of that temporary is not kept by the returned range object, and the
328/// temporary is going to be dropped on the floor after the make_iterator_range
329/// full expression that contains this function call.
330template <typename RangeT, typename PredicateT>
331iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
332make_filter_range(RangeT &&Range, PredicateT Pred) {
333 using FilterIteratorT =
334 filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
335 return make_range(FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
336 std::end(std::forward<RangeT>(Range)),
337 std::move(Pred)),
338 FilterIteratorT(std::end(std::forward<RangeT>(Range))));
339}
340
341// forward declarations required by zip_shortest/zip_first
342template <typename R, typename UnaryPredicate>
343bool all_of(R &&range, UnaryPredicate P);
344
345template <size_t... I> struct index_sequence;
346
347template <class... Ts> struct index_sequence_for;
348
349namespace detail {
350
351using std::declval;
352
353// We have to alias this since inlining the actual type at the usage site
354// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
355template<typename... Iters> struct ZipTupleType {
356 using type = std::tuple<decltype(*declval<Iters>())...>;
357};
358
359template <typename ZipType, typename... Iters>
360using zip_traits = iterator_facade_base<
361 ZipType, typename std::common_type<std::bidirectional_iterator_tag,
362 typename std::iterator_traits<
363 Iters>::iterator_category...>::type,
364 // ^ TODO: Implement random access methods.
365 typename ZipTupleType<Iters...>::type,
366 typename std::iterator_traits<typename std::tuple_element<
367 0, std::tuple<Iters...>>::type>::difference_type,
368 // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
369 // inner iterators have the same difference_type. It would fail if, for
370 // instance, the second field's difference_type were non-numeric while the
371 // first is.
372 typename ZipTupleType<Iters...>::type *,
373 typename ZipTupleType<Iters...>::type>;
374
375template <typename ZipType, typename... Iters>
376struct zip_common : public zip_traits<ZipType, Iters...> {
377 using Base = zip_traits<ZipType, Iters...>;
378 using value_type = typename Base::value_type;
379
380 std::tuple<Iters...> iterators;
381
382protected:
383 template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
384 return value_type(*std::get<Ns>(iterators)...);
385 }
386
387 template <size_t... Ns>
388 decltype(iterators) tup_inc(index_sequence<Ns...>) const {
389 return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
390 }
391
392 template <size_t... Ns>
393 decltype(iterators) tup_dec(index_sequence<Ns...>) const {
394 return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
395 }
396
397public:
398 zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
399
400 value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
401
402 const value_type operator*() const {
403 return deref(index_sequence_for<Iters...>{});
404 }
405
406 ZipType &operator++() {
407 iterators = tup_inc(index_sequence_for<Iters...>{});
408 return *reinterpret_cast<ZipType *>(this);
409 }
410
411 ZipType &operator--() {
412 static_assert(Base::IsBidirectional,
413 "All inner iterators must be at least bidirectional.");
414 iterators = tup_dec(index_sequence_for<Iters...>{});
415 return *reinterpret_cast<ZipType *>(this);
416 }
417};
418
419template <typename... Iters>
420struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
421 using Base = zip_common<zip_first<Iters...>, Iters...>;
422
423 bool operator==(const zip_first<Iters...> &other) const {
424 return std::get<0>(this->iterators) == std::get<0>(other.iterators);
425 }
426
427 zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
428};
429
430template <typename... Iters>
431class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
432 template <size_t... Ns>
433 bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
434 return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
435 std::get<Ns>(other.iterators)...},
436 identity<bool>{});
437 }
438
439public:
440 using Base = zip_common<zip_shortest<Iters...>, Iters...>;
441
442 zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
443
444 bool operator==(const zip_shortest<Iters...> &other) const {
445 return !test(other, index_sequence_for<Iters...>{});
446 }
447};
448
449template <template <typename...> class ItType, typename... Args> class zippy {
450public:
451 using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
452 using iterator_category = typename iterator::iterator_category;
453 using value_type = typename iterator::value_type;
454 using difference_type = typename iterator::difference_type;
455 using pointer = typename iterator::pointer;
456 using reference = typename iterator::reference;
457
458private:
459 std::tuple<Args...> ts;
460
461 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
462 return iterator(std::begin(std::get<Ns>(ts))...);
463 }
464 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
465 return iterator(std::end(std::get<Ns>(ts))...);
466 }
467
468public:
469 zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
470
471 iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
472 iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
473};
474
475} // end namespace detail
476
477/// zip iterator for two or more iteratable types.
478template <typename T, typename U, typename... Args>
479detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
480 Args &&... args) {
481 return detail::zippy<detail::zip_shortest, T, U, Args...>(
482 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
483}
484
485/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
486/// be the shortest.
487template <typename T, typename U, typename... Args>
488detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
489 Args &&... args) {
490 return detail::zippy<detail::zip_first, T, U, Args...>(
491 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
492}
493
494/// Iterator wrapper that concatenates sequences together.
495///
496/// This can concatenate different iterators, even with different types, into
497/// a single iterator provided the value types of all the concatenated
498/// iterators expose `reference` and `pointer` types that can be converted to
499/// `ValueT &` and `ValueT *` respectively. It doesn't support more
500/// interesting/customized pointer or reference types.
501///
502/// Currently this only supports forward or higher iterator categories as
503/// inputs and always exposes a forward iterator interface.
504template <typename ValueT, typename... IterTs>
505class concat_iterator
506 : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
507 std::forward_iterator_tag, ValueT> {
508 using BaseT = typename concat_iterator::iterator_facade_base;
509
510 /// We store both the current and end iterators for each concatenated
511 /// sequence in a tuple of pairs.
512 ///
513 /// Note that something like iterator_range seems nice at first here, but the
514 /// range properties are of little benefit and end up getting in the way
515 /// because we need to do mutation on the current iterators.
516 std::tuple<std::pair<IterTs, IterTs>...> IterPairs;
517
518 /// Attempts to increment a specific iterator.
519 ///
520 /// Returns true if it was able to increment the iterator. Returns false if
521 /// the iterator is already at the end iterator.
522 template <size_t Index> bool incrementHelper() {
523 auto &IterPair = std::get<Index>(IterPairs);
524 if (IterPair.first == IterPair.second)
525 return false;
526
527 ++IterPair.first;
528 return true;
529 }
530
531 /// Increments the first non-end iterator.
532 ///
533 /// It is an error to call this with all iterators at the end.
534 template <size_t... Ns> void increment(index_sequence<Ns...>) {
535 // Build a sequence of functions to increment each iterator if possible.
536 bool (concat_iterator::*IncrementHelperFns[])() = {
537 &concat_iterator::incrementHelper<Ns>...};
538
539 // Loop over them, and stop as soon as we succeed at incrementing one.
540 for (auto &IncrementHelperFn : IncrementHelperFns)
541 if ((this->*IncrementHelperFn)())
542 return;
543
544 llvm_unreachable("Attempted to increment an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to increment an end concat iterator!"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/STLExtras.h"
, 544)
;
545 }
546
547 /// Returns null if the specified iterator is at the end. Otherwise,
548 /// dereferences the iterator and returns the address of the resulting
549 /// reference.
550 template <size_t Index> ValueT *getHelper() const {
551 auto &IterPair = std::get<Index>(IterPairs);
552 if (IterPair.first == IterPair.second)
553 return nullptr;
554
555 return &*IterPair.first;
556 }
557
558 /// Finds the first non-end iterator, dereferences, and returns the resulting
559 /// reference.
560 ///
561 /// It is an error to call this with all iterators at the end.
562 template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
563 // Build a sequence of functions to get from iterator if possible.
564 ValueT *(concat_iterator::*GetHelperFns[])() const = {
565 &concat_iterator::getHelper<Ns>...};
566
567 // Loop over them, and return the first result we find.
568 for (auto &GetHelperFn : GetHelperFns)
569 if (ValueT *P = (this->*GetHelperFn)())
570 return *P;
571
572 llvm_unreachable("Attempted to get a pointer from an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to get a pointer from an end concat iterator!"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/STLExtras.h"
, 572)
;
573 }
574
575public:
576 /// Constructs an iterator from a squence of ranges.
577 ///
578 /// We need the full range to know how to switch between each of the
579 /// iterators.
580 template <typename... RangeTs>
581 explicit concat_iterator(RangeTs &&... Ranges)
582 : IterPairs({std::begin(Ranges), std::end(Ranges)}...) {}
583
584 using BaseT::operator++;
585
586 concat_iterator &operator++() {
587 increment(index_sequence_for<IterTs...>());
588 return *this;
589 }
590
591 ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
592
593 bool operator==(const concat_iterator &RHS) const {
594 return IterPairs == RHS.IterPairs;
595 }
596};
597
598namespace detail {
599
600/// Helper to store a sequence of ranges being concatenated and access them.
601///
602/// This is designed to facilitate providing actual storage when temporaries
603/// are passed into the constructor such that we can use it as part of range
604/// based for loops.
605template <typename ValueT, typename... RangeTs> class concat_range {
606public:
607 using iterator =
608 concat_iterator<ValueT,
609 decltype(std::begin(std::declval<RangeTs &>()))...>;
610
611private:
612 std::tuple<RangeTs...> Ranges;
613
614 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
615 return iterator(std::get<Ns>(Ranges)...);
616 }
617 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
618 return iterator(make_range(std::end(std::get<Ns>(Ranges)),
619 std::end(std::get<Ns>(Ranges)))...);
620 }
621
622public:
623 concat_range(RangeTs &&... Ranges)
624 : Ranges(std::forward<RangeTs>(Ranges)...) {}
625
626 iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
627 iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
628};
629
630} // end namespace detail
631
632/// Concatenated range across two or more ranges.
633///
634/// The desired value type must be explicitly specified.
635template <typename ValueT, typename... RangeTs>
636detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
637 static_assert(sizeof...(RangeTs) > 1,
638 "Need more than one range to concatenate!");
639 return detail::concat_range<ValueT, RangeTs...>(
640 std::forward<RangeTs>(Ranges)...);
641}
642
643//===----------------------------------------------------------------------===//
644// Extra additions to <utility>
645//===----------------------------------------------------------------------===//
646
647/// \brief Function object to check whether the first component of a std::pair
648/// compares less than the first component of another std::pair.
649struct less_first {
650 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
651 return lhs.first < rhs.first;
652 }
653};
654
655/// \brief Function object to check whether the second component of a std::pair
656/// compares less than the second component of another std::pair.
657struct less_second {
658 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
659 return lhs.second < rhs.second;
660 }
661};
662
663// A subset of N3658. More stuff can be added as-needed.
664
665/// \brief Represents a compile-time sequence of integers.
666template <class T, T... I> struct integer_sequence {
667 using value_type = T;
668
669 static constexpr size_t size() { return sizeof...(I); }
670};
671
672/// \brief Alias for the common case of a sequence of size_ts.
673template <size_t... I>
674struct index_sequence : integer_sequence<std::size_t, I...> {};
675
676template <std::size_t N, std::size_t... I>
677struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
678template <std::size_t... I>
679struct build_index_impl<0, I...> : index_sequence<I...> {};
680
681/// \brief Creates a compile-time integer sequence for a parameter pack.
682template <class... Ts>
683struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
684
685/// Utility type to build an inheritance chain that makes it easy to rank
686/// overload candidates.
687template <int N> struct rank : rank<N - 1> {};
688template <> struct rank<0> {};
689
690/// \brief traits class for checking whether type T is one of any of the given
691/// types in the variadic list.
692template <typename T, typename... Ts> struct is_one_of {
693 static const bool value = false;
694};
695
696template <typename T, typename U, typename... Ts>
697struct is_one_of<T, U, Ts...> {
698 static const bool value =
699 std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
700};
701
702/// \brief traits class for checking whether type T is a base class for all
703/// the given types in the variadic list.
704template <typename T, typename... Ts> struct are_base_of {
705 static const bool value = true;
706};
707
708template <typename T, typename U, typename... Ts>
709struct are_base_of<T, U, Ts...> {
710 static const bool value =
711 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
712};
713
714//===----------------------------------------------------------------------===//
715// Extra additions for arrays
716//===----------------------------------------------------------------------===//
717
718/// Find the length of an array.
719template <class T, std::size_t N>
720constexpr inline size_t array_lengthof(T (&)[N]) {
721 return N;
722}
723
724/// Adapt std::less<T> for array_pod_sort.
725template<typename T>
726inline int array_pod_sort_comparator(const void *P1, const void *P2) {
727 if (std::less<T>()(*reinterpret_cast<const T*>(P1),
728 *reinterpret_cast<const T*>(P2)))
729 return -1;
730 if (std::less<T>()(*reinterpret_cast<const T*>(P2),
731 *reinterpret_cast<const T*>(P1)))
732 return 1;
733 return 0;
734}
735
736/// get_array_pod_sort_comparator - This is an internal helper function used to
737/// get type deduction of T right.
738template<typename T>
739inline int (*get_array_pod_sort_comparator(const T &))
740 (const void*, const void*) {
741 return array_pod_sort_comparator<T>;
742}
743
744/// array_pod_sort - This sorts an array with the specified start and end
745/// extent. This is just like std::sort, except that it calls qsort instead of
746/// using an inlined template. qsort is slightly slower than std::sort, but
747/// most sorts are not performance critical in LLVM and std::sort has to be
748/// template instantiated for each type, leading to significant measured code
749/// bloat. This function should generally be used instead of std::sort where
750/// possible.
751///
752/// This function assumes that you have simple POD-like types that can be
753/// compared with std::less and can be moved with memcpy. If this isn't true,
754/// you should use std::sort.
755///
756/// NOTE: If qsort_r were portable, we could allow a custom comparator and
757/// default to std::less.
758template<class IteratorTy>
759inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
760 // Don't inefficiently call qsort with one element or trigger undefined
761 // behavior with an empty sequence.
762 auto NElts = End - Start;
763 if (NElts <= 1) return;
764 qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
765}
766
767template <class IteratorTy>
768inline void array_pod_sort(
769 IteratorTy Start, IteratorTy End,
770 int (*Compare)(
771 const typename std::iterator_traits<IteratorTy>::value_type *,
772 const typename std::iterator_traits<IteratorTy>::value_type *)) {
773 // Don't inefficiently call qsort with one element or trigger undefined
774 // behavior with an empty sequence.
775 auto NElts = End - Start;
776 if (NElts <= 1) return;
777 qsort(&*Start, NElts, sizeof(*Start),
778 reinterpret_cast<int (*)(const void *, const void *)>(Compare));
779}
780
781//===----------------------------------------------------------------------===//
782// Extra additions to <algorithm>
783//===----------------------------------------------------------------------===//
784
785/// For a container of pointers, deletes the pointers and then clears the
786/// container.
787template<typename Container>
788void DeleteContainerPointers(Container &C) {
789 for (auto V : C)
790 delete V;
791 C.clear();
792}
793
794/// In a container of pairs (usually a map) whose second element is a pointer,
795/// deletes the second elements and then clears the container.
796template<typename Container>
797void DeleteContainerSeconds(Container &C) {
798 for (auto &V : C)
799 delete V.second;
800 C.clear();
801}
802
803/// Provide wrappers to std::for_each which take ranges instead of having to
804/// pass begin/end explicitly.
805template <typename R, typename UnaryPredicate>
806UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
807 return std::for_each(adl_begin(Range), adl_end(Range), P);
808}
809
810/// Provide wrappers to std::all_of which take ranges instead of having to pass
811/// begin/end explicitly.
812template <typename R, typename UnaryPredicate>
813bool all_of(R &&Range, UnaryPredicate P) {
814 return std::all_of(adl_begin(Range), adl_end(Range), P);
815}
816
817/// Provide wrappers to std::any_of which take ranges instead of having to pass
818/// begin/end explicitly.
819template <typename R, typename UnaryPredicate>
820bool any_of(R &&Range, UnaryPredicate P) {
821 return std::any_of(adl_begin(Range), adl_end(Range), P);
822}
823
824/// Provide wrappers to std::none_of which take ranges instead of having to pass
825/// begin/end explicitly.
826template <typename R, typename UnaryPredicate>
827bool none_of(R &&Range, UnaryPredicate P) {
828 return std::none_of(adl_begin(Range), adl_end(Range), P);
829}
830
831/// Provide wrappers to std::find which take ranges instead of having to pass
832/// begin/end explicitly.
833template <typename R, typename T>
834auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
835 return std::find(adl_begin(Range), adl_end(Range), Val);
836}
837
838/// Provide wrappers to std::find_if which take ranges instead of having to pass
839/// begin/end explicitly.
840template <typename R, typename UnaryPredicate>
841auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
842 return std::find_if(adl_begin(Range), adl_end(Range), P);
843}
844
845template <typename R, typename UnaryPredicate>
846auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
847 return std::find_if_not(adl_begin(Range), adl_end(Range), P);
848}
849
850/// Provide wrappers to std::remove_if which take ranges instead of having to
851/// pass begin/end explicitly.
852template <typename R, typename UnaryPredicate>
853auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
854 return std::remove_if(adl_begin(Range), adl_end(Range), P);
855}
856
857/// Provide wrappers to std::copy_if which take ranges instead of having to
858/// pass begin/end explicitly.
859template <typename R, typename OutputIt, typename UnaryPredicate>
860OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
861 return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
862}
863
864/// Wrapper function around std::find to detect if an element exists
865/// in a container.
866template <typename R, typename E>
867bool is_contained(R &&Range, const E &Element) {
868 return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
869}
870
871/// Wrapper function around std::count to count the number of times an element
872/// \p Element occurs in the given range \p Range.
873template <typename R, typename E>
874auto count(R &&Range, const E &Element) ->
875 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
876 return std::count(adl_begin(Range), adl_end(Range), Element);
877}
878
879/// Wrapper function around std::count_if to count the number of times an
880/// element satisfying a given predicate occurs in a range.
881template <typename R, typename UnaryPredicate>
882auto count_if(R &&Range, UnaryPredicate P) ->
883 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
884 return std::count_if(adl_begin(Range), adl_end(Range), P);
885}
886
887/// Wrapper function around std::transform to apply a function to a range and
888/// store the result elsewhere.
889template <typename R, typename OutputIt, typename UnaryPredicate>
890OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
891 return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
892}
893
894/// Provide wrappers to std::partition which take ranges instead of having to
895/// pass begin/end explicitly.
896template <typename R, typename UnaryPredicate>
897auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
898 return std::partition(adl_begin(Range), adl_end(Range), P);
899}
900
901/// Provide wrappers to std::lower_bound which take ranges instead of having to
902/// pass begin/end explicitly.
903template <typename R, typename ForwardIt>
904auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range)) {
905 return std::lower_bound(adl_begin(Range), adl_end(Range), I);
906}
907
908/// \brief Given a range of type R, iterate the entire range and return a
909/// SmallVector with elements of the vector. This is useful, for example,
910/// when you want to iterate a range and then sort the results.
911template <unsigned Size, typename R>
912SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
913to_vector(R &&Range) {
914 return {adl_begin(Range), adl_end(Range)};
915}
916
917/// Provide a container algorithm similar to C++ Library Fundamentals v2's
918/// `erase_if` which is equivalent to:
919///
920/// C.erase(remove_if(C, pred), C.end());
921///
922/// This version works for any container with an erase method call accepting
923/// two iterators.
924template <typename Container, typename UnaryPredicate>
925void erase_if(Container &C, UnaryPredicate P) {
926 C.erase(remove_if(C, P), C.end());
927}
928
929//===----------------------------------------------------------------------===//
930// Extra additions to <memory>
931//===----------------------------------------------------------------------===//
932
933// Implement make_unique according to N3656.
934
935/// \brief Constructs a `new T()` with the given args and returns a
936/// `unique_ptr<T>` which owns the object.
937///
938/// Example:
939///
940/// auto p = make_unique<int>();
941/// auto p = make_unique<std::tuple<int, int>>(0, 1);
942template <class T, class... Args>
943typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
944make_unique(Args &&... args) {
945 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
946}
947
948/// \brief Constructs a `new T[n]` with the given args and returns a
949/// `unique_ptr<T[]>` which owns the object.
950///
951/// \param n size of the new array.
952///
953/// Example:
954///
955/// auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
956template <class T>
957typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
958 std::unique_ptr<T>>::type
959make_unique(size_t n) {
960 return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
961}
962
963/// This function isn't used and is only here to provide better compile errors.
964template <class T, class... Args>
965typename std::enable_if<std::extent<T>::value != 0>::type
966make_unique(Args &&...) = delete;
967
968struct FreeDeleter {
969 void operator()(void* v) {
970 ::free(v);
971 }
972};
973
974template<typename First, typename Second>
975struct pair_hash {
976 size_t operator()(const std::pair<First, Second> &P) const {
977 return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
978 }
979};
980
981/// A functor like C++14's std::less<void> in its absence.
982struct less {
983 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
984 return std::forward<A>(a) < std::forward<B>(b);
985 }
986};
987
988/// A functor like C++14's std::equal<void> in its absence.
989struct equal {
990 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
991 return std::forward<A>(a) == std::forward<B>(b);
992 }
993};
994
995/// Binary functor that adapts to any other binary functor after dereferencing
996/// operands.
997template <typename T> struct deref {
998 T func;
999
1000 // Could be further improved to cope with non-derivable functors and
1001 // non-binary functors (should be a variadic template member function
1002 // operator()).
1003 template <typename A, typename B>
1004 auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
1005 assert(lhs)(static_cast <bool> (lhs) ? void (0) : __assert_fail ("lhs"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/STLExtras.h"
, 1005, __extension__ __PRETTY_FUNCTION__))
;
1006 assert(rhs)(static_cast <bool> (rhs) ? void (0) : __assert_fail ("rhs"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/STLExtras.h"
, 1006, __extension__ __PRETTY_FUNCTION__))
;
1007 return func(*lhs, *rhs);
1008 }
1009};
1010
1011namespace detail {
1012
1013template <typename R> class enumerator_iter;
1014
1015template <typename R> struct result_pair {
1016 friend class enumerator_iter<R>;
1017
1018 result_pair() = default;
1019 result_pair(std::size_t Index, IterOfRange<R> Iter)
1020 : Index(Index), Iter(Iter) {}
1021
1022 result_pair<R> &operator=(const result_pair<R> &Other) {
1023 Index = Other.Index;
1024 Iter = Other.Iter;
1025 return *this;
1026 }
1027
1028 std::size_t index() const { return Index; }
1029 const ValueOfRange<R> &value() const { return *Iter; }
1030 ValueOfRange<R> &value() { return *Iter; }
1031
1032private:
1033 std::size_t Index = std::numeric_limits<std::size_t>::max();
1034 IterOfRange<R> Iter;
1035};
1036
1037template <typename R>
1038class enumerator_iter
1039 : public iterator_facade_base<
1040 enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1041 typename std::iterator_traits<IterOfRange<R>>::difference_type,
1042 typename std::iterator_traits<IterOfRange<R>>::pointer,
1043 typename std::iterator_traits<IterOfRange<R>>::reference> {
1044 using result_type = result_pair<R>;
1045
1046public:
1047 explicit enumerator_iter(IterOfRange<R> EndIter)
1048 : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1049
1050 enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1051 : Result(Index, Iter) {}
1052
1053 result_type &operator*() { return Result; }
1054 const result_type &operator*() const { return Result; }
1055
1056 enumerator_iter<R> &operator++() {
1057 assert(Result.Index != std::numeric_limits<size_t>::max())(static_cast <bool> (Result.Index != std::numeric_limits
<size_t>::max()) ? void (0) : __assert_fail ("Result.Index != std::numeric_limits<size_t>::max()"
, "/build/llvm-toolchain-snapshot-6.0~svn321639/include/llvm/ADT/STLExtras.h"
, 1057, __extension__ __PRETTY_FUNCTION__))
;
1058 ++Result.Iter;
1059 ++Result.Index;
1060 return *this;
1061 }
1062
1063 bool operator==(const enumerator_iter<R> &RHS) const {
1064 // Don't compare indices here, only iterators. It's possible for an end
1065 // iterator to have different indices depending on whether it was created
1066 // by calling std::end() versus incrementing a valid iterator.
1067 return Result.Iter == RHS.Result.Iter;
1068 }
1069
1070 enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
1071 Result = Other.Result;
1072 return *this;
1073 }
1074
1075private:
1076 result_type Result;
1077};
1078
1079template <typename R> class enumerator {
1080public:
1081 explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1082
1083 enumerator_iter<R> begin() {
1084 return enumerator_iter<R>(0, std::begin(TheRange));
1085 }
1086
1087 enumerator_iter<R> end() {
1088 return enumerator_iter<R>(std::end(TheRange));
1089 }
1090
1091private:
1092 R TheRange;
1093};
1094
1095} // end namespace detail
1096
1097/// Given an input range, returns a new range whose values are are pair (A,B)
1098/// such that A is the 0-based index of the item in the sequence, and B is
1099/// the value from the original sequence. Example:
1100///
1101/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1102/// for (auto X : enumerate(Items)) {
1103/// printf("Item %d - %c\n", X.index(), X.value());
1104/// }
1105///
1106/// Output:
1107/// Item 0 - A
1108/// Item 1 - B
1109/// Item 2 - C
1110/// Item 3 - D
1111///
1112template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1113 return detail::enumerator<R>(std::forward<R>(TheRange));
1114}
1115
1116namespace detail {
1117
1118template <typename F, typename Tuple, std::size_t... I>
1119auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
1120 -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1121 return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1122}
1123
1124} // end namespace detail
1125
1126/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1127/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1128/// return the result.
1129template <typename F, typename Tuple>
1130auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
1131 std::forward<F>(f), std::forward<Tuple>(t),
1132 build_index_impl<
1133 std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1134 using Indices = build_index_impl<
1135 std::tuple_size<typename std::decay<Tuple>::type>::value>;
1136
1137 return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1138 Indices{});
1139}
1140
1141} // end namespace llvm
1142
1143#endif // LLVM_ADT_STLEXTRAS_H

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

1//===- iterator_range.h - A range adaptor for iterators ---------*- 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/// \file
10/// This provides a very simple, boring adaptor for a begin and end iterator
11/// into a range type. This should be used to build range views that work well
12/// with range based for loops and range based constructors.
13///
14/// Note that code here follows more standards-based coding conventions as it
15/// is mirroring proposed interfaces for standardization.
16///
17//===----------------------------------------------------------------------===//
18
19#ifndef LLVM_ADT_ITERATOR_RANGE_H
20#define LLVM_ADT_ITERATOR_RANGE_H
21
22#include <iterator>
23#include <utility>
24
25namespace llvm {
26
27/// \brief A range adaptor for a pair of iterators.
28///
29/// This just wraps two iterators into a range-compatible interface. Nothing
30/// fancy at all.
31template <typename IteratorT>
32class iterator_range {
33 IteratorT begin_iterator, end_iterator;
34
35public:
36 //TODO: Add SFINAE to test that the Container's iterators match the range's
37 // iterators.
38 template <typename Container>
39 iterator_range(Container &&c)
40 //TODO: Consider ADL/non-member begin/end calls.
41 : begin_iterator(c.begin()), end_iterator(c.end()) {}
42 iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
43 : begin_iterator(std::move(begin_iterator)),
44 end_iterator(std::move(end_iterator)) {}
45
46 IteratorT begin() const { return begin_iterator; }
47 IteratorT end() const { return end_iterator; }
48};
49
50/// \brief Convenience function for iterating over sub-ranges.
51///
52/// This provides a bit of syntactic sugar to make using sub-ranges
53/// in for loops a bit easier. Analogous to std::make_pair().
54template <class T> iterator_range<T> make_range(T x, T y) {
55 return iterator_range<T>(std::move(x), std::move(y));
38
Calling 'move'
39
Returning from 'move'
40
Calling 'move'
41
Returning from 'move'
56}
57
58template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
59 return iterator_range<T>(std::move(p.first), std::move(p.second));
60}
61
62template<typename T>
63iterator_range<decltype(begin(std::declval<T>()))> drop_begin(T &&t, int n) {
64 return make_range(std::next(begin(t), n), end(t));
65}
66}
67
68#endif

/usr/lib/gcc/x86_64-linux-gnu/7.2.0/../../../../include/c++/7.2.0/bits/stl_iterator.h

1// Iterators -*- C++ -*-
2
3// Copyright (C) 2001-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/*
26 *
27 * Copyright (c) 1994
28 * Hewlett-Packard Company
29 *
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Hewlett-Packard Company makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
37 *
38 *
39 * Copyright (c) 1996-1998
40 * Silicon Graphics Computer Systems, Inc.
41 *
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
49 */
50
51/** @file bits/stl_iterator.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{iterator}
54 *
55 * This file implements reverse_iterator, back_insert_iterator,
56 * front_insert_iterator, insert_iterator, __normal_iterator, and their
57 * supporting functions and overloaded operators.
58 */
59
60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1
62
63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>
66#include <bits/ptr_traits.h>
67
68#if __cplusplus201103L > 201402L
69# define __cpp_lib_array_constexpr 201603
70#endif
71
72namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
73{
74_GLIBCXX_BEGIN_NAMESPACE_VERSION
75
76 /**
77 * @addtogroup iterators
78 * @{
79 */
80
81 // 24.4.1 Reverse iterators
82 /**
83 * Bidirectional and random access iterators have corresponding reverse
84 * %iterator adaptors that iterate through the data structure in the
85 * opposite direction. They have the same signatures as the corresponding
86 * iterators. The fundamental relation between a reverse %iterator and its
87 * corresponding %iterator @c i is established by the identity:
88 * @code
89 * &*(reverse_iterator(i)) == &*(i - 1)
90 * @endcode
91 *
92 * <em>This mapping is dictated by the fact that while there is always a
93 * pointer past the end of an array, there might not be a valid pointer
94 * before the beginning of an array.</em> [24.4.1]/1,2
95 *
96 * Reverse iterators can be tricky and surprising at first. Their
97 * semantics make sense, however, and the trickiness is a side effect of
98 * the requirement that the iterators must be safe.
99 */
100 template<typename _Iterator>
101 class reverse_iterator
102 : public iterator<typename iterator_traits<_Iterator>::iterator_category,
103 typename iterator_traits<_Iterator>::value_type,
104 typename iterator_traits<_Iterator>::difference_type,
105 typename iterator_traits<_Iterator>::pointer,
106 typename iterator_traits<_Iterator>::reference>
107 {
108 protected:
109 _Iterator current;
110
111 typedef iterator_traits<_Iterator> __traits_type;
112
113 public:
114 typedef _Iterator iterator_type;
115 typedef typename __traits_type::difference_type difference_type;
116 typedef typename __traits_type::pointer pointer;
117 typedef typename __traits_type::reference reference;
118
119 /**
120 * The default constructor value-initializes member @p current.
121 * If it is a pointer, that means it is zero-initialized.
122 */
123 // _GLIBCXX_RESOLVE_LIB_DEFECTS
124 // 235 No specification of default ctor for reverse_iterator
125 _GLIBCXX17_CONSTEXPR
126 reverse_iterator() : current() { }
127
128 /**
129 * This %iterator will move in the opposite direction that @p x does.
130 */
131 explicit _GLIBCXX17_CONSTEXPR
132 reverse_iterator(iterator_type __x) : current(__x) { }
133
134 /**
135 * The copy constructor is normal.
136 */
137 _GLIBCXX17_CONSTEXPR
138 reverse_iterator(const reverse_iterator& __x)
139 : current(__x.current) { }
140
141 /**
142 * A %reverse_iterator across other types can be copied if the
143 * underlying %iterator can be converted to the type of @c current.
144 */
145 template<typename _Iter>
146 _GLIBCXX17_CONSTEXPR
147 reverse_iterator(const reverse_iterator<_Iter>& __x)
148 : current(__x.base()) { }
149
150 /**
151 * @return @c current, the %iterator used for underlying work.
152 */
153 _GLIBCXX17_CONSTEXPR iterator_type
154 base() const
155 { return current; }
156
157 /**
158 * @return A reference to the value at @c --current
159 *
160 * This requires that @c --current is dereferenceable.
161 *
162 * @warning This implementation requires that for an iterator of the
163 * underlying iterator type, @c x, a reference obtained by
164 * @c *x remains valid after @c x has been modified or
165 * destroyed. This is a bug: http://gcc.gnu.org/PR51823
166 */
167 _GLIBCXX17_CONSTEXPR reference
168 operator*() const
169 {
170 _Iterator __tmp = current;
171 return *--__tmp;
172 }
173
174 /**
175 * @return A pointer to the value at @c --current
176 *
177 * This requires that @c --current is dereferenceable.
178 */
179 _GLIBCXX17_CONSTEXPR pointer
180 operator->() const
181 { return &(operator*()); }
182
183 /**
184 * @return @c *this
185 *
186 * Decrements the underlying iterator.
187 */
188 _GLIBCXX17_CONSTEXPR reverse_iterator&
189 operator++()
190 {
191 --current;
192 return *this;
193 }
194
195 /**
196 * @return The original value of @c *this
197 *
198 * Decrements the underlying iterator.
199 */
200 _GLIBCXX17_CONSTEXPR reverse_iterator
201 operator++(int)
202 {
203 reverse_iterator __tmp = *this;
204 --current;
205 return __tmp;
206 }
207
208 /**
209 * @return @c *this
210 *
211 * Increments the underlying iterator.
212 */
213 _GLIBCXX17_CONSTEXPR reverse_iterator&
214 operator--()
215 {
216 ++current;
217 return *this;
218 }
219
220 /**
221 * @return A reverse_iterator with the previous value of @c *this
222 *
223 * Increments the underlying iterator.
224 */
225 _GLIBCXX17_CONSTEXPR reverse_iterator
226 operator--(int)
227 {
228 reverse_iterator __tmp = *this;
229 ++current;
230 return __tmp;
231 }
232
233 /**
234 * @return A reverse_iterator that refers to @c current - @a __n
235 *
236 * The underlying iterator must be a Random Access Iterator.
237 */
238 _GLIBCXX17_CONSTEXPR reverse_iterator
239 operator+(difference_type __n) const
240 { return reverse_iterator(current - __n); }
241
242 /**
243 * @return *this
244 *
245 * Moves the underlying iterator backwards @a __n steps.
246 * The underlying iterator must be a Random Access Iterator.
247 */
248 _GLIBCXX17_CONSTEXPR reverse_iterator&
249 operator+=(difference_type __n)
250 {
251 current -= __n;
252 return *this;
253 }
254
255 /**
256 * @return A reverse_iterator that refers to @c current - @a __n
257 *
258 * The underlying iterator must be a Random Access Iterator.
259 */
260 _GLIBCXX17_CONSTEXPR reverse_iterator
261 operator-(difference_type __n) const
262 { return reverse_iterator(current + __n); }
263
264 /**
265 * @return *this
266 *
267 * Moves the underlying iterator forwards @a __n steps.
268 * The underlying iterator must be a Random Access Iterator.
269 */
270 _GLIBCXX17_CONSTEXPR reverse_iterator&
271 operator-=(difference_type __n)
272 {
273 current += __n;
274 return *this;
275 }
276
277 /**
278 * @return The value at @c current - @a __n - 1
279 *
280 * The underlying iterator must be a Random Access Iterator.
281 */
282 _GLIBCXX17_CONSTEXPR reference
283 operator[](difference_type __n) const
284 { return *(*this + __n); }
285 };
286
287 //@{
288 /**
289 * @param __x A %reverse_iterator.
290 * @param __y A %reverse_iterator.
291 * @return A simple bool.
292 *
293 * Reverse iterators forward many operations to their underlying base()
294 * iterators. Others are implemented in terms of one another.
295 *
296 */
297 template<typename _Iterator>
298 inline _GLIBCXX17_CONSTEXPR bool
299 operator==(const reverse_iterator<_Iterator>& __x,
300 const reverse_iterator<_Iterator>& __y)
301 { return __x.base() == __y.base(); }
46
Assuming the condition is false
58
Assuming the condition is false
70
Assuming the condition is true
302
303 template<typename _Iterator>
304 inline _GLIBCXX17_CONSTEXPR bool
305 operator<(const reverse_iterator<_Iterator>& __x,
306 const reverse_iterator<_Iterator>& __y)
307 { return __y.base() < __x.base(); }
308
309 template<typename _Iterator>
310 inline _GLIBCXX17_CONSTEXPR bool
311 operator!=(const reverse_iterator<_Iterator>& __x,
312 const reverse_iterator<_Iterator>& __y)
313 { return !(__x == __y); }
45
Calling 'operator=='
47
Returning from 'operator=='
57
Calling 'operator=='
59
Returning from 'operator=='
69
Calling 'operator=='
71
Returning from 'operator=='
314
315 template<typename _Iterator>
316 inline _GLIBCXX17_CONSTEXPR bool
317 operator>(const reverse_iterator<_Iterator>& __x,
318 const reverse_iterator<_Iterator>& __y)
319 { return __y < __x; }
320
321 template<typename _Iterator>
322 inline _GLIBCXX17_CONSTEXPR bool
323 operator<=(const reverse_iterator<_Iterator>& __x,
324 const reverse_iterator<_Iterator>& __y)
325 { return !(__y < __x); }
326
327 template<typename _Iterator>
328 inline _GLIBCXX17_CONSTEXPR bool
329 operator>=(const reverse_iterator<_Iterator>& __x,
330 const reverse_iterator<_Iterator>& __y)
331 { return !(__x < __y); }
332
333 // _GLIBCXX_RESOLVE_LIB_DEFECTS
334 // DR 280. Comparison of reverse_iterator to const reverse_iterator.
335 template<typename _IteratorL, typename _IteratorR>
336 inline _GLIBCXX17_CONSTEXPR bool
337 operator==(const reverse_iterator<_IteratorL>& __x,
338 const reverse_iterator<_IteratorR>& __y)
339 { return __x.base() == __y.base(); }
340
341 template<typename _IteratorL, typename _IteratorR>
342 inline _GLIBCXX17_CONSTEXPR bool
343 operator<(const reverse_iterator<_IteratorL>& __x,
344 const reverse_iterator<_IteratorR>& __y)
345 { return __y.base() < __x.base(); }
346
347 template<typename _IteratorL, typename _IteratorR>
348 inline _GLIBCXX17_CONSTEXPR bool
349 operator!=(const reverse_iterator<_IteratorL>& __x,
350 const reverse_iterator<_IteratorR>& __y)
351 { return !(__x == __y); }
352
353 template<typename _IteratorL, typename _IteratorR>
354 inline _GLIBCXX17_CONSTEXPR bool
355 operator>(const reverse_iterator<_IteratorL>& __x,
356 const reverse_iterator<_IteratorR>& __y)
357 { return __y < __x; }
358
359 template<typename _IteratorL, typename _IteratorR>
360 inline _GLIBCXX17_CONSTEXPR bool
361 operator<=(const reverse_iterator<_IteratorL>& __x,
362 const reverse_iterator<_IteratorR>& __y)
363 { return !(__y < __x); }
364
365 template<typename _IteratorL, typename _IteratorR>
366 inline _GLIBCXX17_CONSTEXPR bool
367 operator>=(const reverse_iterator<_IteratorL>& __x,
368 const reverse_iterator<_IteratorR>& __y)
369 { return !(__x < __y); }
370 //@}
371
372#if __cplusplus201103L < 201103L
373 template<typename _Iterator>
374 inline typename reverse_iterator<_Iterator>::difference_type
375 operator-(const reverse_iterator<_Iterator>& __x,
376 const reverse_iterator<_Iterator>& __y)
377 { return __y.base() - __x.base(); }
378
379 template<typename _IteratorL, typename _IteratorR>
380 inline typename reverse_iterator<_IteratorL>::difference_type
381 operator-(const reverse_iterator<_IteratorL>& __x,
382 const reverse_iterator<_IteratorR>& __y)
383 { return __y.base() - __x.base(); }
384#else
385 // _GLIBCXX_RESOLVE_LIB_DEFECTS
386 // DR 685. reverse_iterator/move_iterator difference has invalid signatures
387 template<typename _IteratorL, typename _IteratorR>
388 inline _GLIBCXX17_CONSTEXPR auto
389 operator-(const reverse_iterator<_IteratorL>& __x,
390 const reverse_iterator<_IteratorR>& __y)
391 -> decltype(__y.base() - __x.base())
392 { return __y.base() - __x.base(); }
393#endif
394
395 template<typename _Iterator>
396 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
397 operator+(typename reverse_iterator<_Iterator>::difference_type __n,
398 const reverse_iterator<_Iterator>& __x)
399 { return reverse_iterator<_Iterator>(__x.base() - __n); }
400
401#if __cplusplus201103L >= 201103L
402 // Same as C++14 make_reverse_iterator but used in C++03 mode too.
403 template<typename _Iterator>
404 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
405 __make_reverse_iterator(_Iterator __i)
406 { return reverse_iterator<_Iterator>(__i); }
407
408# if __cplusplus201103L > 201103L
409# define __cpp_lib_make_reverse_iterator 201402
410
411 // _GLIBCXX_RESOLVE_LIB_DEFECTS
412 // DR 2285. make_reverse_iterator
413 /// Generator function for reverse_iterator.
414 template<typename _Iterator>
415 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
416 make_reverse_iterator(_Iterator __i)
417 { return reverse_iterator<_Iterator>(__i); }
418# endif
419#endif
420
421#if __cplusplus201103L >= 201103L
422 template<typename _Iterator>
423 auto
424 __niter_base(reverse_iterator<_Iterator> __it)
425 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
426 { return __make_reverse_iterator(__niter_base(__it.base())); }
427
428 template<typename _Iterator>
429 struct __is_move_iterator<reverse_iterator<_Iterator> >
430 : __is_move_iterator<_Iterator>
431 { };
432
433 template<typename _Iterator>
434 auto
435 __miter_base(reverse_iterator<_Iterator> __it)
436 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
437 { return __make_reverse_iterator(__miter_base(__it.base())); }
438#endif
439
440 // 24.4.2.2.1 back_insert_iterator
441 /**
442 * @brief Turns assignment into insertion.
443 *
444 * These are output iterators, constructed from a container-of-T.
445 * Assigning a T to the iterator appends it to the container using
446 * push_back.
447 *
448 * Tip: Using the back_inserter function to create these iterators can
449 * save typing.
450 */
451 template<typename _Container>
452 class back_insert_iterator
453 : public iterator<output_iterator_tag, void, void, void, void>
454 {
455 protected:
456 _Container* container;
457
458 public:
459 /// A nested typedef for the type of whatever container you used.
460 typedef _Container container_type;
461
462 /// The only way to create this %iterator is with a container.
463 explicit
464 back_insert_iterator(_Container& __x)
465 : container(std::__addressof(__x)) { }
466
467 /**
468 * @param __value An instance of whatever type
469 * container_type::const_reference is; presumably a
470 * reference-to-const T for container<T>.
471 * @return This %iterator, for chained operations.
472 *
473 * This kind of %iterator doesn't really have a @a position in the
474 * container (you can think of the position as being permanently at
475 * the end, if you like). Assigning a value to the %iterator will
476 * always append the value to the end of the container.
477 */
478#if __cplusplus201103L < 201103L
479 back_insert_iterator&
480 operator=(typename _Container::const_reference __value)
481 {
482 container->push_back(__value);
483 return *this;
484 }
485#else
486 back_insert_iterator&
487 operator=(const typename _Container::value_type& __value)
488 {
489 container->push_back(__value);
490 return *this;
491 }
492
493 back_insert_iterator&
494 operator=(typename _Container::value_type&& __value)
495 {
496 container->push_back(std::move(__value));
497 return *this;
498 }
499#endif
500
501 /// Simply returns *this.
502 back_insert_iterator&
503 operator*()
504 { return *this; }
505
506 /// Simply returns *this. (This %iterator does not @a move.)
507 back_insert_iterator&
508 operator++()
509 { return *this; }
510
511 /// Simply returns *this. (This %iterator does not @a move.)
512 back_insert_iterator
513 operator++(int)
514 { return *this; }
515 };
516
517 /**
518 * @param __x A container of arbitrary type.
519 * @return An instance of back_insert_iterator working on @p __x.
520 *
521 * This wrapper function helps in creating back_insert_iterator instances.
522 * Typing the name of the %iterator requires knowing the precise full
523 * type of the container, which can be tedious and impedes generic
524 * programming. Using this function lets you take advantage of automatic
525 * template parameter deduction, making the compiler match the correct
526 * types for you.
527 */
528 template<typename _Container>
529 inline back_insert_iterator<_Container>
530 back_inserter(_Container& __x)
531 { return back_insert_iterator<_Container>(__x); }
532
533 /**
534 * @brief Turns assignment into insertion.
535 *
536 * These are output iterators, constructed from a container-of-T.
537 * Assigning a T to the iterator prepends it to the container using
538 * push_front.
539 *
540 * Tip: Using the front_inserter function to create these iterators can
541 * save typing.
542 */
543 template<typename _Container>
544 class front_insert_iterator
545 : public iterator<output_iterator_tag, void, void, void, void>
546 {
547 protected:
548 _Container* container;
549
550 public:
551 /// A nested typedef for the type of whatever container you used.
552 typedef _Container container_type;
553
554 /// The only way to create this %iterator is with a container.
555 explicit front_insert_iterator(_Container& __x)
556 : container(std::__addressof(__x)) { }
557
558 /**
559 * @param __value An instance of whatever type
560 * container_type::const_reference is; presumably a
561 * reference-to-const T for container<T>.
562 * @return This %iterator, for chained operations.
563 *
564 * This kind of %iterator doesn't really have a @a position in the
565 * container (you can think of the position as being permanently at
566 * the front, if you like). Assigning a value to the %iterator will
567 * always prepend the value to the front of the container.
568 */
569#if __cplusplus201103L < 201103L
570 front_insert_iterator&
571 operator=(typename _Container::const_reference __value)
572 {
573 container->push_front(__value);
574 return *this;
575 }
576#else
577 front_insert_iterator&
578 operator=(const typename _Container::value_type& __value)
579 {
580 container->push_front(__value);
581 return *this;
582 }
583
584 front_insert_iterator&
585 operator=(typename _Container::value_type&& __value)
586 {
587 container->push_front(std::move(__value));
588 return *this;
589 }
590#endif
591
592 /// Simply returns *this.
593 front_insert_iterator&
594 operator*()
595 { return *this; }
596
597 /// Simply returns *this. (This %iterator does not @a move.)
598 front_insert_iterator&
599 operator++()
600 { return *this; }
601
602 /// Simply returns *this. (This %iterator does not @a move.)
603 front_insert_iterator
604 operator++(int)
605 { return *this; }
606 };
607
608 /**
609 * @param __x A container of arbitrary type.
610 * @return An instance of front_insert_iterator working on @p x.
611 *
612 * This wrapper function helps in creating front_insert_iterator instances.
613 * Typing the name of the %iterator requires knowing the precise full
614 * type of the container, which can be tedious and impedes generic
615 * programming. Using this function lets you take advantage of automatic
616 * template parameter deduction, making the compiler match the correct
617 * types for you.
618 */
619 template<typename _Container>
620 inline front_insert_iterator<_Container>
621 front_inserter(_Container& __x)
622 { return front_insert_iterator<_Container>(__x); }
623
624 /**
625 * @brief Turns assignment into insertion.
626 *
627 * These are output iterators, constructed from a container-of-T.
628 * Assigning a T to the iterator inserts it in the container at the
629 * %iterator's position, rather than overwriting the value at that
630 * position.
631 *
632 * (Sequences will actually insert a @e copy of the value before the
633 * %iterator's position.)
634 *
635 * Tip: Using the inserter function to create these iterators can
636 * save typing.
637 */
638 template<typename _Container>
639 class insert_iterator
640 : public iterator<output_iterator_tag, void, void, void, void>
641 {
642 protected:
643 _Container* container;
644 typename _Container::iterator iter;
645
646 public:
647 /// A nested typedef for the type of whatever container you used.
648 typedef _Container container_type;
649
650 /**
651 * The only way to create this %iterator is with a container and an
652 * initial position (a normal %iterator into the container).
653 */
654 insert_iterator(_Container& __x, typename _Container::iterator __i)
655 : container(std::__addressof(__x)), iter(__i) {}
656
657 /**
658 * @param __value An instance of whatever type
659 * container_type::const_reference is; presumably a
660 * reference-to-const T for container<T>.
661 * @return This %iterator, for chained operations.
662 *
663 * This kind of %iterator maintains its own position in the
664 * container. Assigning a value to the %iterator will insert the
665 * value into the container at the place before the %iterator.
666 *
667 * The position is maintained such that subsequent assignments will
668 * insert values immediately after one another. For example,
669 * @code
670 * // vector v contains A and Z
671 *
672 * insert_iterator i (v, ++v.begin());
673 * i = 1;
674 * i = 2;
675 * i = 3;
676 *
677 * // vector v contains A, 1, 2, 3, and Z
678 * @endcode
679 */
680#if __cplusplus201103L < 201103L
681 insert_iterator&
682 operator=(typename _Container::const_reference __value)
683 {
684 iter = container->insert(iter, __value);
685 ++iter;
686 return *this;
687 }
688#else
689 insert_iterator&
690 operator=(const typename _Container::value_type& __value)
691 {
692 iter = container->insert(iter, __value);
693 ++iter;
694 return *this;
695 }
696
697 insert_iterator&
698 operator=(typename _Container::value_type&& __value)
699 {
700 iter = container->insert(iter, std::move(__value));
701 ++iter;
702 return *this;
703 }
704#endif
705
706 /// Simply returns *this.
707 insert_iterator&
708 operator*()
709 { return *this; }
710
711 /// Simply returns *this. (This %iterator does not @a move.)
712 insert_iterator&
713 operator++()
714 { return *this; }
715
716 /// Simply returns *this. (This %iterator does not @a move.)
717 insert_iterator&
718 operator++(int)
719 { return *this; }
720 };
721
722 /**
723 * @param __x A container of arbitrary type.
724 * @return An instance of insert_iterator working on @p __x.
725 *
726 * This wrapper function helps in creating insert_iterator instances.
727 * Typing the name of the %iterator requires knowing the precise full
728 * type of the container, which can be tedious and impedes generic
729 * programming. Using this function lets you take advantage of automatic
730 * template parameter deduction, making the compiler match the correct
731 * types for you.
732 */
733 template<typename _Container, typename _Iterator>
734 inline insert_iterator<_Container>
735 inserter(_Container& __x, _Iterator __i)
736 {
737 return insert_iterator<_Container>(__x,
738 typename _Container::iterator(__i));
739 }
740
741 // @} group iterators
742
743_GLIBCXX_END_NAMESPACE_VERSION
744} // namespace
745
746namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
747{
748_GLIBCXX_BEGIN_NAMESPACE_VERSION
749
750 // This iterator adapter is @a normal in the sense that it does not
751 // change the semantics of any of the operators of its iterator
752 // parameter. Its primary purpose is to convert an iterator that is
753 // not a class, e.g. a pointer, into an iterator that is a class.
754 // The _Container parameter exists solely so that different containers
755 // using this template can instantiate different types, even if the
756 // _Iterator parameter is the same.
757 using std::iterator_traits;
758 using std::iterator;
759 template<typename _Iterator, typename _Container>
760 class __normal_iterator
761 {
762 protected:
763 _Iterator _M_current;
764
765 typedef iterator_traits<_Iterator> __traits_type;
766
767 public:
768 typedef _Iterator iterator_type;
769 typedef typename __traits_type::iterator_category iterator_category;
770 typedef typename __traits_type::value_type value_type;
771 typedef typename __traits_type::difference_type difference_type;
772 typedef typename __traits_type::reference reference;
773 typedef typename __traits_type::pointer pointer;
774
775 _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() _GLIBCXX_NOEXCEPTnoexcept
776 : _M_current(_Iterator()) { }
777
778 explicit
779 __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPTnoexcept
780 : _M_current(__i) { }
781
782 // Allow iterator to const_iterator conversion
783 template<typename _Iter>
784 __normal_iterator(const __normal_iterator<_Iter,
785 typename __enable_if<
786 (std::__are_same<_Iter, typename _Container::pointer>::__value),
787 _Container>::__type>& __i) _GLIBCXX_NOEXCEPTnoexcept
788 : _M_current(__i.base()) { }
789
790 // Forward iterator requirements
791 reference
792 operator*() const _GLIBCXX_NOEXCEPTnoexcept
793 { return *_M_current; }
794
795 pointer
796 operator->() const _GLIBCXX_NOEXCEPTnoexcept
797 { return _M_current; }
798
799 __normal_iterator&
800 operator++() _GLIBCXX_NOEXCEPTnoexcept
801 {
802 ++_M_current;
803 return *this;
804 }
805
806 __normal_iterator
807 operator++(int) _GLIBCXX_NOEXCEPTnoexcept
808 { return __normal_iterator(_M_current++); }
809
810 // Bidirectional iterator requirements
811 __normal_iterator&
812 operator--() _GLIBCXX_NOEXCEPTnoexcept
813 {
814 --_M_current;
815 return *this;
816 }
817
818 __normal_iterator
819 operator--(int) _GLIBCXX_NOEXCEPTnoexcept
820 { return __normal_iterator(_M_current--); }
821
822 // Random access iterator requirements
823 reference
824 operator[](difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
825 { return _M_current[__n]; }
826
827 __normal_iterator&
828 operator+=(difference_type __n) _GLIBCXX_NOEXCEPTnoexcept
829 { _M_current += __n; return *this; }
830
831 __normal_iterator
832 operator+(difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
833 { return __normal_iterator(_M_current + __n); }
834
835 __normal_iterator&
836 operator-=(difference_type __n) _GLIBCXX_NOEXCEPTnoexcept
837 { _M_current -= __n; return *this; }
838
839 __normal_iterator
840 operator-(difference_type __n) const _GLIBCXX_NOEXCEPTnoexcept
841 { return __normal_iterator(_M_current - __n); }
842
843 const _Iterator&
844 base() const _GLIBCXX_NOEXCEPTnoexcept
845 { return _M_current; }
846 };
847
848 // Note: In what follows, the left- and right-hand-side iterators are
849 // allowed to vary in types (conceptually in cv-qualification) so that
850 // comparison between cv-qualified and non-cv-qualified iterators be
851 // valid. However, the greedy and unfriendly operators in std::rel_ops
852 // will make overload resolution ambiguous (when in scope) if we don't
853 // provide overloads whose operands are of the same type. Can someone
854 // remind me what generic programming is about? -- Gaby
855
856 // Forward iterator requirements
857 template<typename _IteratorL, typename _IteratorR, typename _Container>
858 inline bool
859 operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
860 const __normal_iterator<_IteratorR, _Container>& __rhs)
861 _GLIBCXX_NOEXCEPTnoexcept
862 { return __lhs.base() == __rhs.base(); }
863
864 template<typename _Iterator, typename _Container>
865 inline bool
866 operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
867 const __normal_iterator<_Iterator, _Container>& __rhs)
868 _GLIBCXX_NOEXCEPTnoexcept
869 { return __lhs.base() == __rhs.base(); }
870
871 template<typename _IteratorL, typename _IteratorR, typename _Container>
872 inline bool
873 operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
874 const __normal_iterator<_IteratorR, _Container>& __rhs)
875 _GLIBCXX_NOEXCEPTnoexcept
876 { return __lhs.base() != __rhs.base(); }
877
878 template<typename _Iterator, typename _Container>
879 inline bool
880 operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
881 const __normal_iterator<_Iterator, _Container>& __rhs)
882 _GLIBCXX_NOEXCEPTnoexcept
883 { return __lhs.base() != __rhs.base(); }
884
885 // Random access iterator requirements
886 template<typename _IteratorL, typename _IteratorR, typename _Container>
887 inline bool
888 operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
889 const __normal_iterator<_IteratorR, _Container>& __rhs)
890 _GLIBCXX_NOEXCEPTnoexcept
891 { return __lhs.base() < __rhs.base(); }
892
893 template<typename _Iterator, typename _Container>
894 inline bool
895 operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
896 const __normal_iterator<_Iterator, _Container>& __rhs)
897 _GLIBCXX_NOEXCEPTnoexcept
898 { return __lhs.base() < __rhs.base(); }
899
900 template<typename _IteratorL, typename _IteratorR, typename _Container>
901 inline bool
902 operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
903 const __normal_iterator<_IteratorR, _Container>& __rhs)
904 _GLIBCXX_NOEXCEPTnoexcept
905 { return __lhs.base() > __rhs.base(); }
906
907 template<typename _Iterator, typename _Container>
908 inline bool
909 operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
910 const __normal_iterator<_Iterator, _Container>& __rhs)
911 _GLIBCXX_NOEXCEPTnoexcept
912 { return __lhs.base() > __rhs.base(); }
913
914 template<typename _IteratorL, typename _IteratorR, typename _Container>
915 inline bool
916 operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
917 const __normal_iterator<_IteratorR, _Container>& __rhs)
918 _GLIBCXX_NOEXCEPTnoexcept
919 { return __lhs.base() <= __rhs.base(); }
920
921 template<typename _Iterator, typename _Container>
922 inline bool
923 operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
924 const __normal_iterator<_Iterator, _Container>& __rhs)
925 _GLIBCXX_NOEXCEPTnoexcept
926 { return __lhs.base() <= __rhs.base(); }
927
928 template<typename _IteratorL, typename _IteratorR, typename _Container>
929 inline bool
930 operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
931 const __normal_iterator<_IteratorR, _Container>& __rhs)
932 _GLIBCXX_NOEXCEPTnoexcept
933 { return __lhs.base() >= __rhs.base(); }
934
935 template<typename _Iterator, typename _Container>
936 inline bool
937 operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
938 const __normal_iterator<_Iterator, _Container>& __rhs)
939 _GLIBCXX_NOEXCEPTnoexcept
940 { return __lhs.base() >= __rhs.base(); }
941
942 // _GLIBCXX_RESOLVE_LIB_DEFECTS
943 // According to the resolution of DR179 not only the various comparison
944 // operators but also operator- must accept mixed iterator/const_iterator
945 // parameters.
946 template<typename _IteratorL, typename _IteratorR, typename _Container>
947#if __cplusplus201103L >= 201103L
948 // DR 685.
949 inline auto
950 operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
951 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
952 -> decltype(__lhs.base() - __rhs.base())
953#else
954 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
955 operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
956 const __normal_iterator<_IteratorR, _Container>& __rhs)
957#endif
958 { return __lhs.base() - __rhs.base(); }
959
960 template<typename _Iterator, typename _Container>
961 inline typename __normal_iterator<_Iterator, _Container>::difference_type
962 operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
963 const __normal_iterator<_Iterator, _Container>& __rhs)
964 _GLIBCXX_NOEXCEPTnoexcept
965 { return __lhs.base() - __rhs.base(); }
966
967 template<typename _Iterator, typename _Container>
968 inline __normal_iterator<_Iterator, _Container>
969 operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
970 __n, const __normal_iterator<_Iterator, _Container>& __i)
971 _GLIBCXX_NOEXCEPTnoexcept
972 { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
973
974_GLIBCXX_END_NAMESPACE_VERSION
975} // namespace
976
977namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
978{
979_GLIBCXX_BEGIN_NAMESPACE_VERSION
980
981 template<typename _Iterator, typename _Container>
982 _Iterator
983 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
984 { return __it.base(); }
985
986_GLIBCXX_END_NAMESPACE_VERSION
987} // namespace
988
989#if __cplusplus201103L >= 201103L
990
991namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
992{
993_GLIBCXX_BEGIN_NAMESPACE_VERSION
994
995 /**
996 * @addtogroup iterators
997 * @{
998 */
999
1000 // 24.4.3 Move iterators
1001 /**
1002 * Class template move_iterator is an iterator adapter with the same
1003 * behavior as the underlying iterator except that its dereference
1004 * operator implicitly converts the value returned by the underlying
1005 * iterator's dereference operator to an rvalue reference. Some
1006 * generic algorithms can be called with move iterators to replace
1007 * copying with moving.
1008 */
1009 template<typename _Iterator>
1010 class move_iterator
1011 {
1012 protected:
1013 _Iterator _M_current;
1014
1015 typedef iterator_traits<_Iterator> __traits_type;
1016 typedef typename __traits_type::reference __base_ref;
1017
1018 public:
1019 typedef _Iterator iterator_type;
1020 typedef typename __traits_type::iterator_category iterator_category;
1021 typedef typename __traits_type::value_type value_type;
1022 typedef typename __traits_type::difference_type difference_type;
1023 // NB: DR 680.
1024 typedef _Iterator pointer;
1025 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1026 // 2106. move_iterator wrapping iterators returning prvalues
1027 typedef typename conditional<is_reference<__base_ref>::value,
1028 typename remove_reference<__base_ref>::type&&,
1029 __base_ref>::type reference;
1030
1031 _GLIBCXX17_CONSTEXPR
1032 move_iterator()
1033 : _M_current() { }
1034
1035 explicit _GLIBCXX17_CONSTEXPR
1036 move_iterator(iterator_type __i)
1037 : _M_current(__i) { }
1038
1039 template<typename _Iter>
1040 _GLIBCXX17_CONSTEXPR
1041 move_iterator(const move_iterator<_Iter>& __i)
1042 : _M_current(__i.base()) { }
1043
1044 _GLIBCXX17_CONSTEXPR iterator_type
1045 base() const
1046 { return _M_current; }
1047
1048 _GLIBCXX17_CONSTEXPR reference
1049 operator*() const
1050 { return static_cast<reference>(*_M_current); }
1051
1052 _GLIBCXX17_CONSTEXPR pointer
1053 operator->() const
1054 { return _M_current; }
1055
1056 _GLIBCXX17_CONSTEXPR move_iterator&
1057 operator++()
1058 {
1059 ++_M_current;
1060 return *this;
1061 }
1062
1063 _GLIBCXX17_CONSTEXPR move_iterator
1064 operator++(int)
1065 {
1066 move_iterator __tmp = *this;
1067 ++_M_current;
1068 return __tmp;
1069 }
1070
1071 _GLIBCXX17_CONSTEXPR move_iterator&
1072 operator--()
1073 {
1074 --_M_current;
1075 return *this;
1076 }
1077
1078 _GLIBCXX17_CONSTEXPR move_iterator
1079 operator--(int)
1080 {
1081 move_iterator __tmp = *this;
1082 --_M_current;
1083 return __tmp;
1084 }
1085
1086 _GLIBCXX17_CONSTEXPR move_iterator
1087 operator+(difference_type __n) const
1088 { return move_iterator(_M_current + __n); }
1089
1090 _GLIBCXX17_CONSTEXPR move_iterator&
1091 operator+=(difference_type __n)
1092 {
1093 _M_current += __n;
1094 return *this;
1095 }
1096
1097 _GLIBCXX17_CONSTEXPR move_iterator
1098 operator-(difference_type __n) const
1099 { return move_iterator(_M_current - __n); }
1100
1101 _GLIBCXX17_CONSTEXPR move_iterator&
1102 operator-=(difference_type __n)
1103 {
1104 _M_current -= __n;
1105 return *this;
1106 }
1107
1108 _GLIBCXX17_CONSTEXPR reference
1109 operator[](difference_type __n) const
1110 { return std::move(_M_current[__n]); }
1111 };
1112
1113 // Note: See __normal_iterator operators note from Gaby to understand
1114 // why there are always 2 versions for most of the move_iterator
1115 // operators.
1116 template<typename _IteratorL, typename _IteratorR>
1117 inline _GLIBCXX17_CONSTEXPR bool
1118 operator==(const move_iterator<_IteratorL>& __x,
1119 const move_iterator<_IteratorR>& __y)
1120 { return __x.base() == __y.base(); }
1121
1122 template<typename _Iterator>
1123 inline _GLIBCXX17_CONSTEXPR bool
1124 operator==(const move_iterator<_Iterator>& __x,
1125 const move_iterator<_Iterator>& __y)
1126 { return __x.base() == __y.base(); }
1127
1128 template<typename _IteratorL, typename _IteratorR>
1129 inline _GLIBCXX17_CONSTEXPR bool
1130 operator!=(const move_iterator<_IteratorL>& __x,
1131 const move_iterator<_IteratorR>& __y)
1132 { return !(__x == __y); }
1133
1134 template<typename _Iterator>
1135 inline _GLIBCXX17_CONSTEXPR bool
1136 operator!=(const move_iterator<_Iterator>& __x,
1137 const move_iterator<_Iterator>& __y)
1138 { return !(__x == __y); }
1139
1140 template<typename _IteratorL, typename _IteratorR>
1141 inline _GLIBCXX17_CONSTEXPR bool
1142 operator<(const move_iterator<_IteratorL>& __x,
1143 const move_iterator<_IteratorR>& __y)
1144 { return __x.base() < __y.base(); }
1145
1146 template<typename _Iterator>
1147 inline _GLIBCXX17_CONSTEXPR bool
1148 operator<(const move_iterator<_Iterator>& __x,
1149 const move_iterator<_Iterator>& __y)
1150 { return __x.base() < __y.base(); }
1151
1152 template<typename _IteratorL, typename _IteratorR>
1153 inline _GLIBCXX17_CONSTEXPR bool
1154 operator<=(const move_iterator<_IteratorL>& __x,
1155 const move_iterator<_IteratorR>& __y)
1156 { return !(__y < __x); }
1157
1158 template<typename _Iterator>
1159 inline _GLIBCXX17_CONSTEXPR bool
1160 operator<=(