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