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