contrib/llvm/tools/clang/lib/Sema/Sema.cpp

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