Sema.cpp revision 15e17aed79163d0d40ed7914f7fe992c400d93dd 
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 (true) {
640    if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC)) {
641      DC = DC->getParent();
642    } else if (isa<CXXMethodDecl>(DC) &&
643               cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
644      DC = DC->getParent()->getParent();
645    }
646    else break;
647  }
648
649  return DC;
650}
651
652/// getCurFunctionDecl - If inside of a function body, this returns a pointer
653/// to the function decl for the function being parsed.  If we're currently
654/// in a 'block', this returns the containing context.
655FunctionDecl *Sema::getCurFunctionDecl() {
656  DeclContext *DC = getFunctionLevelDeclContext();
657  return dyn_cast<FunctionDecl>(DC);
658}
659
660ObjCMethodDecl *Sema::getCurMethodDecl() {
661  DeclContext *DC = getFunctionLevelDeclContext();
662  return dyn_cast<ObjCMethodDecl>(DC);
663}
664
665NamedDecl *Sema::getCurFunctionOrMethodDecl() {
666  DeclContext *DC = getFunctionLevelDeclContext();
667  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
668    return cast<NamedDecl>(DC);
669  return 0;
670}
671
672Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
673  if (!isActive())
674    return;
675
676  if (llvm::Optional<TemplateDeductionInfo*> Info = SemaRef.isSFINAEContext()) {
677    switch (DiagnosticIDs::getDiagnosticSFINAEResponse(getDiagID())) {
678    case DiagnosticIDs::SFINAE_Report:
679      // We'll report the diagnostic below.
680      break;
681
682    case DiagnosticIDs::SFINAE_SubstitutionFailure:
683      // Count this failure so that we know that template argument deduction
684      // has failed.
685      ++SemaRef.NumSFINAEErrors;
686      SemaRef.Diags.setLastDiagnosticIgnored();
687      SemaRef.Diags.Clear();
688      Clear();
689      return;
690
691    case DiagnosticIDs::SFINAE_AccessControl: {
692      // Per C++ Core Issue 1170, access control is part of SFINAE.
693      // Additionally, the AccessCheckingSFINAE flag can be used to temporary
694      // make access control a part of SFINAE for the purposes of checking
695      // type traits.
696      if (!SemaRef.AccessCheckingSFINAE &&
697          !SemaRef.getLangOptions().CPlusPlus0x)
698        break;
699
700      SourceLocation Loc = getLocation();
701
702      // Suppress this diagnostic.
703      ++SemaRef.NumSFINAEErrors;
704      SemaRef.Diags.setLastDiagnosticIgnored();
705      SemaRef.Diags.Clear();
706      Clear();
707
708      // Now the diagnostic state is clear, produce a C++98 compatibility
709      // warning.
710      SemaRef.Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
711
712      // The last diagnostic which Sema produced was ignored. Suppress any
713      // notes attached to it.
714      SemaRef.Diags.setLastDiagnosticIgnored();
715      return;
716    }
717
718    case DiagnosticIDs::SFINAE_Suppress:
719      // Make a copy of this suppressed diagnostic and store it with the
720      // template-deduction information;
721      FlushCounts();
722      Diagnostic DiagInfo(&SemaRef.Diags);
723
724      if (*Info)
725        (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
726                        PartialDiagnostic(DiagInfo,
727                                          SemaRef.Context.getDiagAllocator()));
728
729      // Suppress this diagnostic.
730      SemaRef.Diags.setLastDiagnosticIgnored();
731      SemaRef.Diags.Clear();
732      Clear();
733      return;
734    }
735  }
736
737  // Set up the context's printing policy based on our current state.
738  SemaRef.Context.setPrintingPolicy(SemaRef.getPrintingPolicy());
739
740  // Emit the diagnostic.
741  if (!this->Emit())
742    return;
743
744  // If this is not a note, and we're in a template instantiation
745  // that is different from the last template instantiation where
746  // we emitted an error, print a template instantiation
747  // backtrace.
748  if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
749      !SemaRef.ActiveTemplateInstantiations.empty() &&
750      SemaRef.ActiveTemplateInstantiations.back()
751        != SemaRef.LastTemplateInstantiationErrorContext) {
752    SemaRef.PrintInstantiationStack();
753    SemaRef.LastTemplateInstantiationErrorContext
754      = SemaRef.ActiveTemplateInstantiations.back();
755  }
756}
757
758Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) {
759  DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
760  return SemaDiagnosticBuilder(DB, *this, DiagID);
761}
762
763Sema::SemaDiagnosticBuilder
764Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
765  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
766  PD.Emit(Builder);
767
768  return Builder;
769}
770
771/// \brief Looks through the macro-expansion chain for the given
772/// location, looking for a macro expansion with the given name.
773/// If one is found, returns true and sets the location to that
774/// expansion loc.
775bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
776  SourceLocation loc = locref;
777  if (!loc.isMacroID()) return false;
778
779  // There's no good way right now to look at the intermediate
780  // expansions, so just jump to the expansion location.
781  loc = getSourceManager().getExpansionLoc(loc);
782
783  // If that's written with the name, stop here.
784  SmallVector<char, 16> buffer;
785  if (getPreprocessor().getSpelling(loc, buffer) == name) {
786    locref = loc;
787    return true;
788  }
789  return false;
790}
791
792/// \brief Determines the active Scope associated with the given declaration
793/// context.
794///
795/// This routine maps a declaration context to the active Scope object that
796/// represents that declaration context in the parser. It is typically used
797/// from "scope-less" code (e.g., template instantiation, lazy creation of
798/// declarations) that injects a name for name-lookup purposes and, therefore,
799/// must update the Scope.
800///
801/// \returns The scope corresponding to the given declaraion context, or NULL
802/// if no such scope is open.
803Scope *Sema::getScopeForContext(DeclContext *Ctx) {
804
805  if (!Ctx)
806    return 0;
807
808  Ctx = Ctx->getPrimaryContext();
809  for (Scope *S = getCurScope(); S; S = S->getParent()) {
810    // Ignore scopes that cannot have declarations. This is important for
811    // out-of-line definitions of static class members.
812    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
813      if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
814        if (Ctx == Entity->getPrimaryContext())
815          return S;
816  }
817
818  return 0;
819}
820
821/// \brief Enter a new function scope
822void Sema::PushFunctionScope() {
823  if (FunctionScopes.size() == 1) {
824    // Use the "top" function scope rather than having to allocate
825    // memory for a new scope.
826    FunctionScopes.back()->Clear();
827    FunctionScopes.push_back(FunctionScopes.back());
828    return;
829  }
830
831  FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
832}
833
834void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
835  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
836                                              BlockScope, Block));
837}
838
839void Sema::PushLambdaScope(CXXRecordDecl *Lambda) {
840  FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda));
841}
842
843void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
844                                const Decl *D, const BlockExpr *blkExpr) {
845  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
846  assert(!FunctionScopes.empty() && "mismatched push/pop!");
847
848  // Issue any analysis-based warnings.
849  if (WP && D)
850    AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
851  else {
852    for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
853         i = Scope->PossiblyUnreachableDiags.begin(),
854         e = Scope->PossiblyUnreachableDiags.end();
855         i != e; ++i) {
856      const sema::PossiblyUnreachableDiag &D = *i;
857      Diag(D.Loc, D.PD);
858    }
859  }
860
861  if (FunctionScopes.back() != Scope) {
862    delete Scope;
863  }
864}
865
866/// \brief Determine whether any errors occurred within this function/method/
867/// block.
868bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
869  return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
870}
871
872BlockScopeInfo *Sema::getCurBlock() {
873  if (FunctionScopes.empty())
874    return 0;
875
876  return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
877}
878
879LambdaScopeInfo *Sema::getCurLambda() {
880  if (FunctionScopes.empty())
881    return 0;
882
883  return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
884}
885
886// Pin this vtable to this file.
887ExternalSemaSource::~ExternalSemaSource() {}
888
889std::pair<ObjCMethodList, ObjCMethodList>
890ExternalSemaSource::ReadMethodPool(Selector Sel) {
891  return std::pair<ObjCMethodList, ObjCMethodList>();
892}
893
894void ExternalSemaSource::ReadKnownNamespaces(
895                           SmallVectorImpl<NamespaceDecl *> &Namespaces) {
896}
897
898void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
899  SourceLocation Loc = this->Loc;
900  if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
901  if (Loc.isValid()) {
902    Loc.print(OS, S.getSourceManager());
903    OS << ": ";
904  }
905  OS << Message;
906
907  if (TheDecl && isa<NamedDecl>(TheDecl)) {
908    std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
909    if (!Name.empty())
910      OS << " '" << Name << '\'';
911  }
912
913  OS << '\n';
914}
915
916/// \brief Figure out if an expression could be turned into a call.
917///
918/// Use this when trying to recover from an error where the programmer may have
919/// written just the name of a function instead of actually calling it.
920///
921/// \param E - The expression to examine.
922/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
923///  with no arguments, this parameter is set to the type returned by such a
924///  call; otherwise, it is set to an empty QualType.
925/// \param OverloadSet - If the expression is an overloaded function
926///  name, this parameter is populated with the decls of the various overloads.
927bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
928                          UnresolvedSetImpl &OverloadSet) {
929  ZeroArgCallReturnTy = QualType();
930  OverloadSet.clear();
931
932  if (E.getType() == Context.OverloadTy) {
933    OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
934    const OverloadExpr *Overloads = FR.Expression;
935
936    for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
937         DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
938      OverloadSet.addDecl(*it);
939
940      // Check whether the function is a non-template which takes no
941      // arguments.
942      if (const FunctionDecl *OverloadDecl
943            = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
944        if (OverloadDecl->getMinRequiredArguments() == 0)
945          ZeroArgCallReturnTy = OverloadDecl->getResultType();
946      }
947    }
948
949    // Ignore overloads that are pointer-to-member constants.
950    if (FR.HasFormOfMemberPointer)
951      return false;
952
953    return true;
954  }
955
956  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
957    if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
958      if (Fun->getMinRequiredArguments() == 0)
959        ZeroArgCallReturnTy = Fun->getResultType();
960      return true;
961    }
962  }
963
964  // We don't have an expression that's convenient to get a FunctionDecl from,
965  // but we can at least check if the type is "function of 0 arguments".
966  QualType ExprTy = E.getType();
967  const FunctionType *FunTy = NULL;
968  QualType PointeeTy = ExprTy->getPointeeType();
969  if (!PointeeTy.isNull())
970    FunTy = PointeeTy->getAs<FunctionType>();
971  if (!FunTy)
972    FunTy = ExprTy->getAs<FunctionType>();
973  if (!FunTy && ExprTy == Context.BoundMemberTy) {
974    // Look for the bound-member type.  If it's still overloaded, give up,
975    // although we probably should have fallen into the OverloadExpr case above
976    // if we actually have an overloaded bound member.
977    QualType BoundMemberTy = Expr::findBoundMemberType(&E);
978    if (!BoundMemberTy.isNull())
979      FunTy = BoundMemberTy->castAs<FunctionType>();
980  }
981
982  if (const FunctionProtoType *FPT =
983      dyn_cast_or_null<FunctionProtoType>(FunTy)) {
984    if (FPT->getNumArgs() == 0)
985      ZeroArgCallReturnTy = FunTy->getResultType();
986    return true;
987  }
988  return false;
989}
990
991/// \brief Give notes for a set of overloads.
992///
993/// A companion to isExprCallable. In cases when the name that the programmer
994/// wrote was an overloaded function, we may be able to make some guesses about
995/// plausible overloads based on their return types; such guesses can be handed
996/// off to this method to be emitted as notes.
997///
998/// \param Overloads - The overloads to note.
999/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1000///  -fshow-overloads=best, this is the location to attach to the note about too
1001///  many candidates. Typically this will be the location of the original
1002///  ill-formed expression.
1003static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1004                          const SourceLocation FinalNoteLoc) {
1005  int ShownOverloads = 0;
1006  int SuppressedOverloads = 0;
1007  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1008       DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1009    // FIXME: Magic number for max shown overloads stolen from
1010    // OverloadCandidateSet::NoteCandidates.
1011    if (ShownOverloads >= 4 &&
1012        S.Diags.getShowOverloads() == DiagnosticsEngine::Ovl_Best) {
1013      ++SuppressedOverloads;
1014      continue;
1015    }
1016
1017    NamedDecl *Fn = (*It)->getUnderlyingDecl();
1018    S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1019    ++ShownOverloads;
1020  }
1021
1022  if (SuppressedOverloads)
1023    S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1024      << SuppressedOverloads;
1025}
1026
1027static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1028                                   const UnresolvedSetImpl &Overloads,
1029                                   bool (*IsPlausibleResult)(QualType)) {
1030  if (!IsPlausibleResult)
1031    return noteOverloads(S, Overloads, Loc);
1032
1033  UnresolvedSet<2> PlausibleOverloads;
1034  for (OverloadExpr::decls_iterator It = Overloads.begin(),
1035         DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1036    const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1037    QualType OverloadResultTy = OverloadDecl->getResultType();
1038    if (IsPlausibleResult(OverloadResultTy))
1039      PlausibleOverloads.addDecl(It.getDecl());
1040  }
1041  noteOverloads(S, PlausibleOverloads, Loc);
1042}
1043
1044/// Determine whether the given expression can be called by just
1045/// putting parentheses after it.  Notably, expressions with unary
1046/// operators can't be because the unary operator will start parsing
1047/// outside the call.
1048static bool IsCallableWithAppend(Expr *E) {
1049  E = E->IgnoreImplicit();
1050  return (!isa<CStyleCastExpr>(E) &&
1051          !isa<UnaryOperator>(E) &&
1052          !isa<BinaryOperator>(E) &&
1053          !isa<CXXOperatorCallExpr>(E));
1054}
1055
1056bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1057                                bool ForceComplain,
1058                                bool (*IsPlausibleResult)(QualType)) {
1059  SourceLocation Loc = E.get()->getExprLoc();
1060  SourceRange Range = E.get()->getSourceRange();
1061
1062  QualType ZeroArgCallTy;
1063  UnresolvedSet<4> Overloads;
1064  if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) &&
1065      !ZeroArgCallTy.isNull() &&
1066      (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1067    // At this point, we know E is potentially callable with 0
1068    // arguments and that it returns something of a reasonable type,
1069    // so we can emit a fixit and carry on pretending that E was
1070    // actually a CallExpr.
1071    SourceLocation ParenInsertionLoc =
1072      PP.getLocForEndOfToken(Range.getEnd());
1073    Diag(Loc, PD)
1074      << /*zero-arg*/ 1 << Range
1075      << (IsCallableWithAppend(E.get())
1076          ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1077          : FixItHint());
1078    notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1079
1080    // FIXME: Try this before emitting the fixit, and suppress diagnostics
1081    // while doing so.
1082    E = ActOnCallExpr(0, E.take(), ParenInsertionLoc,
1083                      MultiExprArg(*this, 0, 0),
1084                      ParenInsertionLoc.getLocWithOffset(1));
1085    return true;
1086  }
1087
1088  if (!ForceComplain) return false;
1089
1090  Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1091  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1092  E = ExprError();
1093  return true;
1094}
1095