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