contrib/llvm/tools/clang/lib/Sema/Sema.cpp

   1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
   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 the actions class which performs semantic analysis and
  11 // builds an AST out of a parse stream.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Sema/SemaInternal.h"
  16 #include "clang/Sema/DelayedDiagnostic.h"
  17 #include "TargetAttributesSema.h"
  18 #include "llvm/ADT/DenseMap.h"
  19 #include "llvm/ADT/SmallSet.h"
  20 #include "llvm/ADT/APFloat.h"
  21 #include "llvm/Support/CrashRecoveryContext.h"
  22 #include "clang/Sema/CXXFieldCollector.h"
  23 #include "clang/Sema/TemplateDeduction.h"
  24 #include "clang/Sema/ExternalSemaSource.h"
  25 #include "clang/Sema/MultiplexExternalSemaSource.h"
  26 #include "clang/Sema/ObjCMethodList.h"
  27 #include "clang/Sema/PrettyDeclStackTrace.h"
  28 #include "clang/Sema/Scope.h"
  29 #include "clang/Sema/ScopeInfo.h"
  30 #include "clang/Sema/SemaConsumer.h"
  31 #include "clang/AST/ASTContext.h"
  32 #include "clang/AST/ASTDiagnostic.h"
  33 #include "clang/AST/DeclCXX.h"
  34 #include "clang/AST/DeclFriend.h"
  35 #include "clang/AST/DeclObjC.h"
  36 #include "clang/AST/Expr.h"
  37 #include "clang/AST/ExprCXX.h"
  38 #include "clang/AST/StmtCXX.h"
  39 #include "clang/Lex/HeaderSearch.h"
  40 #include "clang/Lex/Preprocessor.h"
  41 #include "clang/Basic/FileManager.h"
  42 #include "clang/Basic/PartialDiagnostic.h"
  43 #include "clang/Basic/TargetInfo.h"
  44 using namespace clang;
  45 using namespace sema;
  46
  47 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
  48                                        const Preprocessor &PP) {
  49   PrintingPolicy Policy = Context.getPrintingPolicy();
  50   Policy.Bool = Context.getLangOpts().Bool;
  51   if (!Policy.Bool) {
  52     if (MacroInfo *BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) {
  53       Policy.Bool = BoolMacro->isObjectLike() &&
  54         BoolMacro->getNumTokens() == 1 &&
  55         BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
  56     }
  57   }
  58
  59   return Policy;
  60 }
  61
  62 void Sema::ActOnTranslationUnitScope(Scope *S) {
  63   TUScope = S;
  64   PushDeclContext(S, Context.getTranslationUnitDecl());
  65
  66   VAListTagName = PP.getIdentifierInfo("__va_list_tag");
  67 }
  68
  69 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
  70            TranslationUnitKind TUKind,
  71            CodeCompleteConsumer *CodeCompleter)
  72   : TheTargetAttributesSema(0), ExternalSource(0),
  73     isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()),
  74     LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer),
  75     Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
  76     CollectStats(false), CodeCompleter(CodeCompleter),
  77     CurContext(0), OriginalLexicalContext(0),
  78     PackContext(0), MSStructPragmaOn(false), VisContext(0),
  79     IsBuildingRecoveryCallExpr(false),
  80     ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
  81     IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
  82     NSNumberDecl(0),
  83     NSStringDecl(0), StringWithUTF8StringMethod(0),
  84     NSArrayDecl(0), ArrayWithObjectsMethod(0),
  85     NSDictionaryDecl(0), DictionaryWithObjectsMethod(0),
  86     GlobalNewDeleteDeclared(false),
  87     TUKind(TUKind),
  88     NumSFINAEErrors(0), InFunctionDeclarator(0),
  89     AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
  90     NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
  91     CurrentInstantiationScope(0), TyposCorrected(0),
  92     AnalysisWarnings(*this)
  93 {
  94   TUScope = 0;
  95
  96   LoadedExternalKnownNamespaces = false;
  97   for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
  98     NSNumberLiteralMethods[I] = 0;
  99
 100   if (getLangOpts().ObjC1)
 101     NSAPIObj.reset(new NSAPI(Context));
 102
 103   if (getLangOpts().CPlusPlus)
 104     FieldCollector.reset(new CXXFieldCollector());
 105
 106   // Tell diagnostics how to render things from the AST library.
 107   PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
 108                                        &Context);
 109
 110   ExprEvalContexts.push_back(
 111         ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
 112                                           false, 0, false));
 113
 114   FunctionScopes.push_back(new FunctionScopeInfo(Diags));
 115 }
 116
 117 void Sema::Initialize() {
 118   // Tell the AST consumer about this Sema object.
 119   Consumer.Initialize(Context);
 120
 121   // FIXME: Isn't this redundant with the initialization above?
 122   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
 123     SC->InitializeSema(*this);
 124
 125   // Tell the external Sema source about this Sema object.
 126   if (ExternalSemaSource *ExternalSema
 127       = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
 128     ExternalSema->InitializeSema(*this);
 129
 130   // Initialize predefined 128-bit integer types, if needed.
 131   if (PP.getTargetInfo().getPointerWidth(0) >= 64) {
 132     // If either of the 128-bit integer types are unavailable to name lookup,
 133     // define them now.
 134     DeclarationName Int128 = &Context.Idents.get("__int128_t");
 135     if (IdResolver.begin(Int128) == IdResolver.end())
 136       PushOnScopeChains(Context.getInt128Decl(), TUScope);
 137
 138     DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
 139     if (IdResolver.begin(UInt128) == IdResolver.end())
 140       PushOnScopeChains(Context.getUInt128Decl(), TUScope);
 141   }
 142
 143
 144   // Initialize predefined Objective-C types:
 145   if (PP.getLangOpts().ObjC1) {
 146     // If 'SEL' does not yet refer to any declarations, make it refer to the
 147     // predefined 'SEL'.
 148     DeclarationName SEL = &Context.Idents.get("SEL");
 149     if (IdResolver.begin(SEL) == IdResolver.end())
 150       PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
 151
 152     // If 'id' does not yet refer to any declarations, make it refer to the
 153     // predefined 'id'.
 154     DeclarationName Id = &Context.Idents.get("id");
 155     if (IdResolver.begin(Id) == IdResolver.end())
 156       PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
 157
 158     // Create the built-in typedef for 'Class'.
 159     DeclarationName Class = &Context.Idents.get("Class");
 160     if (IdResolver.begin(Class) == IdResolver.end())
 161       PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
 162
 163     // Create the built-in forward declaratino for 'Protocol'.
 164     DeclarationName Protocol = &Context.Idents.get("Protocol");
 165     if (IdResolver.begin(Protocol) == IdResolver.end())
 166       PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
 167   }
 168
 169   DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
 170   if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
 171     PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
 172 }
 173
 174 Sema::~Sema() {
 175   if (PackContext) FreePackedContext();
 176   if (VisContext) FreeVisContext();
 177   delete TheTargetAttributesSema;
 178   MSStructPragmaOn = false;
 179   // Kill all the active scopes.
 180   for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
 181     delete FunctionScopes[I];
 182   if (FunctionScopes.size() == 1)
 183     delete FunctionScopes[0];
 184
 185   // Tell the SemaConsumer to forget about us; we're going out of scope.
 186   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
 187     SC->ForgetSema();
 188
 189   // Detach from the external Sema source.
 190   if (ExternalSemaSource *ExternalSema
 191         = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
 192     ExternalSema->ForgetSema();
 193
 194   // If Sema's ExternalSource is the multiplexer - we own it.
 195   if (isMultiplexExternalSource)
 196     delete ExternalSource;
 197 }
 198
 199 /// makeUnavailableInSystemHeader - There is an error in the current
 200 /// context.  If we're still in a system header, and we can plausibly
 201 /// make the relevant declaration unavailable instead of erroring, do
 202 /// so and return true.
 203 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
 204                                          StringRef msg) {
 205   // If we're not in a function, it's an error.
 206   FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
 207   if (!fn) return false;
 208
 209   // If we're in template instantiation, it's an error.
 210   if (!ActiveTemplateInstantiations.empty())
 211     return false;
 212
 213   // If that function's not in a system header, it's an error.
 214   if (!Context.getSourceManager().isInSystemHeader(loc))
 215     return false;
 216
 217   // If the function is already unavailable, it's not an error.
 218   if (fn->hasAttr<UnavailableAttr>()) return true;
 219
 220   fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
 221   return true;
 222 }
 223
 224 ASTMutationListener *Sema::getASTMutationListener() const {
 225   return getASTConsumer().GetASTMutationListener();
 226 }
 227
 228 ///\brief Registers an external source. If an external source already exists,
 229 /// creates a multiplex external source and appends to it.
 230 ///
 231 ///\param[in] E - A non-null external sema source.
 232 ///
 233 void Sema::addExternalSource(ExternalSemaSource *E) {
 234   assert(E && "Cannot use with NULL ptr");
 235
 236   if (!ExternalSource) {
 237     ExternalSource = E;
 238     return;
 239   }
 240
 241   if (isMultiplexExternalSource)
 242     static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
 243   else {
 244     ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
 245     isMultiplexExternalSource = true;
 246   }
 247 }
 248
 249 /// \brief Print out statistics about the semantic analysis.
 250 void Sema::PrintStats() const {
 251   llvm::errs() << "\n*** Semantic Analysis Stats:\n";
 252   llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
 253
 254   BumpAlloc.PrintStats();
 255   AnalysisWarnings.PrintStats();
 256 }
 257
 258 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
 259 /// If there is already an implicit cast, merge into the existing one.
 260 /// The result is of the given category.
 261 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
 262                                    CastKind Kind, ExprValueKind VK,
 263                                    const CXXCastPath *BasePath,
 264                                    CheckedConversionKind CCK) {
 265 #ifndef NDEBUG
 266   if (VK == VK_RValue && !E->isRValue()) {
 267     switch (Kind) {
 268     default:
 269       assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
 270     case CK_LValueToRValue:
 271     case CK_ArrayToPointerDecay:
 272     case CK_FunctionToPointerDecay:
 273     case CK_ToVoid:
 274       break;
 275     }
 276   }
 277   assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
 278 #endif
 279
 280   QualType ExprTy = Context.getCanonicalType(E->getType());
 281   QualType TypeTy = Context.getCanonicalType(Ty);
 282
 283   if (ExprTy == TypeTy)
 284     return Owned(E);
 285
 286   if (getLangOpts().ObjCAutoRefCount)
 287     CheckObjCARCConversion(SourceRange(), Ty, E, CCK);
 288
 289   // If this is a derived-to-base cast to a through a virtual base, we
 290   // need a vtable.
 291   if (Kind == CK_DerivedToBase &&
 292       BasePathInvolvesVirtualBase(*BasePath)) {
 293     QualType T = E->getType();
 294     if (const PointerType *Pointer = T->getAs<PointerType>())
 295       T = Pointer->getPointeeType();
 296     if (const RecordType *RecordTy = T->getAs<RecordType>())
 297       MarkVTableUsed(E->getLocStart(),
 298                      cast<CXXRecordDecl>(RecordTy->getDecl()));
 299   }
 300
 301   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
 302     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
 303       ImpCast->setType(Ty);
 304       ImpCast->setValueKind(VK);
 305       return Owned(E);
 306     }
 307   }
 308
 309   return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
 310 }
 311
 312 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
 313 /// to the conversion from scalar type ScalarTy to the Boolean type.
 314 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
 315   switch (ScalarTy->getScalarTypeKind()) {
 316   case Type::STK_Bool: return CK_NoOp;
 317   case Type::STK_CPointer: return CK_PointerToBoolean;
 318   case Type::STK_BlockPointer: return CK_PointerToBoolean;
 319   case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
 320   case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
 321   case Type::STK_Integral: return CK_IntegralToBoolean;
 322   case Type::STK_Floating: return CK_FloatingToBoolean;
 323   case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
 324   case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
 325   }
 326   return CK_Invalid;
 327 }
 328
 329 /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
 330 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
 331   if (D->isUsed())
 332     return true;
 333
 334   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 335     // UnusedFileScopedDecls stores the first declaration.
 336     // The declaration may have become definition so check again.
 337     const FunctionDecl *DeclToCheck;
 338     if (FD->hasBody(DeclToCheck))
 339       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 340
 341     // Later redecls may add new information resulting in not having to warn,
 342     // so check again.
 343     DeclToCheck = FD->getMostRecentDecl();
 344     if (DeclToCheck != FD)
 345       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 346   }
 347
 348   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
 349     // UnusedFileScopedDecls stores the first declaration.
 350     // The declaration may have become definition so check again.
 351     const VarDecl *DeclToCheck = VD->getDefinition();
 352     if (DeclToCheck)
 353       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 354
 355     // Later redecls may add new information resulting in not having to warn,
 356     // so check again.
 357     DeclToCheck = VD->getMostRecentDecl();
 358     if (DeclToCheck != VD)
 359       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 360   }
 361
 362   return false;
 363 }
 364
 365 namespace {
 366   struct UndefinedInternal {
 367     NamedDecl *decl;
 368     FullSourceLoc useLoc;
 369
 370     UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc)
 371       : decl(decl), useLoc(useLoc) {}
 372   };
 373
 374   bool operator<(const UndefinedInternal &l, const UndefinedInternal &r) {
 375     return l.useLoc.isBeforeInTranslationUnitThan(r.useLoc);
 376   }
 377 }
 378
 379 /// checkUndefinedInternals - Check for undefined objects with internal linkage.
 380 static void checkUndefinedInternals(Sema &S) {
 381   if (S.UndefinedInternals.empty()) return;
 382
 383   // Collect all the still-undefined entities with internal linkage.
 384   SmallVector<UndefinedInternal, 16> undefined;
 385   for (llvm::DenseMap<NamedDecl*,SourceLocation>::iterator
 386          i = S.UndefinedInternals.begin(), e = S.UndefinedInternals.end();
 387        i != e; ++i) {
 388     NamedDecl *decl = i->first;
 389
 390     // Ignore attributes that have become invalid.
 391     if (decl->isInvalidDecl()) continue;
 392
 393     // __attribute__((weakref)) is basically a definition.
 394     if (decl->hasAttr<WeakRefAttr>()) continue;
 395
 396     if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) {
 397       if (fn->isPure() || fn->hasBody())
 398         continue;
 399     } else {
 400       if (cast<VarDecl>(decl)->hasDefinition() != VarDecl::DeclarationOnly)
 401         continue;
 402     }
 403
 404     // We build a FullSourceLoc so that we can sort with array_pod_sort.
 405     FullSourceLoc loc(i->second, S.Context.getSourceManager());
 406     undefined.push_back(UndefinedInternal(decl, loc));
 407   }
 408
 409   if (undefined.empty()) return;
 410
 411   // Sort (in order of use site) so that we're not (as) dependent on
 412   // the iteration order through an llvm::DenseMap.
 413   llvm::array_pod_sort(undefined.begin(), undefined.end());
 414
 415   for (SmallVectorImpl<UndefinedInternal>::iterator
 416          i = undefined.begin(), e = undefined.end(); i != e; ++i) {
 417     NamedDecl *decl = i->decl;
 418     S.Diag(decl->getLocation(), diag::warn_undefined_internal)
 419       << isa<VarDecl>(decl) << decl;
 420     S.Diag(i->useLoc, diag::note_used_here);
 421   }
 422 }
 423
 424 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
 425   if (!ExternalSource)
 426     return;
 427
 428   SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
 429   ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
 430   for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) {
 431     llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos
 432       = WeakUndeclaredIdentifiers.find(WeakIDs[I].first);
 433     if (Pos != WeakUndeclaredIdentifiers.end())
 434       continue;
 435
 436     WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
 437   }
 438 }
 439
 440
 441 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
 442
 443 /// \brief Returns true, if all methods and nested classes of the given
 444 /// CXXRecordDecl are defined in this translation unit.
 445 ///
 446 /// Should only be called from ActOnEndOfTranslationUnit so that all
 447 /// definitions are actually read.
 448 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
 449                                             RecordCompleteMap &MNCComplete) {
 450   RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
 451   if (Cache != MNCComplete.end())
 452     return Cache->second;
 453   if (!RD->isCompleteDefinition())
 454     return false;
 455   bool Complete = true;
 456   for (DeclContext::decl_iterator I = RD->decls_begin(),
 457                                   E = RD->decls_end();
 458        I != E && Complete; ++I) {
 459     if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
 460       Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
 461     else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
 462       Complete = F->getTemplatedDecl()->isDefined();
 463     else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
 464       if (R->isInjectedClassName())
 465         continue;
 466       if (R->hasDefinition())
 467         Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
 468                                                    MNCComplete);
 469       else
 470         Complete = false;
 471     }
 472   }
 473   MNCComplete[RD] = Complete;
 474   return Complete;
 475 }
 476
 477 /// \brief Returns true, if the given CXXRecordDecl is fully defined in this
 478 /// translation unit, i.e. all methods are defined or pure virtual and all
 479 /// friends, friend functions and nested classes are fully defined in this
 480 /// translation unit.
 481 ///
 482 /// Should only be called from ActOnEndOfTranslationUnit so that all
 483 /// definitions are actually read.
 484 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
 485                                  RecordCompleteMap &RecordsComplete,
 486                                  RecordCompleteMap &MNCComplete) {
 487   RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
 488   if (Cache != RecordsComplete.end())
 489     return Cache->second;
 490   bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
 491   for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
 492                                       E = RD->friend_end();
 493        I != E && Complete; ++I) {
 494     // Check if friend classes and methods are complete.
 495     if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
 496       // Friend classes are available as the TypeSourceInfo of the FriendDecl.
 497       if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
 498         Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
 499       else
 500         Complete = false;
 501     } else {
 502       // Friend functions are available through the NamedDecl of FriendDecl.
 503       if (const FunctionDecl *FD =
 504           dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
 505         Complete = FD->isDefined();
 506       else
 507         // This is a template friend, give up.
 508         Complete = false;
 509     }
 510   }
 511   RecordsComplete[RD] = Complete;
 512   return Complete;
 513 }
 514
 515 /// ActOnEndOfTranslationUnit - This is called at the very end of the
 516 /// translation unit when EOF is reached and all but the top-level scope is
 517 /// popped.
 518 void Sema::ActOnEndOfTranslationUnit() {
 519   assert(DelayedDiagnostics.getCurrentPool() == NULL
 520          && "reached end of translation unit with a pool attached?");
 521
 522   // If code completion is enabled, don't perform any end-of-translation-unit
 523   // work.
 524   if (PP.isCodeCompletionEnabled())
 525     return;
 526
 527   // Only complete translation units define vtables and perform implicit
 528   // instantiations.
 529   if (TUKind == TU_Complete) {
 530     DiagnoseUseOfUnimplementedSelectors();
 531
 532     // If any dynamic classes have their key function defined within
 533     // this translation unit, then those vtables are considered "used" and must
 534     // be emitted.
 535     for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
 536                                       E = DynamicClasses.end();
 537          I != E; ++I) {
 538       assert(!(*I)->isDependentType() &&
 539              "Should not see dependent types here!");
 540       if (const CXXMethodDecl *KeyFunction = Context.getKeyFunction(*I)) {
 541         const FunctionDecl *Definition = 0;
 542         if (KeyFunction->hasBody(Definition))
 543           MarkVTableUsed(Definition->getLocation(), *I, true);
 544       }
 545     }
 546
 547     // If DefinedUsedVTables ends up marking any virtual member functions it
 548     // might lead to more pending template instantiations, which we then need
 549     // to instantiate.
 550     DefineUsedVTables();
 551
 552     // C++: Perform implicit template instantiations.
 553     //
 554     // FIXME: When we perform these implicit instantiations, we do not
 555     // carefully keep track of the point of instantiation (C++ [temp.point]).
 556     // This means that name lookup that occurs within the template
 557     // instantiation will always happen at the end of the translation unit,
 558     // so it will find some names that should not be found. Although this is
 559     // common behavior for C++ compilers, it is technically wrong. In the
 560     // future, we either need to be able to filter the results of name lookup
 561     // or we need to perform template instantiations earlier.
 562     PerformPendingInstantiations();
 563   }
 564
 565   // Remove file scoped decls that turned out to be used.
 566   UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(0,
 567                                                                          true),
 568                                              UnusedFileScopedDecls.end(),
 569                               std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
 570                                            this)),
 571                               UnusedFileScopedDecls.end());
 572
 573   if (TUKind == TU_Prefix) {
 574     // Translation unit prefixes don't need any of the checking below.
 575     TUScope = 0;
 576     return;
 577   }
 578
 579   // Check for #pragma weak identifiers that were never declared
 580   // FIXME: This will cause diagnostics to be emitted in a non-determinstic
 581   // order!  Iterating over a densemap like this is bad.
 582   LoadExternalWeakUndeclaredIdentifiers();
 583   for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
 584        I = WeakUndeclaredIdentifiers.begin(),
 585        E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
 586     if (I->second.getUsed()) continue;
 587
 588     Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
 589       << I->first;
 590   }
 591
 592   if (TUKind == TU_Module) {
 593     // If we are building a module, resolve all of the exported declarations
 594     // now.
 595     if (Module *CurrentModule = PP.getCurrentModule()) {
 596       ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
 597
 598       llvm::SmallVector<Module *, 2> Stack;
 599       Stack.push_back(CurrentModule);
 600       while (!Stack.empty()) {
 601         Module *Mod = Stack.back();
 602         Stack.pop_back();
 603
 604         // Resolve the exported declarations.
 605         // FIXME: Actually complain, once we figure out how to teach the
 606         // diagnostic client to deal with complains in the module map at this
 607         // point.
 608         ModMap.resolveExports(Mod, /*Complain=*/false);
 609
 610         // Queue the submodules, so their exports will also be resolved.
 611         for (Module::submodule_iterator Sub = Mod->submodule_begin(),
 612                                      SubEnd = Mod->submodule_end();
 613              Sub != SubEnd; ++Sub) {
 614           Stack.push_back(*Sub);
 615         }
 616       }
 617     }
 618
 619     // Modules don't need any of the checking below.
 620     TUScope = 0;
 621     return;
 622   }
 623
 624   // C99 6.9.2p2:
 625   //   A declaration of an identifier for an object that has file
 626   //   scope without an initializer, and without a storage-class
 627   //   specifier or with the storage-class specifier static,
 628   //   constitutes a tentative definition. If a translation unit
 629   //   contains one or more tentative definitions for an identifier,
 630   //   and the translation unit contains no external definition for
 631   //   that identifier, then the behavior is exactly as if the
 632   //   translation unit contains a file scope declaration of that
 633   //   identifier, with the composite type as of the end of the
 634   //   translation unit, with an initializer equal to 0.
 635   llvm::SmallSet<VarDecl *, 32> Seen;
 636   for (TentativeDefinitionsType::iterator
 637             T = TentativeDefinitions.begin(ExternalSource),
 638          TEnd = TentativeDefinitions.end();
 639        T != TEnd; ++T)
 640   {
 641     VarDecl *VD = (*T)->getActingDefinition();
 642
 643     // If the tentative definition was completed, getActingDefinition() returns
 644     // null. If we've already seen this variable before, insert()'s second
 645     // return value is false.
 646     if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
 647       continue;
 648
 649     if (const IncompleteArrayType *ArrayT
 650         = Context.getAsIncompleteArrayType(VD->getType())) {
 651       if (RequireCompleteType(VD->getLocation(),
 652                               ArrayT->getElementType(),
 653                               diag::err_tentative_def_incomplete_type_arr)) {
 654         VD->setInvalidDecl();
 655         continue;
 656       }
 657
 658       // Set the length of the array to 1 (C99 6.9.2p5).
 659       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
 660       llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
 661       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
 662                                                 One, ArrayType::Normal, 0);
 663       VD->setType(T);
 664     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
 665                                    diag::err_tentative_def_incomplete_type))
 666       VD->setInvalidDecl();
 667
 668     CheckCompleteVariableDeclaration(VD);
 669
 670     // Notify the consumer that we've completed a tentative definition.
 671     if (!VD->isInvalidDecl())
 672       Consumer.CompleteTentativeDefinition(VD);
 673
 674   }
 675
 676   if (LangOpts.CPlusPlus0x &&
 677       Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
 678                                SourceLocation())
 679         != DiagnosticsEngine::Ignored)
 680     CheckDelegatingCtorCycles();
 681
 682   // If there were errors, disable 'unused' warnings since they will mostly be
 683   // noise.
 684   if (!Diags.hasErrorOccurred()) {
 685     // Output warning for unused file scoped decls.
 686     for (UnusedFileScopedDeclsType::iterator
 687            I = UnusedFileScopedDecls.begin(ExternalSource),
 688            E = UnusedFileScopedDecls.end(); I != E; ++I) {
 689       if (ShouldRemoveFromUnused(this, *I))
 690         continue;
 691
 692       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
 693         const FunctionDecl *DiagD;
 694         if (!FD->hasBody(DiagD))
 695           DiagD = FD;
 696         if (DiagD->isDeleted())
 697           continue; // Deleted functions are supposed to be unused.
 698         if (DiagD->isReferenced()) {
 699           if (isa<CXXMethodDecl>(DiagD))
 700             Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
 701                   << DiagD->getDeclName();
 702           else {
 703             if (FD->getStorageClassAsWritten() == SC_Static &&
 704                 !FD->isInlineSpecified() &&
 705                 !SourceMgr.isFromMainFile(
 706                    SourceMgr.getExpansionLoc(FD->getLocation())))
 707               Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl)
 708                 << DiagD->getDeclName();
 709             else
 710               Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
 711                    << /*function*/0 << DiagD->getDeclName();
 712           }
 713         } else {
 714           Diag(DiagD->getLocation(),
 715                isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
 716                                          : diag::warn_unused_function)
 717                 << DiagD->getDeclName();
 718         }
 719       } else {
 720         const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
 721         if (!DiagD)
 722           DiagD = cast<VarDecl>(*I);
 723         if (DiagD->isReferenced()) {
 724           Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
 725                 << /*variable*/1 << DiagD->getDeclName();
 726         } else {
 727           Diag(DiagD->getLocation(), diag::warn_unused_variable)
 728                 << DiagD->getDeclName();
 729         }
 730       }
 731     }
 732
 733     checkUndefinedInternals(*this);
 734   }
 735
 736   if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
 737                                SourceLocation())
 738         != DiagnosticsEngine::Ignored) {
 739     RecordCompleteMap RecordsComplete;
 740     RecordCompleteMap MNCComplete;
 741     for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
 742          E = UnusedPrivateFields.end(); I != E; ++I) {
 743       const NamedDecl *D = *I;
 744       const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
 745       if (RD && !RD->isUnion() &&
 746           IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
 747         Diag(D->getLocation(), diag::warn_unused_private_field)
 748               << D->getDeclName();
 749       }
 750     }
 751   }
 752
 753   // Check we've noticed that we're no longer parsing the initializer for every
 754   // variable. If we miss cases, then at best we have a performance issue and
 755   // at worst a rejects-valid bug.
 756   assert(ParsingInitForAutoVars.empty() &&
 757          "Didn't unmark var as having its initializer parsed");
 758
 759   TUScope = 0;
 760 }
 761
 762
 763 //===----------------------------------------------------------------------===//
 764 // Helper functions.
 765 //===----------------------------------------------------------------------===//
 766
 767 DeclContext *Sema::getFunctionLevelDeclContext() {
 768   DeclContext *DC = CurContext;
 769
 770   while (true) {
 771     if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC)) {
 772       DC = DC->getParent();
 773     } else if (isa<CXXMethodDecl>(DC) &&
 774                cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
 775                cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
 776       DC = DC->getParent()->getParent();
 777     }
 778     else break;
 779   }
 780
 781   return DC;
 782 }
 783
 784 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
 785 /// to the function decl for the function being parsed.  If we're currently
 786 /// in a 'block', this returns the containing context.
 787 FunctionDecl *Sema::getCurFunctionDecl() {
 788   DeclContext *DC = getFunctionLevelDeclContext();
 789   return dyn_cast<FunctionDecl>(DC);
 790 }
 791
 792 ObjCMethodDecl *Sema::getCurMethodDecl() {
 793   DeclContext *DC = getFunctionLevelDeclContext();
 794   return dyn_cast<ObjCMethodDecl>(DC);
 795 }
 796
 797 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
 798   DeclContext *DC = getFunctionLevelDeclContext();
 799   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
 800     return cast<NamedDecl>(DC);
 801   return 0;
 802 }
 803
 804 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
 805   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
 806   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
 807   // been made more painfully obvious by the refactor that introduced this
 808   // function, but it is possible that the incoming argument can be
 809   // eliminnated. If it truly cannot be (for example, there is some reentrancy
 810   // issue I am not seeing yet), then there should at least be a clarifying
 811   // comment somewhere.
 812   if (llvm::Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
 813     switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
 814               Diags.getCurrentDiagID())) {
 815     case DiagnosticIDs::SFINAE_Report:
 816       // We'll report the diagnostic below.
 817       break;
 818
 819     case DiagnosticIDs::SFINAE_SubstitutionFailure:
 820       // Count this failure so that we know that template argument deduction
 821       // has failed.
 822       ++NumSFINAEErrors;
 823
 824       // Make a copy of this suppressed diagnostic and store it with the
 825       // template-deduction information.
 826       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
 827         Diagnostic DiagInfo(&Diags);
 828         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
 829                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
 830       }
 831
 832       Diags.setLastDiagnosticIgnored();
 833       Diags.Clear();
 834       return;
 835
 836     case DiagnosticIDs::SFINAE_AccessControl: {
 837       // Per C++ Core Issue 1170, access control is part of SFINAE.
 838       // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
 839       // make access control a part of SFINAE for the purposes of checking
 840       // type traits.
 841       if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus0x)
 842         break;
 843
 844       SourceLocation Loc = Diags.getCurrentDiagLoc();
 845
 846       // Suppress this diagnostic.
 847       ++NumSFINAEErrors;
 848
 849       // Make a copy of this suppressed diagnostic and store it with the
 850       // template-deduction information.
 851       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
 852         Diagnostic DiagInfo(&Diags);
 853         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
 854                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
 855       }
 856
 857       Diags.setLastDiagnosticIgnored();
 858       Diags.Clear();
 859
 860       // Now the diagnostic state is clear, produce a C++98 compatibility
 861       // warning.
 862       Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
 863
 864       // The last diagnostic which Sema produced was ignored. Suppress any
 865       // notes attached to it.
 866       Diags.setLastDiagnosticIgnored();
 867       return;
 868     }
 869
 870     case DiagnosticIDs::SFINAE_Suppress:
 871       // Make a copy of this suppressed diagnostic and store it with the
 872       // template-deduction information;
 873       if (*Info) {
 874         Diagnostic DiagInfo(&Diags);
 875         (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
 876                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
 877       }
 878
 879       // Suppress this diagnostic.
 880       Diags.setLastDiagnosticIgnored();
 881       Diags.Clear();
 882       return;
 883     }
 884   }
 885
 886   // Set up the context's printing policy based on our current state.
 887   Context.setPrintingPolicy(getPrintingPolicy());
 888
 889   // Emit the diagnostic.
 890   if (!Diags.EmitCurrentDiagnostic())
 891     return;
 892
 893   // If this is not a note, and we're in a template instantiation
 894   // that is different from the last template instantiation where
 895   // we emitted an error, print a template instantiation
 896   // backtrace.
 897   if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
 898       !ActiveTemplateInstantiations.empty() &&
 899       ActiveTemplateInstantiations.back()
 900         != LastTemplateInstantiationErrorContext) {
 901     PrintInstantiationStack();
 902     LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
 903   }
 904 }
 905
 906 Sema::SemaDiagnosticBuilder
 907 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
 908   SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
 909   PD.Emit(Builder);
 910
 911   return Builder;
 912 }
 913
 914 /// \brief Looks through the macro-expansion chain for the given
 915 /// location, looking for a macro expansion with the given name.
 916 /// If one is found, returns true and sets the location to that
 917 /// expansion loc.
 918 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
 919   SourceLocation loc = locref;
 920   if (!loc.isMacroID()) return false;
 921
 922   // There's no good way right now to look at the intermediate
 923   // expansions, so just jump to the expansion location.
 924   loc = getSourceManager().getExpansionLoc(loc);
 925
 926   // If that's written with the name, stop here.
 927   SmallVector<char, 16> buffer;
 928   if (getPreprocessor().getSpelling(loc, buffer) == name) {
 929     locref = loc;
 930     return true;
 931   }
 932   return false;
 933 }
 934
 935 /// \brief Determines the active Scope associated with the given declaration
 936 /// context.
 937 ///
 938 /// This routine maps a declaration context to the active Scope object that
 939 /// represents that declaration context in the parser. It is typically used
 940 /// from "scope-less" code (e.g., template instantiation, lazy creation of
 941 /// declarations) that injects a name for name-lookup purposes and, therefore,
 942 /// must update the Scope.
 943 ///
 944 /// \returns The scope corresponding to the given declaraion context, or NULL
 945 /// if no such scope is open.
 946 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
 947
 948   if (!Ctx)
 949     return 0;
 950
 951   Ctx = Ctx->getPrimaryContext();
 952   for (Scope *S = getCurScope(); S; S = S->getParent()) {
 953     // Ignore scopes that cannot have declarations. This is important for
 954     // out-of-line definitions of static class members.
 955     if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
 956       if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
 957         if (Ctx == Entity->getPrimaryContext())
 958           return S;
 959   }
 960
 961   return 0;
 962 }
 963
 964 /// \brief Enter a new function scope
 965 void Sema::PushFunctionScope() {
 966   if (FunctionScopes.size() == 1) {
 967     // Use the "top" function scope rather than having to allocate
 968     // memory for a new scope.
 969     FunctionScopes.back()->Clear();
 970     FunctionScopes.push_back(FunctionScopes.back());
 971     return;
 972   }
 973
 974   FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
 975 }
 976
 977 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
 978   FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
 979                                               BlockScope, Block));
 980 }
 981
 982 void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
 983                            CXXMethodDecl *CallOperator) {
 984   FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
 985                                                CallOperator));
 986 }
 987
 988 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
 989                                 const Decl *D, const BlockExpr *blkExpr) {
 990   FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
 991   assert(!FunctionScopes.empty() && "mismatched push/pop!");
 992
 993   // Issue any analysis-based warnings.
 994   if (WP && D)
 995     AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
 996   else {
 997     for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
 998          i = Scope->PossiblyUnreachableDiags.begin(),
 999          e = Scope->PossiblyUnreachableDiags.end();
1000          i != e; ++i) {
1001       const sema::PossiblyUnreachableDiag &D = *i;
1002       Diag(D.Loc, D.PD);
1003     }
1004   }
1005
1006   if (FunctionScopes.back() != Scope) {
1007     delete Scope;
1008   }
1009 }
1010
1011 void Sema::PushCompoundScope() {
1012   getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
1013 }
1014
1015 void Sema::PopCompoundScope() {
1016   FunctionScopeInfo *CurFunction = getCurFunction();
1017   assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1018
1019   CurFunction->CompoundScopes.pop_back();
1020 }
1021
1022 /// \brief Determine whether any errors occurred within this function/method/
1023 /// block.
1024 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1025   return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1026 }
1027
1028 BlockScopeInfo *Sema::getCurBlock() {
1029   if (FunctionScopes.empty())
1030     return 0;
1031
1032   return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1033 }
1034
1035 LambdaScopeInfo *Sema::getCurLambda() {
1036   if (FunctionScopes.empty())
1037     return 0;
1038
1039   return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
1040 }
1041
1042 void Sema::ActOnComment(SourceRange Comment) {
1043   if (!LangOpts.RetainCommentsFromSystemHeaders &&
1044       SourceMgr.isInSystemHeader(Comment.getBegin()))
1045     return;
1046   RawComment RC(SourceMgr, Comment);
1047   if (RC.isAlmostTrailingComment()) {
1048     SourceRange MagicMarkerRange(Comment.getBegin(),
1049                                  Comment.getBegin().getLocWithOffset(3));
1050     StringRef MagicMarkerText;
1051     switch (RC.getKind()) {
1052     case RawComment::RCK_OrdinaryBCPL:
1053       MagicMarkerText = "///<";
1054       break;
1055     case RawComment::RCK_OrdinaryC:
1056       MagicMarkerText = "/**<";
1057       break;
1058     default:
1059       llvm_unreachable("if this is an almost Doxygen comment, "
1060                        "it should be ordinary");
1061     }
1062     Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1063       FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1064   }
1065   Context.addComment(RC);
1066 }
1067
1068 // Pin this vtable to this file.
1069 ExternalSemaSource::~ExternalSemaSource() {}
1070
1071 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1072
1073 void ExternalSemaSource::ReadKnownNamespaces(
1074                            SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1075 }
1076
1077 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
1078   SourceLocation Loc = this->Loc;
1079   if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
1080   if (Loc.isValid()) {
1081     Loc.print(OS, S.getSourceManager());
1082     OS << ": ";
1083   }
1084   OS << Message;
1085
1086   if (TheDecl && isa<NamedDecl>(TheDecl)) {
1087     std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1088     if (!Name.empty())
1089       OS << " '" << Name << '\'';
1090   }
1091
1092   OS << '\n';
1093 }
1094
1095 /// \brief Figure out if an expression could be turned into a call.
1096 ///
1097 /// Use this when trying to recover from an error where the programmer may have
1098 /// written just the name of a function instead of actually calling it.
1099 ///
1100 /// \param E - The expression to examine.
1101 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1102 ///  with no arguments, this parameter is set to the type returned by such a
1103 ///  call; otherwise, it is set to an empty QualType.
1104 /// \param OverloadSet - If the expression is an overloaded function
1105 ///  name, this parameter is populated with the decls of the various overloads.
1106 bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
1107                           UnresolvedSetImpl &OverloadSet) {
1108   ZeroArgCallReturnTy = QualType();
1109   OverloadSet.clear();
1110
1111   if (E.getType() == Context.OverloadTy) {
1112     OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1113     const OverloadExpr *Overloads = FR.Expression;
1114
1115     for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1116          DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1117       OverloadSet.addDecl(*it);
1118
1119       // Check whether the function is a non-template which takes no
1120       // arguments.
1121       if (const FunctionDecl *OverloadDecl
1122             = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1123         if (OverloadDecl->getMinRequiredArguments() == 0)
1124           ZeroArgCallReturnTy = OverloadDecl->getResultType();
1125       }
1126     }
1127
1128     // Ignore overloads that are pointer-to-member constants.
1129     if (FR.HasFormOfMemberPointer)
1130       return false;
1131
1132     return true;
1133   }
1134
1135   if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1136     if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1137       if (Fun->getMinRequiredArguments() == 0)
1138         ZeroArgCallReturnTy = Fun->getResultType();
1139       return true;
1140     }
1141   }
1142
1143   // We don't have an expression that's convenient to get a FunctionDecl from,
1144   // but we can at least check if the type is "function of 0 arguments".
1145   QualType ExprTy = E.getType();
1146   const FunctionType *FunTy = NULL;
1147   QualType PointeeTy = ExprTy->getPointeeType();
1148   if (!PointeeTy.isNull())
1149     FunTy = PointeeTy->getAs<FunctionType>();
1150   if (!FunTy)
1151     FunTy = ExprTy->getAs<FunctionType>();
1152   if (!FunTy && ExprTy == Context.BoundMemberTy) {
1153     // Look for the bound-member type.  If it's still overloaded, give up,
1154     // although we probably should have fallen into the OverloadExpr case above
1155     // if we actually have an overloaded bound member.
1156     QualType BoundMemberTy = Expr::findBoundMemberType(&E);
1157     if (!BoundMemberTy.isNull())
1158       FunTy = BoundMemberTy->castAs<FunctionType>();
1159   }
1160
1161   if (const FunctionProtoType *FPT =
1162       dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1163     if (FPT->getNumArgs() == 0)
1164       ZeroArgCallReturnTy = FunTy->getResultType();
1165     return true;
1166   }
1167   return false;
1168 }
1169
1170 /// \brief Give notes for a set of overloads.
1171 ///
1172 /// A companion to isExprCallable. In cases when the name that the programmer
1173 /// wrote was an overloaded function, we may be able to make some guesses about
1174 /// plausible overloads based on their return types; such guesses can be handed
1175 /// off to this method to be emitted as notes.
1176 ///
1177 /// \param Overloads - The overloads to note.
1178 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1179 ///  -fshow-overloads=best, this is the location to attach to the note about too
1180 ///  many candidates. Typically this will be the location of the original
1181 ///  ill-formed expression.
1182 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1183                           const SourceLocation FinalNoteLoc) {
1184   int ShownOverloads = 0;
1185   int SuppressedOverloads = 0;
1186   for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1187        DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1188     // FIXME: Magic number for max shown overloads stolen from
1189     // OverloadCandidateSet::NoteCandidates.
1190     if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1191       ++SuppressedOverloads;
1192       continue;
1193     }
1194
1195     NamedDecl *Fn = (*It)->getUnderlyingDecl();
1196     S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1197     ++ShownOverloads;
1198   }
1199
1200   if (SuppressedOverloads)
1201     S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1202       << SuppressedOverloads;
1203 }
1204
1205 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1206                                    const UnresolvedSetImpl &Overloads,
1207                                    bool (*IsPlausibleResult)(QualType)) {
1208   if (!IsPlausibleResult)
1209     return noteOverloads(S, Overloads, Loc);
1210
1211   UnresolvedSet<2> PlausibleOverloads;
1212   for (OverloadExpr::decls_iterator It = Overloads.begin(),
1213          DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1214     const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1215     QualType OverloadResultTy = OverloadDecl->getResultType();
1216     if (IsPlausibleResult(OverloadResultTy))
1217       PlausibleOverloads.addDecl(It.getDecl());
1218   }
1219   noteOverloads(S, PlausibleOverloads, Loc);
1220 }
1221
1222 /// Determine whether the given expression can be called by just
1223 /// putting parentheses after it.  Notably, expressions with unary
1224 /// operators can't be because the unary operator will start parsing
1225 /// outside the call.
1226 static bool IsCallableWithAppend(Expr *E) {
1227   E = E->IgnoreImplicit();
1228   return (!isa<CStyleCastExpr>(E) &&
1229           !isa<UnaryOperator>(E) &&
1230           !isa<BinaryOperator>(E) &&
1231           !isa<CXXOperatorCallExpr>(E));
1232 }
1233
1234 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1235                                 bool ForceComplain,
1236                                 bool (*IsPlausibleResult)(QualType)) {
1237   SourceLocation Loc = E.get()->getExprLoc();
1238   SourceRange Range = E.get()->getSourceRange();
1239
1240   QualType ZeroArgCallTy;
1241   UnresolvedSet<4> Overloads;
1242   if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) &&
1243       !ZeroArgCallTy.isNull() &&
1244       (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1245     // At this point, we know E is potentially callable with 0
1246     // arguments and that it returns something of a reasonable type,
1247     // so we can emit a fixit and carry on pretending that E was
1248     // actually a CallExpr.
1249     SourceLocation ParenInsertionLoc =
1250       PP.getLocForEndOfToken(Range.getEnd());
1251     Diag(Loc, PD)
1252       << /*zero-arg*/ 1 << Range
1253       << (IsCallableWithAppend(E.get())
1254           ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1255           : FixItHint());
1256     notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1257
1258     // FIXME: Try this before emitting the fixit, and suppress diagnostics
1259     // while doing so.
1260     E = ActOnCallExpr(0, E.take(), ParenInsertionLoc,
1261                       MultiExprArg(), ParenInsertionLoc.getLocWithOffset(1));
1262     return true;
1263   }
1264
1265   if (!ForceComplain) return false;
1266
1267   Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1268   notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1269   E = ExprError();
1270   return true;
1271 }