• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
43 using namespace clang;
44 using namespace sema;
45 
~FunctionScopeInfo()46 FunctionScopeInfo::~FunctionScopeInfo() { }
47 
Clear()48 void 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 
~BlockScopeInfo()59 BlockScopeInfo::~BlockScopeInfo() { }
~LambdaScopeInfo()60 LambdaScopeInfo::~LambdaScopeInfo() { }
61 
getPrintingPolicy(const ASTContext & Context,const Preprocessor & PP)62 PrintingPolicy 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 
ActOnTranslationUnitScope(Scope * S)77 void Sema::ActOnTranslationUnitScope(Scope *S) {
78   TUScope = S;
79   PushDeclContext(S, Context.getTranslationUnitDecl());
80 
81   VAListTagName = PP.getIdentifierInfo("__va_list_tag");
82 }
83 
Sema(Preprocessor & pp,ASTContext & ctxt,ASTConsumer & consumer,TranslationUnitKind TUKind,CodeCompleteConsumer * CodeCompleter)84 Sema::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 
Initialize()130 void 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 
~Sema()187 Sema::~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.
makeUnavailableInSystemHeader(SourceLocation loc,StringRef msg)212 bool 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 
getASTMutationListener() const233 ASTMutationListener *Sema::getASTMutationListener() const {
234   return getASTConsumer().GetASTMutationListener();
235 }
236 
237 /// \brief Print out statistics about the semantic analysis.
PrintStats() const238 void 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.
ImpCastExprToType(Expr * E,QualType Ty,CastKind Kind,ExprValueKind VK,const CXXCastPath * BasePath,CheckedConversionKind CCK)249 ExprResult 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.
ScalarTypeToBooleanCastKind(QualType ScalarTy)302 CastKind 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.
ShouldRemoveFromUnused(Sema * SemaRef,const DeclaratorDecl * D)318 static 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 
353 namespace {
354   struct UndefinedInternal {
355     NamedDecl *decl;
356     FullSourceLoc useLoc;
357 
UndefinedInternal__anon461fb15d0111::UndefinedInternal358     UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc)
359       : decl(decl), useLoc(useLoc) {}
360   };
361 
operator <(const UndefinedInternal & l,const UndefinedInternal & r)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.
checkUndefinedInternals(Sema & S)368 static 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 
LoadExternalWeakUndeclaredIdentifiers()412 void 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 
429 typedef 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.
MethodsAndNestedClassesComplete(const CXXRecordDecl * RD,RecordCompleteMap & MNCComplete)436 static 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.
IsRecordFullyDefined(const CXXRecordDecl * RD,RecordCompleteMap & RecordsComplete,RecordCompleteMap & MNCComplete)472 static 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.
ActOnEndOfTranslationUnit()506 void 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 
getFunctionLevelDeclContext()753 DeclContext *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.
getCurFunctionDecl()773 FunctionDecl *Sema::getCurFunctionDecl() {
774   DeclContext *DC = getFunctionLevelDeclContext();
775   return dyn_cast<FunctionDecl>(DC);
776 }
777 
getCurMethodDecl()778 ObjCMethodDecl *Sema::getCurMethodDecl() {
779   DeclContext *DC = getFunctionLevelDeclContext();
780   return dyn_cast<ObjCMethodDecl>(DC);
781 }
782 
getCurFunctionOrMethodDecl()783 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
784   DeclContext *DC = getFunctionLevelDeclContext();
785   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
786     return cast<NamedDecl>(DC);
787   return 0;
788 }
789 
EmitCurrentDiagnostic(unsigned DiagID)790 void 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 
892 Sema::SemaDiagnosticBuilder
Diag(SourceLocation Loc,const PartialDiagnostic & PD)893 Sema::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.
findMacroSpelling(SourceLocation & locref,StringRef name)904 bool 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.
getScopeForContext(DeclContext * Ctx)932 Scope *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
PushFunctionScope()951 void 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 
PushBlockScope(Scope * BlockScope,BlockDecl * Block)963 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
964   FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
965                                               BlockScope, Block));
966 }
967 
PushLambdaScope(CXXRecordDecl * Lambda,CXXMethodDecl * CallOperator)968 void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
969                            CXXMethodDecl *CallOperator) {
970   FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
971                                                CallOperator));
972 }
973 
PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy * WP,const Decl * D,const BlockExpr * blkExpr)974 void 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 
PushCompoundScope()997 void Sema::PushCompoundScope() {
998   getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
999 }
1000 
PopCompoundScope()1001 void 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.
hasAnyUnrecoverableErrorsInThisFunction() const1010 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1011   return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1012 }
1013 
getCurBlock()1014 BlockScopeInfo *Sema::getCurBlock() {
1015   if (FunctionScopes.empty())
1016     return 0;
1017 
1018   return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1019 }
1020 
getCurLambda()1021 LambdaScopeInfo *Sema::getCurLambda() {
1022   if (FunctionScopes.empty())
1023     return 0;
1024 
1025   return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
1026 }
1027 
ActOnComment(SourceRange Comment)1028 void Sema::ActOnComment(SourceRange Comment) {
1029   RawComment RC(SourceMgr, Comment);
1030   if (RC.isAlmostTrailingComment()) {
1031     SourceRange MagicMarkerRange(Comment.getBegin(),
1032                                  Comment.getBegin().getLocWithOffset(3));
1033     StringRef MagicMarkerText;
1034     switch (RC.getKind()) {
1035     case RawComment::RCK_OrdinaryBCPL:
1036       MagicMarkerText = "///<";
1037       break;
1038     case RawComment::RCK_OrdinaryC:
1039       MagicMarkerText = "/**<";
1040       break;
1041     default:
1042       llvm_unreachable("if this is an almost Doxygen comment, "
1043                        "it should be ordinary");
1044     }
1045     Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1046       FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1047   }
1048   Context.addComment(RC);
1049 }
1050 
1051 // Pin this vtable to this file.
~ExternalSemaSource()1052 ExternalSemaSource::~ExternalSemaSource() {}
1053 
ReadMethodPool(Selector Sel)1054 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1055 
ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl * > & Namespaces)1056 void ExternalSemaSource::ReadKnownNamespaces(
1057                            SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1058 }
1059 
print(raw_ostream & OS) const1060 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
1061   SourceLocation Loc = this->Loc;
1062   if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
1063   if (Loc.isValid()) {
1064     Loc.print(OS, S.getSourceManager());
1065     OS << ": ";
1066   }
1067   OS << Message;
1068 
1069   if (TheDecl && isa<NamedDecl>(TheDecl)) {
1070     std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1071     if (!Name.empty())
1072       OS << " '" << Name << '\'';
1073   }
1074 
1075   OS << '\n';
1076 }
1077 
1078 /// \brief Figure out if an expression could be turned into a call.
1079 ///
1080 /// Use this when trying to recover from an error where the programmer may have
1081 /// written just the name of a function instead of actually calling it.
1082 ///
1083 /// \param E - The expression to examine.
1084 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1085 ///  with no arguments, this parameter is set to the type returned by such a
1086 ///  call; otherwise, it is set to an empty QualType.
1087 /// \param OverloadSet - If the expression is an overloaded function
1088 ///  name, this parameter is populated with the decls of the various overloads.
isExprCallable(const Expr & E,QualType & ZeroArgCallReturnTy,UnresolvedSetImpl & OverloadSet)1089 bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
1090                           UnresolvedSetImpl &OverloadSet) {
1091   ZeroArgCallReturnTy = QualType();
1092   OverloadSet.clear();
1093 
1094   if (E.getType() == Context.OverloadTy) {
1095     OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1096     const OverloadExpr *Overloads = FR.Expression;
1097 
1098     for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1099          DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1100       OverloadSet.addDecl(*it);
1101 
1102       // Check whether the function is a non-template which takes no
1103       // arguments.
1104       if (const FunctionDecl *OverloadDecl
1105             = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1106         if (OverloadDecl->getMinRequiredArguments() == 0)
1107           ZeroArgCallReturnTy = OverloadDecl->getResultType();
1108       }
1109     }
1110 
1111     // Ignore overloads that are pointer-to-member constants.
1112     if (FR.HasFormOfMemberPointer)
1113       return false;
1114 
1115     return true;
1116   }
1117 
1118   if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1119     if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1120       if (Fun->getMinRequiredArguments() == 0)
1121         ZeroArgCallReturnTy = Fun->getResultType();
1122       return true;
1123     }
1124   }
1125 
1126   // We don't have an expression that's convenient to get a FunctionDecl from,
1127   // but we can at least check if the type is "function of 0 arguments".
1128   QualType ExprTy = E.getType();
1129   const FunctionType *FunTy = NULL;
1130   QualType PointeeTy = ExprTy->getPointeeType();
1131   if (!PointeeTy.isNull())
1132     FunTy = PointeeTy->getAs<FunctionType>();
1133   if (!FunTy)
1134     FunTy = ExprTy->getAs<FunctionType>();
1135   if (!FunTy && ExprTy == Context.BoundMemberTy) {
1136     // Look for the bound-member type.  If it's still overloaded, give up,
1137     // although we probably should have fallen into the OverloadExpr case above
1138     // if we actually have an overloaded bound member.
1139     QualType BoundMemberTy = Expr::findBoundMemberType(&E);
1140     if (!BoundMemberTy.isNull())
1141       FunTy = BoundMemberTy->castAs<FunctionType>();
1142   }
1143 
1144   if (const FunctionProtoType *FPT =
1145       dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1146     if (FPT->getNumArgs() == 0)
1147       ZeroArgCallReturnTy = FunTy->getResultType();
1148     return true;
1149   }
1150   return false;
1151 }
1152 
1153 /// \brief Give notes for a set of overloads.
1154 ///
1155 /// A companion to isExprCallable. In cases when the name that the programmer
1156 /// wrote was an overloaded function, we may be able to make some guesses about
1157 /// plausible overloads based on their return types; such guesses can be handed
1158 /// off to this method to be emitted as notes.
1159 ///
1160 /// \param Overloads - The overloads to note.
1161 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1162 ///  -fshow-overloads=best, this is the location to attach to the note about too
1163 ///  many candidates. Typically this will be the location of the original
1164 ///  ill-formed expression.
noteOverloads(Sema & S,const UnresolvedSetImpl & Overloads,const SourceLocation FinalNoteLoc)1165 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1166                           const SourceLocation FinalNoteLoc) {
1167   int ShownOverloads = 0;
1168   int SuppressedOverloads = 0;
1169   for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1170        DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1171     // FIXME: Magic number for max shown overloads stolen from
1172     // OverloadCandidateSet::NoteCandidates.
1173     if (ShownOverloads >= 4 &&
1174         S.Diags.getShowOverloads() == DiagnosticsEngine::Ovl_Best) {
1175       ++SuppressedOverloads;
1176       continue;
1177     }
1178 
1179     NamedDecl *Fn = (*It)->getUnderlyingDecl();
1180     S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1181     ++ShownOverloads;
1182   }
1183 
1184   if (SuppressedOverloads)
1185     S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1186       << SuppressedOverloads;
1187 }
1188 
notePlausibleOverloads(Sema & S,SourceLocation Loc,const UnresolvedSetImpl & Overloads,bool (* IsPlausibleResult)(QualType))1189 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1190                                    const UnresolvedSetImpl &Overloads,
1191                                    bool (*IsPlausibleResult)(QualType)) {
1192   if (!IsPlausibleResult)
1193     return noteOverloads(S, Overloads, Loc);
1194 
1195   UnresolvedSet<2> PlausibleOverloads;
1196   for (OverloadExpr::decls_iterator It = Overloads.begin(),
1197          DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1198     const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1199     QualType OverloadResultTy = OverloadDecl->getResultType();
1200     if (IsPlausibleResult(OverloadResultTy))
1201       PlausibleOverloads.addDecl(It.getDecl());
1202   }
1203   noteOverloads(S, PlausibleOverloads, Loc);
1204 }
1205 
1206 /// Determine whether the given expression can be called by just
1207 /// putting parentheses after it.  Notably, expressions with unary
1208 /// operators can't be because the unary operator will start parsing
1209 /// outside the call.
IsCallableWithAppend(Expr * E)1210 static bool IsCallableWithAppend(Expr *E) {
1211   E = E->IgnoreImplicit();
1212   return (!isa<CStyleCastExpr>(E) &&
1213           !isa<UnaryOperator>(E) &&
1214           !isa<BinaryOperator>(E) &&
1215           !isa<CXXOperatorCallExpr>(E));
1216 }
1217 
tryToRecoverWithCall(ExprResult & E,const PartialDiagnostic & PD,bool ForceComplain,bool (* IsPlausibleResult)(QualType))1218 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1219                                 bool ForceComplain,
1220                                 bool (*IsPlausibleResult)(QualType)) {
1221   SourceLocation Loc = E.get()->getExprLoc();
1222   SourceRange Range = E.get()->getSourceRange();
1223 
1224   QualType ZeroArgCallTy;
1225   UnresolvedSet<4> Overloads;
1226   if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) &&
1227       !ZeroArgCallTy.isNull() &&
1228       (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1229     // At this point, we know E is potentially callable with 0
1230     // arguments and that it returns something of a reasonable type,
1231     // so we can emit a fixit and carry on pretending that E was
1232     // actually a CallExpr.
1233     SourceLocation ParenInsertionLoc =
1234       PP.getLocForEndOfToken(Range.getEnd());
1235     Diag(Loc, PD)
1236       << /*zero-arg*/ 1 << Range
1237       << (IsCallableWithAppend(E.get())
1238           ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1239           : FixItHint());
1240     notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1241 
1242     // FIXME: Try this before emitting the fixit, and suppress diagnostics
1243     // while doing so.
1244     E = ActOnCallExpr(0, E.take(), ParenInsertionLoc,
1245                       MultiExprArg(), ParenInsertionLoc.getLocWithOffset(1));
1246     return true;
1247   }
1248 
1249   if (!ForceComplain) return false;
1250 
1251   Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1252   notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1253   E = ExprError();
1254   return true;
1255 }
1256