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