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