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