Removed unused LParenLoc parameter to ActOnCXXForRangeStmt
[lldb.git] / clang / include / clang / Sema / Sema.h
1 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
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 defines the Sema class, which performs semantic analysis and
11 // builds ASTs.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_SEMA_SEMA_H
16 #define LLVM_CLANG_SEMA_SEMA_H
17
18 #include "clang/Sema/Ownership.h"
19 #include "clang/Sema/AnalysisBasedWarnings.h"
20 #include "clang/Sema/IdentifierResolver.h"
21 #include "clang/Sema/ObjCMethodList.h"
22 #include "clang/Sema/DeclSpec.h"
23 #include "clang/Sema/ExternalSemaSource.h"
24 #include "clang/Sema/LocInfoType.h"
25 #include "clang/Sema/TypoCorrection.h"
26 #include "clang/Sema/Weak.h"
27 #include "clang/AST/Expr.h"
28 #include "clang/AST/ExprObjC.h"
29 #include "clang/AST/DeclarationName.h"
30 #include "clang/AST/ExternalASTSource.h"
31 #include "clang/AST/LambdaMangleContext.h"
32 #include "clang/AST/TypeLoc.h"
33 #include "clang/AST/NSAPI.h"
34 #include "clang/Lex/ModuleLoader.h"
35 #include "clang/Basic/Specifiers.h"
36 #include "clang/Basic/TemplateKinds.h"
37 #include "clang/Basic/TypeTraits.h"
38 #include "clang/Basic/ExpressionTraits.h"
39 #include "llvm/ADT/ArrayRef.h"
40 #include "llvm/ADT/Optional.h"
41 #include "llvm/ADT/OwningPtr.h"
42 #include "llvm/ADT/SetVector.h"
43 #include "llvm/ADT/SmallPtrSet.h"
44 #include "llvm/ADT/SmallVector.h"
45 #include <deque>
46 #include <string>
47
48 namespace llvm {
49   class APSInt;
50   template <typename ValueT> struct DenseMapInfo;
51   template <typename ValueT, typename ValueInfoT> class DenseSet;
52   class SmallBitVector;
53 }
54
55 namespace clang {
56   class ADLResult;
57   class ASTConsumer;
58   class ASTContext;
59   class ASTMutationListener;
60   class ASTReader;
61   class ASTWriter;
62   class ArrayType;
63   class AttributeList;
64   class BlockDecl;
65   class CXXBasePath;
66   class CXXBasePaths;
67   class CXXBindTemporaryExpr;
68   typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
69   class CXXConstructorDecl;
70   class CXXConversionDecl;
71   class CXXDestructorDecl;
72   class CXXFieldCollector;
73   class CXXMemberCallExpr;
74   class CXXMethodDecl;
75   class CXXScopeSpec;
76   class CXXTemporary;
77   class CXXTryStmt;
78   class CallExpr;
79   class ClassTemplateDecl;
80   class ClassTemplatePartialSpecializationDecl;
81   class ClassTemplateSpecializationDecl;
82   class CodeCompleteConsumer;
83   class CodeCompletionAllocator;
84   class CodeCompletionTUInfo;
85   class CodeCompletionResult;
86   class Decl;
87   class DeclAccessPair;
88   class DeclContext;
89   class DeclRefExpr;
90   class DeclaratorDecl;
91   class DeducedTemplateArgument;
92   class DependentDiagnostic;
93   class DesignatedInitExpr;
94   class Designation;
95   class EnumConstantDecl;
96   class Expr;
97   class ExtVectorType;
98   class ExternalSemaSource;
99   class FormatAttr;
100   class FriendDecl;
101   class FunctionDecl;
102   class FunctionProtoType;
103   class FunctionTemplateDecl;
104   class ImplicitConversionSequence;
105   class InitListExpr;
106   class InitializationKind;
107   class InitializationSequence;
108   class InitializedEntity;
109   class IntegerLiteral;
110   class LabelStmt;
111   class LambdaExpr;
112   class LangOptions;
113   class LocalInstantiationScope;
114   class LookupResult;
115   class MacroInfo;
116   class MultiLevelTemplateArgumentList;
117   class NamedDecl;
118   class NonNullAttr;
119   class ObjCCategoryDecl;
120   class ObjCCategoryImplDecl;
121   class ObjCCompatibleAliasDecl;
122   class ObjCContainerDecl;
123   class ObjCImplDecl;
124   class ObjCImplementationDecl;
125   class ObjCInterfaceDecl;
126   class ObjCIvarDecl;
127   template <class T> class ObjCList;
128   class ObjCMessageExpr;
129   class ObjCMethodDecl;
130   class ObjCPropertyDecl;
131   class ObjCProtocolDecl;
132   class OverloadCandidateSet;
133   class OverloadExpr;
134   class ParenListExpr;
135   class ParmVarDecl;
136   class Preprocessor;
137   class PseudoDestructorTypeStorage;
138   class PseudoObjectExpr;
139   class QualType;
140   class StandardConversionSequence;
141   class Stmt;
142   class StringLiteral;
143   class SwitchStmt;
144   class TargetAttributesSema;
145   class TemplateArgument;
146   class TemplateArgumentList;
147   class TemplateArgumentLoc;
148   class TemplateDecl;
149   class TemplateParameterList;
150   class TemplatePartialOrderingContext;
151   class TemplateTemplateParmDecl;
152   class Token;
153   class TypeAliasDecl;
154   class TypedefDecl;
155   class TypedefNameDecl;
156   class TypeLoc;
157   class UnqualifiedId;
158   class UnresolvedLookupExpr;
159   class UnresolvedMemberExpr;
160   class UnresolvedSetImpl;
161   class UnresolvedSetIterator;
162   class UsingDecl;
163   class UsingShadowDecl;
164   class ValueDecl;
165   class VarDecl;
166   class VisibilityAttr;
167   class VisibleDeclConsumer;
168   class IndirectFieldDecl;
169
170 namespace sema {
171   class AccessedEntity;
172   class BlockScopeInfo;
173   class CapturingScopeInfo;
174   class CompoundScopeInfo;
175   class DelayedDiagnostic;
176   class DelayedDiagnosticPool;
177   class FunctionScopeInfo;
178   class LambdaScopeInfo;
179   class PossiblyUnreachableDiag;
180   class TemplateDeductionInfo;
181 }
182
183 // FIXME: No way to easily map from TemplateTypeParmTypes to
184 // TemplateTypeParmDecls, so we have this horrible PointerUnion.
185 typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
186                   SourceLocation> UnexpandedParameterPack;
187
188 /// Sema - This implements semantic analysis and AST building for C.
189 class Sema {
190   Sema(const Sema&);           // DO NOT IMPLEMENT
191   void operator=(const Sema&); // DO NOT IMPLEMENT
192   mutable const TargetAttributesSema* TheTargetAttributesSema;
193 public:
194   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
195   typedef OpaquePtr<TemplateName> TemplateTy;
196   typedef OpaquePtr<QualType> TypeTy;
197
198   OpenCLOptions OpenCLFeatures;
199   FPOptions FPFeatures;
200
201   const LangOptions &LangOpts;
202   Preprocessor &PP;
203   ASTContext &Context;
204   ASTConsumer &Consumer;
205   DiagnosticsEngine &Diags;
206   SourceManager &SourceMgr;
207
208   /// \brief Flag indicating whether or not to collect detailed statistics.
209   bool CollectStats;
210
211   /// \brief Source of additional semantic information.
212   ExternalSemaSource *ExternalSource;
213
214   /// \brief Code-completion consumer.
215   CodeCompleteConsumer *CodeCompleter;
216
217   /// CurContext - This is the current declaration context of parsing.
218   DeclContext *CurContext;
219
220   /// \brief Generally null except when we temporarily switch decl contexts,
221   /// like in \see ActOnObjCTemporaryExitContainerContext.
222   DeclContext *OriginalLexicalContext;
223
224   /// VAListTagName - The declaration name corresponding to __va_list_tag.
225   /// This is used as part of a hack to omit that class from ADL results.
226   DeclarationName VAListTagName;
227
228   /// PackContext - Manages the stack for \#pragma pack. An alignment
229   /// of 0 indicates default alignment.
230   void *PackContext; // Really a "PragmaPackStack*"
231
232   bool MSStructPragmaOn; // True when \#pragma ms_struct on
233
234   /// VisContext - Manages the stack for \#pragma GCC visibility.
235   void *VisContext; // Really a "PragmaVisStack*"
236
237   /// ExprNeedsCleanups - True if the current evaluation context
238   /// requires cleanups to be run at its conclusion.
239   bool ExprNeedsCleanups;
240
241   /// ExprCleanupObjects - This is the stack of objects requiring
242   /// cleanup that are created by the current full expression.  The
243   /// element type here is ExprWithCleanups::Object.
244   SmallVector<BlockDecl*, 8> ExprCleanupObjects;
245
246   llvm::SmallPtrSet<Expr*, 8> MaybeODRUseExprs;
247
248   /// \brief Stack containing information about each of the nested
249   /// function, block, and method scopes that are currently active.
250   ///
251   /// This array is never empty.  Clients should ignore the first
252   /// element, which is used to cache a single FunctionScopeInfo
253   /// that's used to parse every top-level function.
254   SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
255
256   typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
257                      &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
258     ExtVectorDeclsType;
259
260   /// ExtVectorDecls - This is a list all the extended vector types. This allows
261   /// us to associate a raw vector type with one of the ext_vector type names.
262   /// This is only necessary for issuing pretty diagnostics.
263   ExtVectorDeclsType ExtVectorDecls;
264
265   /// \brief The set of types for which we have already complained about the
266   /// definitions being hidden.
267   ///
268   /// This set is used to suppress redundant diagnostics.
269   llvm::SmallPtrSet<NamedDecl *, 4> HiddenDefinitions;
270
271   /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
272   OwningPtr<CXXFieldCollector> FieldCollector;
273
274   typedef llvm::SmallSetVector<const NamedDecl*, 16> NamedDeclSetType;
275
276   /// \brief Set containing all declared private fields that are not used.
277   NamedDeclSetType UnusedPrivateFields;
278
279   typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
280
281   /// PureVirtualClassDiagSet - a set of class declarations which we have
282   /// emitted a list of pure virtual functions. Used to prevent emitting the
283   /// same list more than once.
284   OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
285
286   /// ParsingInitForAutoVars - a set of declarations with auto types for which
287   /// we are currently parsing the initializer.
288   llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
289
290   /// \brief A mapping from external names to the most recent
291   /// locally-scoped external declaration with that name.
292   ///
293   /// This map contains external declarations introduced in local
294   /// scoped, e.g.,
295   ///
296   /// \code
297   /// void f() {
298   ///   void foo(int, int);
299   /// }
300   /// \endcode
301   ///
302   /// Here, the name "foo" will be associated with the declaration on
303   /// "foo" within f. This name is not visible outside of
304   /// "f". However, we still find it in two cases:
305   ///
306   ///   - If we are declaring another external with the name "foo", we
307   ///     can find "foo" as a previous declaration, so that the types
308   ///     of this external declaration can be checked for
309   ///     compatibility.
310   ///
311   ///   - If we would implicitly declare "foo" (e.g., due to a call to
312   ///     "foo" in C when no prototype or definition is visible), then
313   ///     we find this declaration of "foo" and complain that it is
314   ///     not visible.
315   llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
316
317   /// \brief Look for a locally scoped external declaration by the given name.
318   llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
319   findLocallyScopedExternalDecl(DeclarationName Name);
320
321   typedef LazyVector<VarDecl *, ExternalSemaSource,
322                      &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
323     TentativeDefinitionsType;
324
325   /// \brief All the tentative definitions encountered in the TU.
326   TentativeDefinitionsType TentativeDefinitions;
327
328   typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
329                      &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
330     UnusedFileScopedDeclsType;
331
332   /// \brief The set of file scoped decls seen so far that have not been used
333   /// and must warn if not used. Only contains the first declaration.
334   UnusedFileScopedDeclsType UnusedFileScopedDecls;
335
336   typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
337                      &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
338     DelegatingCtorDeclsType;
339
340   /// \brief All the delegating constructors seen so far in the file, used for
341   /// cycle detection at the end of the TU.
342   DelegatingCtorDeclsType DelegatingCtorDecls;
343
344   /// \brief All the destructors seen during a class definition that had their
345   /// exception spec computation delayed because it depended on an unparsed
346   /// exception spec.
347   SmallVector<CXXDestructorDecl*, 2> DelayedDestructorExceptionSpecs;
348
349   /// \brief All the overriding destructors seen during a class definition
350   /// (there could be multiple due to nested classes) that had their exception
351   /// spec checks delayed, plus the overridden destructor.
352   SmallVector<std::pair<const CXXDestructorDecl*,
353                               const CXXDestructorDecl*>, 2>
354       DelayedDestructorExceptionSpecChecks;
355
356   /// \brief Callback to the parser to parse templated functions when needed.
357   typedef void LateTemplateParserCB(void *P, const FunctionDecl *FD);
358   LateTemplateParserCB *LateTemplateParser;
359   void *OpaqueParser;
360
361   void SetLateTemplateParser(LateTemplateParserCB *LTP, void *P) {
362     LateTemplateParser = LTP;
363     OpaqueParser = P;
364   }
365
366   class DelayedDiagnostics;
367
368   class DelayedDiagnosticsState {
369     sema::DelayedDiagnosticPool *SavedPool;
370     friend class Sema::DelayedDiagnostics;
371   };
372   typedef DelayedDiagnosticsState ParsingDeclState;
373   typedef DelayedDiagnosticsState ProcessingContextState;
374
375   /// A class which encapsulates the logic for delaying diagnostics
376   /// during parsing and other processing.
377   class DelayedDiagnostics {
378     /// \brief The current pool of diagnostics into which delayed
379     /// diagnostics should go.
380     sema::DelayedDiagnosticPool *CurPool;
381
382   public:
383     DelayedDiagnostics() : CurPool(0) {}
384
385     /// Adds a delayed diagnostic.
386     void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
387
388     /// Determines whether diagnostics should be delayed.
389     bool shouldDelayDiagnostics() { return CurPool != 0; }
390
391     /// Returns the current delayed-diagnostics pool.
392     sema::DelayedDiagnosticPool *getCurrentPool() const {
393       return CurPool;
394     }
395
396     /// Enter a new scope.  Access and deprecation diagnostics will be
397     /// collected in this pool.
398     DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
399       DelayedDiagnosticsState state;
400       state.SavedPool = CurPool;
401       CurPool = &pool;
402       return state;
403     }
404
405     /// Leave a delayed-diagnostic state that was previously pushed.
406     /// Do not emit any of the diagnostics.  This is performed as part
407     /// of the bookkeeping of popping a pool "properly".
408     void popWithoutEmitting(DelayedDiagnosticsState state) {
409       CurPool = state.SavedPool;
410     }
411
412     /// Enter a new scope where access and deprecation diagnostics are
413     /// not delayed.
414     DelayedDiagnosticsState pushUndelayed() {
415       DelayedDiagnosticsState state;
416       state.SavedPool = CurPool;
417       CurPool = 0;
418       return state;
419     }
420
421     /// Undo a previous pushUndelayed().
422     void popUndelayed(DelayedDiagnosticsState state) {
423       assert(CurPool == NULL);
424       CurPool = state.SavedPool;
425     }
426   } DelayedDiagnostics;
427
428   /// A RAII object to temporarily push a declaration context.
429   class ContextRAII {
430   private:
431     Sema &S;
432     DeclContext *SavedContext;
433     ProcessingContextState SavedContextState;
434     QualType SavedCXXThisTypeOverride;
435
436   public:
437     ContextRAII(Sema &S, DeclContext *ContextToPush)
438       : S(S), SavedContext(S.CurContext),
439         SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
440         SavedCXXThisTypeOverride(S.CXXThisTypeOverride)
441     {
442       assert(ContextToPush && "pushing null context");
443       S.CurContext = ContextToPush;
444     }
445
446     void pop() {
447       if (!SavedContext) return;
448       S.CurContext = SavedContext;
449       S.DelayedDiagnostics.popUndelayed(SavedContextState);
450       S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
451       SavedContext = 0;
452     }
453
454     ~ContextRAII() {
455       pop();
456     }
457   };
458
459   /// WeakUndeclaredIdentifiers - Identifiers contained in
460   /// \#pragma weak before declared. rare. may alias another
461   /// identifier, declared or undeclared
462   llvm::DenseMap<IdentifierInfo*,WeakInfo> WeakUndeclaredIdentifiers;
463
464   /// ExtnameUndeclaredIdentifiers - Identifiers contained in
465   /// \#pragma redefine_extname before declared.  Used in Solaris system headers
466   /// to define functions that occur in multiple standards to call the version
467   /// in the currently selected standard.
468   llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
469
470
471   /// \brief Load weak undeclared identifiers from the external source.
472   void LoadExternalWeakUndeclaredIdentifiers();
473
474   /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
475   /// \#pragma weak during processing of other Decls.
476   /// I couldn't figure out a clean way to generate these in-line, so
477   /// we store them here and handle separately -- which is a hack.
478   /// It would be best to refactor this.
479   SmallVector<Decl*,2> WeakTopLevelDecl;
480
481   IdentifierResolver IdResolver;
482
483   /// Translation Unit Scope - useful to Objective-C actions that need
484   /// to lookup file scope declarations in the "ordinary" C decl namespace.
485   /// For example, user-defined classes, built-in "id" type, etc.
486   Scope *TUScope;
487
488   /// \brief The C++ "std" namespace, where the standard library resides.
489   LazyDeclPtr StdNamespace;
490
491   /// \brief The C++ "std::bad_alloc" class, which is defined by the C++
492   /// standard library.
493   LazyDeclPtr StdBadAlloc;
494
495   /// \brief The C++ "std::initializer_list" template, which is defined in
496   /// \<initializer_list>.
497   ClassTemplateDecl *StdInitializerList;
498
499   /// \brief The C++ "type_info" declaration, which is defined in \<typeinfo>.
500   RecordDecl *CXXTypeInfoDecl;
501
502   /// \brief The MSVC "_GUID" struct, which is defined in MSVC header files.
503   RecordDecl *MSVCGuidDecl;
504
505   /// \brief Caches identifiers/selectors for NSFoundation APIs.
506   llvm::OwningPtr<NSAPI> NSAPIObj;
507
508   /// \brief The declaration of the Objective-C NSNumber class.
509   ObjCInterfaceDecl *NSNumberDecl;
510
511   /// \brief Pointer to NSNumber type (NSNumber *).
512   QualType NSNumberPointer;
513
514   /// \brief The Objective-C NSNumber methods used to create NSNumber literals.
515   ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
516
517   /// \brief The declaration of the Objective-C NSString class.
518   ObjCInterfaceDecl *NSStringDecl;
519
520   /// \brief Pointer to NSString type (NSString *).
521   QualType NSStringPointer;
522
523   /// \brief The declaration of the stringWithUTF8String: method.
524   ObjCMethodDecl *StringWithUTF8StringMethod;
525
526   /// \brief The declaration of the Objective-C NSArray class.
527   ObjCInterfaceDecl *NSArrayDecl;
528
529   /// \brief The declaration of the arrayWithObjects:count: method.
530   ObjCMethodDecl *ArrayWithObjectsMethod;
531
532   /// \brief The declaration of the Objective-C NSDictionary class.
533   ObjCInterfaceDecl *NSDictionaryDecl;
534
535   /// \brief The declaration of the dictionaryWithObjects:forKeys:count: method.
536   ObjCMethodDecl *DictionaryWithObjectsMethod;
537
538   /// \brief id<NSCopying> type.
539   QualType QIDNSCopying;
540
541   /// A flag to remember whether the implicit forms of operator new and delete
542   /// have been declared.
543   bool GlobalNewDeleteDeclared;
544
545   /// \brief Describes how the expressions currently being parsed are
546   /// evaluated at run-time, if at all.
547   enum ExpressionEvaluationContext {
548     /// \brief The current expression and its subexpressions occur within an
549     /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
550     /// \c sizeof, where the type of the expression may be significant but
551     /// no code will be generated to evaluate the value of the expression at
552     /// run time.
553     Unevaluated,
554
555     /// \brief The current context is "potentially evaluated" in C++11 terms,
556     /// but the expression is evaluated at compile-time (like the values of
557     /// cases in a switch statment).
558     ConstantEvaluated,
559
560     /// \brief The current expression is potentially evaluated at run time,
561     /// which means that code may be generated to evaluate the value of the
562     /// expression at run time.
563     PotentiallyEvaluated,
564
565     /// \brief The current expression is potentially evaluated, but any
566     /// declarations referenced inside that expression are only used if
567     /// in fact the current expression is used.
568     ///
569     /// This value is used when parsing default function arguments, for which
570     /// we would like to provide diagnostics (e.g., passing non-POD arguments
571     /// through varargs) but do not want to mark declarations as "referenced"
572     /// until the default argument is used.
573     PotentiallyEvaluatedIfUsed
574   };
575
576   /// \brief Data structure used to record current or nested
577   /// expression evaluation contexts.
578   struct ExpressionEvaluationContextRecord {
579     /// \brief The expression evaluation context.
580     ExpressionEvaluationContext Context;
581
582     /// \brief Whether the enclosing context needed a cleanup.
583     bool ParentNeedsCleanups;
584
585     /// \brief Whether we are in a decltype expression.
586     bool IsDecltype;
587
588     /// \brief The number of active cleanup objects when we entered
589     /// this expression evaluation context.
590     unsigned NumCleanupObjects;
591
592     llvm::SmallPtrSet<Expr*, 8> SavedMaybeODRUseExprs;
593
594     /// \brief The lambdas that are present within this context, if it
595     /// is indeed an unevaluated context.
596     llvm::SmallVector<LambdaExpr *, 2> Lambdas;
597
598     /// \brief The declaration that provides context for the lambda expression
599     /// if the normal declaration context does not suffice, e.g., in a
600     /// default function argument.
601     Decl *LambdaContextDecl;
602
603     /// \brief The context information used to mangle lambda expressions
604     /// within this context.
605     ///
606     /// This mangling information is allocated lazily, since most contexts
607     /// do not have lambda expressions.
608     LambdaMangleContext *LambdaMangle;
609
610     /// \brief If we are processing a decltype type, a set of call expressions
611     /// for which we have deferred checking the completeness of the return type.
612     llvm::SmallVector<CallExpr*, 8> DelayedDecltypeCalls;
613
614     /// \brief If we are processing a decltype type, a set of temporary binding
615     /// expressions for which we have deferred checking the destructor.
616     llvm::SmallVector<CXXBindTemporaryExpr*, 8> DelayedDecltypeBinds;
617
618     ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
619                                       unsigned NumCleanupObjects,
620                                       bool ParentNeedsCleanups,
621                                       Decl *LambdaContextDecl,
622                                       bool IsDecltype)
623       : Context(Context), ParentNeedsCleanups(ParentNeedsCleanups),
624         IsDecltype(IsDecltype), NumCleanupObjects(NumCleanupObjects),
625         LambdaContextDecl(LambdaContextDecl), LambdaMangle() { }
626
627     ~ExpressionEvaluationContextRecord() {
628       delete LambdaMangle;
629     }
630
631     /// \brief Retrieve the mangling context for lambdas.
632     LambdaMangleContext &getLambdaMangleContext() {
633       assert(LambdaContextDecl && "Need to have a lambda context declaration");
634       if (!LambdaMangle)
635         LambdaMangle = new LambdaMangleContext;
636       return *LambdaMangle;
637     }
638   };
639
640   /// A stack of expression evaluation contexts.
641   SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
642
643   /// SpecialMemberOverloadResult - The overloading result for a special member
644   /// function.
645   ///
646   /// This is basically a wrapper around PointerIntPair. The lowest bits of the
647   /// integer are used to determine whether overload resolution succeeded.
648   class SpecialMemberOverloadResult : public llvm::FastFoldingSetNode {
649   public:
650     enum Kind {
651       NoMemberOrDeleted,
652       Ambiguous,
653       Success
654     };
655
656   private:
657     llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
658
659   public:
660     SpecialMemberOverloadResult(const llvm::FoldingSetNodeID &ID)
661       : FastFoldingSetNode(ID)
662     {}
663
664     CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
665     void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
666
667     Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
668     void setKind(Kind K) { Pair.setInt(K); }
669   };
670
671   /// \brief A cache of special member function overload resolution results
672   /// for C++ records.
673   llvm::FoldingSet<SpecialMemberOverloadResult> SpecialMemberCache;
674
675   /// \brief The kind of translation unit we are processing.
676   ///
677   /// When we're processing a complete translation unit, Sema will perform
678   /// end-of-translation-unit semantic tasks (such as creating
679   /// initializers for tentative definitions in C) once parsing has
680   /// completed. Modules and precompiled headers perform different kinds of
681   /// checks.
682   TranslationUnitKind TUKind;
683
684   llvm::BumpPtrAllocator BumpAlloc;
685
686   /// \brief The number of SFINAE diagnostics that have been trapped.
687   unsigned NumSFINAEErrors;
688
689   typedef llvm::DenseMap<ParmVarDecl *, SmallVector<ParmVarDecl *, 1> >
690     UnparsedDefaultArgInstantiationsMap;
691
692   /// \brief A mapping from parameters with unparsed default arguments to the
693   /// set of instantiations of each parameter.
694   ///
695   /// This mapping is a temporary data structure used when parsing
696   /// nested class templates or nested classes of class templates,
697   /// where we might end up instantiating an inner class before the
698   /// default arguments of its methods have been parsed.
699   UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
700
701   // Contains the locations of the beginning of unparsed default
702   // argument locations.
703   llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
704
705   /// UndefinedInternals - all the used, undefined objects with
706   /// internal linkage in this translation unit.
707   llvm::DenseMap<NamedDecl*, SourceLocation> UndefinedInternals;
708
709   typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
710   typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
711
712   /// Method Pool - allows efficient lookup when typechecking messages to "id".
713   /// We need to maintain a list, since selectors can have differing signatures
714   /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
715   /// of selectors are "overloaded").
716   GlobalMethodPool MethodPool;
717
718   /// Method selectors used in a \@selector expression. Used for implementation
719   /// of -Wselector.
720   llvm::DenseMap<Selector, SourceLocation> ReferencedSelectors;
721
722   void ReadMethodPool(Selector Sel);
723
724   /// Private Helper predicate to check for 'self'.
725   bool isSelfExpr(Expr *RExpr);
726
727   /// \brief Cause the active diagnostic on the DiagosticsEngine to be
728   /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
729   /// should not be used elsewhere.
730   void EmitCurrentDiagnostic(unsigned DiagID);
731
732 public:
733   Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
734        TranslationUnitKind TUKind = TU_Complete,
735        CodeCompleteConsumer *CompletionConsumer = 0);
736   ~Sema();
737
738   /// \brief Perform initialization that occurs after the parser has been
739   /// initialized but before it parses anything.
740   void Initialize();
741
742   const LangOptions &getLangOpts() const { return LangOpts; }
743   OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
744   FPOptions     &getFPOptions() { return FPFeatures; }
745
746   DiagnosticsEngine &getDiagnostics() const { return Diags; }
747   SourceManager &getSourceManager() const { return SourceMgr; }
748   const TargetAttributesSema &getTargetAttributesSema() const;
749   Preprocessor &getPreprocessor() const { return PP; }
750   ASTContext &getASTContext() const { return Context; }
751   ASTConsumer &getASTConsumer() const { return Consumer; }
752   ASTMutationListener *getASTMutationListener() const;
753
754   void PrintStats() const;
755
756   /// \brief Helper class that creates diagnostics with optional
757   /// template instantiation stacks.
758   ///
759   /// This class provides a wrapper around the basic DiagnosticBuilder
760   /// class that emits diagnostics. SemaDiagnosticBuilder is
761   /// responsible for emitting the diagnostic (as DiagnosticBuilder
762   /// does) and, if the diagnostic comes from inside a template
763   /// instantiation, printing the template instantiation stack as
764   /// well.
765   class SemaDiagnosticBuilder : public DiagnosticBuilder {
766     Sema &SemaRef;
767     unsigned DiagID;
768
769   public:
770     SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
771       : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
772
773     ~SemaDiagnosticBuilder() {
774       // If we aren't active, there is nothing to do.
775       if (!isActive()) return;
776
777       // Otherwise, we need to emit the diagnostic. First flush the underlying
778       // DiagnosticBuilder data, and clear the diagnostic builder itself so it
779       // won't emit the diagnostic in its own destructor.
780       //
781       // This seems wasteful, in that as written the DiagnosticBuilder dtor will
782       // do its own needless checks to see if the diagnostic needs to be
783       // emitted. However, because we take care to ensure that the builder
784       // objects never escape, a sufficiently smart compiler will be able to
785       // eliminate that code.
786       FlushCounts();
787       Clear();
788
789       // Dispatch to Sema to emit the diagnostic.
790       SemaRef.EmitCurrentDiagnostic(DiagID);
791     }
792   };
793
794   /// \brief Emit a diagnostic.
795   SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
796     DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
797     return SemaDiagnosticBuilder(DB, *this, DiagID);
798   }
799
800   /// \brief Emit a partial diagnostic.
801   SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic& PD);
802
803   /// \brief Build a partial diagnostic.
804   PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
805
806   bool findMacroSpelling(SourceLocation &loc, StringRef name);
807
808   /// \brief Get a string to suggest for zero-initialization of a type.
809   std::string getFixItZeroInitializerForType(QualType T) const;
810   std::string getFixItZeroLiteralForType(QualType T) const;
811
812   ExprResult Owned(Expr* E) { return E; }
813   ExprResult Owned(ExprResult R) { return R; }
814   StmtResult Owned(Stmt* S) { return S; }
815
816   void ActOnEndOfTranslationUnit();
817
818   void CheckDelegatingCtorCycles();
819
820   Scope *getScopeForContext(DeclContext *Ctx);
821
822   void PushFunctionScope();
823   void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
824   void PushLambdaScope(CXXRecordDecl *Lambda, CXXMethodDecl *CallOperator);
825   void PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP =0,
826                             const Decl *D = 0, const BlockExpr *blkExpr = 0);
827
828   sema::FunctionScopeInfo *getCurFunction() const {
829     return FunctionScopes.back();
830   }
831
832   void PushCompoundScope();
833   void PopCompoundScope();
834
835   sema::CompoundScopeInfo &getCurCompoundScope() const;
836
837   bool hasAnyUnrecoverableErrorsInThisFunction() const;
838
839   /// \brief Retrieve the current block, if any.
840   sema::BlockScopeInfo *getCurBlock();
841
842   /// \brief Retrieve the current lambda expression, if any.
843   sema::LambdaScopeInfo *getCurLambda();
844
845   /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
846   SmallVector<Decl*,2> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
847
848   void ActOnComment(SourceRange Comment);
849
850   //===--------------------------------------------------------------------===//
851   // Type Analysis / Processing: SemaType.cpp.
852   //
853
854   QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs);
855   QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVR) {
856     return BuildQualifiedType(T, Loc, Qualifiers::fromCVRMask(CVR));
857   }
858   QualType BuildPointerType(QualType T,
859                             SourceLocation Loc, DeclarationName Entity);
860   QualType BuildReferenceType(QualType T, bool LValueRef,
861                               SourceLocation Loc, DeclarationName Entity);
862   QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
863                           Expr *ArraySize, unsigned Quals,
864                           SourceRange Brackets, DeclarationName Entity);
865   QualType BuildExtVectorType(QualType T, Expr *ArraySize,
866                               SourceLocation AttrLoc);
867   QualType BuildFunctionType(QualType T,
868                              QualType *ParamTypes, unsigned NumParamTypes,
869                              bool Variadic, bool HasTrailingReturn,
870                              unsigned Quals, RefQualifierKind RefQualifier,
871                              SourceLocation Loc, DeclarationName Entity,
872                              FunctionType::ExtInfo Info);
873   QualType BuildMemberPointerType(QualType T, QualType Class,
874                                   SourceLocation Loc,
875                                   DeclarationName Entity);
876   QualType BuildBlockPointerType(QualType T,
877                                  SourceLocation Loc, DeclarationName Entity);
878   QualType BuildParenType(QualType T);
879   QualType BuildAtomicType(QualType T, SourceLocation Loc);
880
881   TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
882   TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
883   TypeSourceInfo *GetTypeSourceInfoForDeclarator(Declarator &D, QualType T,
884                                                TypeSourceInfo *ReturnTypeInfo);
885
886   /// \brief Package the given type and TSI into a ParsedType.
887   ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
888   DeclarationNameInfo GetNameForDeclarator(Declarator &D);
889   DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
890   static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo = 0);
891   CanThrowResult canThrow(const Expr *E);
892   const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
893                                                 const FunctionProtoType *FPT);
894   bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range);
895   bool CheckDistantExceptionSpec(QualType T);
896   bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
897   bool CheckEquivalentExceptionSpec(
898       const FunctionProtoType *Old, SourceLocation OldLoc,
899       const FunctionProtoType *New, SourceLocation NewLoc);
900   bool CheckEquivalentExceptionSpec(
901       const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
902       const FunctionProtoType *Old, SourceLocation OldLoc,
903       const FunctionProtoType *New, SourceLocation NewLoc,
904       bool *MissingExceptionSpecification = 0,
905       bool *MissingEmptyExceptionSpecification = 0,
906       bool AllowNoexceptAllMatchWithNoSpec = false,
907       bool IsOperatorNew = false);
908   bool CheckExceptionSpecSubset(
909       const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
910       const FunctionProtoType *Superset, SourceLocation SuperLoc,
911       const FunctionProtoType *Subset, SourceLocation SubLoc);
912   bool CheckParamExceptionSpec(const PartialDiagnostic & NoteID,
913       const FunctionProtoType *Target, SourceLocation TargetLoc,
914       const FunctionProtoType *Source, SourceLocation SourceLoc);
915
916   TypeResult ActOnTypeName(Scope *S, Declarator &D);
917
918   /// \brief The parser has parsed the context-sensitive type 'instancetype'
919   /// in an Objective-C message declaration. Return the appropriate type.
920   ParsedType ActOnObjCInstanceType(SourceLocation Loc);
921
922   /// \brief Abstract class used to diagnose incomplete types.
923   struct TypeDiagnoser {
924     bool Suppressed;
925
926     TypeDiagnoser(bool Suppressed = false) : Suppressed(Suppressed) { }
927
928     virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
929     virtual ~TypeDiagnoser() {}
930   };
931
932   static int getPrintable(int I) { return I; }
933   static unsigned getPrintable(unsigned I) { return I; }
934   static bool getPrintable(bool B) { return B; }
935   static const char * getPrintable(const char *S) { return S; }
936   static StringRef getPrintable(StringRef S) { return S; }
937   static const std::string &getPrintable(const std::string &S) { return S; }
938   static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
939     return II;
940   }
941   static DeclarationName getPrintable(DeclarationName N) { return N; }
942   static QualType getPrintable(QualType T) { return T; }
943   static SourceRange getPrintable(SourceRange R) { return R; }
944   static SourceRange getPrintable(SourceLocation L) { return L; }
945   static SourceRange getPrintable(Expr *E) { return E->getSourceRange(); }
946   static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
947
948   template<typename T1>
949   class BoundTypeDiagnoser1 : public TypeDiagnoser {
950     unsigned DiagID;
951     const T1 &Arg1;
952
953   public:
954     BoundTypeDiagnoser1(unsigned DiagID, const T1 &Arg1)
955       : TypeDiagnoser(DiagID == 0), DiagID(DiagID), Arg1(Arg1) { }
956     virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
957       if (Suppressed) return;
958       S.Diag(Loc, DiagID) << getPrintable(Arg1) << T;
959     }
960
961     virtual ~BoundTypeDiagnoser1() { }
962   };
963
964   template<typename T1, typename T2>
965   class BoundTypeDiagnoser2 : public TypeDiagnoser {
966     unsigned DiagID;
967     const T1 &Arg1;
968     const T2 &Arg2;
969
970   public:
971     BoundTypeDiagnoser2(unsigned DiagID, const T1 &Arg1,
972                                   const T2 &Arg2)
973       : TypeDiagnoser(DiagID == 0), DiagID(DiagID), Arg1(Arg1),
974         Arg2(Arg2) { }
975
976     virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
977       if (Suppressed) return;
978       S.Diag(Loc, DiagID) << getPrintable(Arg1) << getPrintable(Arg2) << T;
979     }
980
981     virtual ~BoundTypeDiagnoser2() { }
982   };
983
984   template<typename T1, typename T2, typename T3>
985   class BoundTypeDiagnoser3 : public TypeDiagnoser {
986     unsigned DiagID;
987     const T1 &Arg1;
988     const T2 &Arg2;
989     const T3 &Arg3;
990
991   public:
992     BoundTypeDiagnoser3(unsigned DiagID, const T1 &Arg1,
993                                   const T2 &Arg2, const T3 &Arg3)
994     : TypeDiagnoser(DiagID == 0), DiagID(DiagID), Arg1(Arg1),
995       Arg2(Arg2), Arg3(Arg3) { }
996
997     virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
998       if (Suppressed) return;
999       S.Diag(Loc, DiagID)
1000         << getPrintable(Arg1) << getPrintable(Arg2) << getPrintable(Arg3) << T;
1001     }
1002
1003     virtual ~BoundTypeDiagnoser3() { }
1004   };
1005
1006   bool RequireCompleteType(SourceLocation Loc, QualType T,
1007                            TypeDiagnoser &Diagnoser);
1008   bool RequireCompleteType(SourceLocation Loc, QualType T,
1009                            unsigned DiagID);
1010
1011   template<typename T1>
1012   bool RequireCompleteType(SourceLocation Loc, QualType T,
1013                            unsigned DiagID, const T1 &Arg1) {
1014     BoundTypeDiagnoser1<T1> Diagnoser(DiagID, Arg1);
1015     return RequireCompleteType(Loc, T, Diagnoser);
1016   }
1017
1018   template<typename T1, typename T2>
1019   bool RequireCompleteType(SourceLocation Loc, QualType T,
1020                            unsigned DiagID, const T1 &Arg1, const T2 &Arg2) {
1021     BoundTypeDiagnoser2<T1, T2> Diagnoser(DiagID, Arg1, Arg2);
1022     return RequireCompleteType(Loc, T, Diagnoser);
1023   }
1024
1025   template<typename T1, typename T2, typename T3>
1026   bool RequireCompleteType(SourceLocation Loc, QualType T,
1027                            unsigned DiagID, const T1 &Arg1, const T2 &Arg2,
1028                            const T3 &Arg3) {
1029     BoundTypeDiagnoser3<T1, T2, T3> Diagnoser(DiagID, Arg1, Arg2,
1030                                                         Arg3);
1031     return RequireCompleteType(Loc, T, Diagnoser);
1032   }
1033
1034   bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser);
1035   bool RequireCompleteExprType(Expr *E, unsigned DiagID);
1036
1037   template<typename T1>
1038   bool RequireCompleteExprType(Expr *E, unsigned DiagID, const T1 &Arg1) {
1039     BoundTypeDiagnoser1<T1> Diagnoser(DiagID, Arg1);
1040     return RequireCompleteExprType(E, Diagnoser);
1041   }
1042
1043   template<typename T1, typename T2>
1044   bool RequireCompleteExprType(Expr *E, unsigned DiagID, const T1 &Arg1,
1045                                const T2 &Arg2) {
1046     BoundTypeDiagnoser2<T1, T2> Diagnoser(DiagID, Arg1, Arg2);
1047     return RequireCompleteExprType(E, Diagnoser);
1048   }
1049
1050   template<typename T1, typename T2, typename T3>
1051   bool RequireCompleteExprType(Expr *E, unsigned DiagID, const T1 &Arg1,
1052                                const T2 &Arg2, const T3 &Arg3) {
1053     BoundTypeDiagnoser3<T1, T2, T3> Diagnoser(DiagID, Arg1, Arg2,
1054                                                         Arg3);
1055     return RequireCompleteExprType(E, Diagnoser);
1056   }
1057
1058   bool RequireLiteralType(SourceLocation Loc, QualType T,
1059                           TypeDiagnoser &Diagnoser);
1060   bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
1061
1062   template<typename T1>
1063   bool RequireLiteralType(SourceLocation Loc, QualType T,
1064                           unsigned DiagID, const T1 &Arg1) {
1065     BoundTypeDiagnoser1<T1> Diagnoser(DiagID, Arg1);
1066     return RequireLiteralType(Loc, T, Diagnoser);
1067   }
1068
1069   template<typename T1, typename T2>
1070   bool RequireLiteralType(SourceLocation Loc, QualType T,
1071                           unsigned DiagID, const T1 &Arg1, const T2 &Arg2) {
1072     BoundTypeDiagnoser2<T1, T2> Diagnoser(DiagID, Arg1, Arg2);
1073     return RequireLiteralType(Loc, T, Diagnoser);
1074   }
1075
1076   template<typename T1, typename T2, typename T3>
1077   bool RequireLiteralType(SourceLocation Loc, QualType T,
1078                           unsigned DiagID, const T1 &Arg1, const T2 &Arg2,
1079                           const T3 &Arg3) {
1080     BoundTypeDiagnoser3<T1, T2, T3> Diagnoser(DiagID, Arg1, Arg2,
1081                                                         Arg3);
1082     return RequireLiteralType(Loc, T, Diagnoser);
1083   }
1084
1085   QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
1086                              const CXXScopeSpec &SS, QualType T);
1087
1088   QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
1089   QualType BuildDecltypeType(Expr *E, SourceLocation Loc);
1090   QualType BuildUnaryTransformType(QualType BaseType,
1091                                    UnaryTransformType::UTTKind UKind,
1092                                    SourceLocation Loc);
1093
1094   //===--------------------------------------------------------------------===//
1095   // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
1096   //
1097
1098   /// List of decls defined in a function prototype. This contains EnumConstants
1099   /// that incorrectly end up in translation unit scope because there is no
1100   /// function to pin them on. ActOnFunctionDeclarator reads this list and patches
1101   /// them into the FunctionDecl.
1102   std::vector<NamedDecl*> DeclsInPrototypeScope;
1103   /// Nonzero if we are currently parsing a function declarator. This is a counter
1104   /// as opposed to a boolean so we can deal with nested function declarators
1105   /// such as:
1106   ///     void f(void (*g)(), ...)
1107   unsigned InFunctionDeclarator;
1108
1109   DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = 0);
1110
1111   void DiagnoseUseOfUnimplementedSelectors();
1112
1113   bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
1114
1115   ParsedType getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
1116                          Scope *S, CXXScopeSpec *SS = 0,
1117                          bool isClassName = false,
1118                          bool HasTrailingDot = false,
1119                          ParsedType ObjectType = ParsedType(),
1120                          bool IsCtorOrDtorName = false,
1121                          bool WantNontrivialTypeSourceInfo = false,
1122                          IdentifierInfo **CorrectedII = 0);
1123   TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
1124   bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
1125   bool DiagnoseUnknownTypeName(IdentifierInfo *&II,
1126                                SourceLocation IILoc,
1127                                Scope *S,
1128                                CXXScopeSpec *SS,
1129                                ParsedType &SuggestedType);
1130
1131   /// \brief Describes the result of the name lookup and resolution performed
1132   /// by \c ClassifyName().
1133   enum NameClassificationKind {
1134     NC_Unknown,
1135     NC_Error,
1136     NC_Keyword,
1137     NC_Type,
1138     NC_Expression,
1139     NC_NestedNameSpecifier,
1140     NC_TypeTemplate,
1141     NC_FunctionTemplate
1142   };
1143
1144   class NameClassification {
1145     NameClassificationKind Kind;
1146     ExprResult Expr;
1147     TemplateName Template;
1148     ParsedType Type;
1149     const IdentifierInfo *Keyword;
1150
1151     explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
1152
1153   public:
1154     NameClassification(ExprResult Expr) : Kind(NC_Expression), Expr(Expr) {}
1155
1156     NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
1157
1158     NameClassification(const IdentifierInfo *Keyword)
1159       : Kind(NC_Keyword), Keyword(Keyword) { }
1160
1161     static NameClassification Error() {
1162       return NameClassification(NC_Error);
1163     }
1164
1165     static NameClassification Unknown() {
1166       return NameClassification(NC_Unknown);
1167     }
1168
1169     static NameClassification NestedNameSpecifier() {
1170       return NameClassification(NC_NestedNameSpecifier);
1171     }
1172
1173     static NameClassification TypeTemplate(TemplateName Name) {
1174       NameClassification Result(NC_TypeTemplate);
1175       Result.Template = Name;
1176       return Result;
1177     }
1178
1179     static NameClassification FunctionTemplate(TemplateName Name) {
1180       NameClassification Result(NC_FunctionTemplate);
1181       Result.Template = Name;
1182       return Result;
1183     }
1184
1185     NameClassificationKind getKind() const { return Kind; }
1186
1187     ParsedType getType() const {
1188       assert(Kind == NC_Type);
1189       return Type;
1190     }
1191
1192     ExprResult getExpression() const {
1193       assert(Kind == NC_Expression);
1194       return Expr;
1195     }
1196
1197     TemplateName getTemplateName() const {
1198       assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate);
1199       return Template;
1200     }
1201
1202     TemplateNameKind getTemplateNameKind() const {
1203       assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate);
1204       return Kind == NC_TypeTemplate? TNK_Type_template : TNK_Function_template;
1205     }
1206 };
1207
1208   /// \brief Perform name lookup on the given name, classifying it based on
1209   /// the results of name lookup and the following token.
1210   ///
1211   /// This routine is used by the parser to resolve identifiers and help direct
1212   /// parsing. When the identifier cannot be found, this routine will attempt
1213   /// to correct the typo and classify based on the resulting name.
1214   ///
1215   /// \param S The scope in which we're performing name lookup.
1216   ///
1217   /// \param SS The nested-name-specifier that precedes the name.
1218   ///
1219   /// \param Name The identifier. If typo correction finds an alternative name,
1220   /// this pointer parameter will be updated accordingly.
1221   ///
1222   /// \param NameLoc The location of the identifier.
1223   ///
1224   /// \param NextToken The token following the identifier. Used to help
1225   /// disambiguate the name.
1226   NameClassification ClassifyName(Scope *S,
1227                                   CXXScopeSpec &SS,
1228                                   IdentifierInfo *&Name,
1229                                   SourceLocation NameLoc,
1230                                   const Token &NextToken);
1231
1232   Decl *ActOnDeclarator(Scope *S, Declarator &D);
1233
1234   Decl *HandleDeclarator(Scope *S, Declarator &D,
1235                          MultiTemplateParamsArg TemplateParameterLists);
1236   void RegisterLocallyScopedExternCDecl(NamedDecl *ND,
1237                                         const LookupResult &Previous,
1238                                         Scope *S);
1239   bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
1240   bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
1241                                     DeclarationName Name,
1242                                     SourceLocation Loc);
1243   void DiagnoseFunctionSpecifiers(Declarator& D);
1244   void CheckShadow(Scope *S, VarDecl *D, const LookupResult& R);
1245   void CheckShadow(Scope *S, VarDecl *D);
1246   void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
1247   void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
1248   NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1249                                     TypeSourceInfo *TInfo,
1250                                     LookupResult &Previous);
1251   NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
1252                                   LookupResult &Previous, bool &Redeclaration);
1253   NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1254                                      TypeSourceInfo *TInfo,
1255                                      LookupResult &Previous,
1256                                      MultiTemplateParamsArg TemplateParamLists);
1257   // Returns true if the variable declaration is a redeclaration
1258   bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
1259   void CheckCompleteVariableDeclaration(VarDecl *var);
1260   void ActOnStartFunctionDeclarator();
1261   void ActOnEndFunctionDeclarator();
1262   NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1263                                      TypeSourceInfo *TInfo,
1264                                      LookupResult &Previous,
1265                                      MultiTemplateParamsArg TemplateParamLists,
1266                                      bool &AddToScope);
1267   bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
1268
1269   bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
1270   bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
1271
1272   void DiagnoseHiddenVirtualMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
1273   // Returns true if the function declaration is a redeclaration
1274   bool CheckFunctionDeclaration(Scope *S,
1275                                 FunctionDecl *NewFD, LookupResult &Previous,
1276                                 bool IsExplicitSpecialization);
1277   void CheckMain(FunctionDecl *FD, const DeclSpec &D);
1278   Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
1279   ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
1280                                           SourceLocation Loc,
1281                                           QualType T);
1282   ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
1283                               SourceLocation NameLoc, IdentifierInfo *Name,
1284                               QualType T, TypeSourceInfo *TSInfo,
1285                               StorageClass SC, StorageClass SCAsWritten);
1286   void ActOnParamDefaultArgument(Decl *param,
1287                                  SourceLocation EqualLoc,
1288                                  Expr *defarg);
1289   void ActOnParamUnparsedDefaultArgument(Decl *param,
1290                                          SourceLocation EqualLoc,
1291                                          SourceLocation ArgLoc);
1292   void ActOnParamDefaultArgumentError(Decl *param);
1293   bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
1294                                SourceLocation EqualLoc);
1295
1296   void CheckSelfReference(Decl *OrigDecl, Expr *E);
1297   void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit,
1298                             bool TypeMayContainAuto);
1299   void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto);
1300   void ActOnInitializerError(Decl *Dcl);
1301   void ActOnCXXForRangeDecl(Decl *D);
1302   void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
1303   void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
1304   void FinalizeDeclaration(Decl *D);
1305   DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
1306                                          Decl **Group,
1307                                          unsigned NumDecls);
1308   DeclGroupPtrTy BuildDeclaratorGroup(Decl **Group, unsigned NumDecls,
1309                                       bool TypeMayContainAuto = true);
1310
1311   /// Should be called on all declarations that might have attached
1312   /// documentation comments.
1313   void ActOnDocumentableDecl(Decl *D);
1314   void ActOnDocumentableDecls(Decl **Group, unsigned NumDecls);
1315
1316   void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
1317                                        SourceLocation LocAfterDecls);
1318   void CheckForFunctionRedefinition(FunctionDecl *FD);
1319   Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D);
1320   Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D);
1321   void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
1322   bool isObjCMethodDecl(Decl *D) {
1323     return D && isa<ObjCMethodDecl>(D);
1324   }
1325
1326   void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
1327   Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
1328   Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
1329
1330   /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
1331   /// attribute for which parsing is delayed.
1332   void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
1333
1334   /// \brief Diagnose any unused parameters in the given sequence of
1335   /// ParmVarDecl pointers.
1336   void DiagnoseUnusedParameters(ParmVarDecl * const *Begin,
1337                                 ParmVarDecl * const *End);
1338
1339   /// \brief Diagnose whether the size of parameters or return value of a
1340   /// function or obj-c method definition is pass-by-value and larger than a
1341   /// specified threshold.
1342   void DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Begin,
1343                                               ParmVarDecl * const *End,
1344                                               QualType ReturnTy,
1345                                               NamedDecl *D);
1346
1347   void DiagnoseInvalidJumps(Stmt *Body);
1348   Decl *ActOnFileScopeAsmDecl(Expr *expr,
1349                               SourceLocation AsmLoc,
1350                               SourceLocation RParenLoc);
1351
1352   /// \brief The parser has processed a module import declaration.
1353   ///
1354   /// \param AtLoc The location of the '@' symbol, if any.
1355   ///
1356   /// \param ImportLoc The location of the 'import' keyword.
1357   ///
1358   /// \param Path The module access path.
1359   DeclResult ActOnModuleImport(SourceLocation AtLoc, SourceLocation ImportLoc,
1360                                ModuleIdPath Path);
1361
1362   /// \brief Retrieve a suitable printing policy.
1363   PrintingPolicy getPrintingPolicy() const {
1364     return getPrintingPolicy(Context, PP);
1365   }
1366
1367   /// \brief Retrieve a suitable printing policy.
1368   static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
1369                                           const Preprocessor &PP);
1370
1371   /// Scope actions.
1372   void ActOnPopScope(SourceLocation Loc, Scope *S);
1373   void ActOnTranslationUnitScope(Scope *S);
1374
1375   Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
1376                                    DeclSpec &DS);
1377   Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
1378                                    DeclSpec &DS,
1379                                    MultiTemplateParamsArg TemplateParams);
1380
1381   Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1382                                     AccessSpecifier AS,
1383                                     RecordDecl *Record);
1384
1385   Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
1386                                        RecordDecl *Record);
1387
1388   bool isAcceptableTagRedeclaration(const TagDecl *Previous,
1389                                     TagTypeKind NewTag, bool isDefinition,
1390                                     SourceLocation NewTagLoc,
1391                                     const IdentifierInfo &Name);
1392
1393   enum TagUseKind {
1394     TUK_Reference,   // Reference to a tag:  'struct foo *X;'
1395     TUK_Declaration, // Fwd decl of a tag:   'struct foo;'
1396     TUK_Definition,  // Definition of a tag: 'struct foo { int X; } Y;'
1397     TUK_Friend       // Friend declaration:  'friend struct foo;'
1398   };
1399
1400   Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
1401                  SourceLocation KWLoc, CXXScopeSpec &SS,
1402                  IdentifierInfo *Name, SourceLocation NameLoc,
1403                  AttributeList *Attr, AccessSpecifier AS,
1404                  SourceLocation ModulePrivateLoc,
1405                  MultiTemplateParamsArg TemplateParameterLists,
1406                  bool &OwnedDecl, bool &IsDependent,
1407                  SourceLocation ScopedEnumKWLoc,
1408                  bool ScopedEnumUsesClassTag, TypeResult UnderlyingType);
1409
1410   Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
1411                                 unsigned TagSpec, SourceLocation TagLoc,
1412                                 CXXScopeSpec &SS,
1413                                 IdentifierInfo *Name, SourceLocation NameLoc,
1414                                 AttributeList *Attr,
1415                                 MultiTemplateParamsArg TempParamLists);
1416
1417   TypeResult ActOnDependentTag(Scope *S,
1418                                unsigned TagSpec,
1419                                TagUseKind TUK,
1420                                const CXXScopeSpec &SS,
1421                                IdentifierInfo *Name,
1422                                SourceLocation TagLoc,
1423                                SourceLocation NameLoc);
1424
1425   void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
1426                  IdentifierInfo *ClassName,
1427                  SmallVectorImpl<Decl *> &Decls);
1428   Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
1429                    Declarator &D, Expr *BitfieldWidth);
1430
1431   FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
1432                          Declarator &D, Expr *BitfieldWidth,
1433                          InClassInitStyle InitStyle,
1434                          AccessSpecifier AS);
1435
1436   FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
1437                             TypeSourceInfo *TInfo,
1438                             RecordDecl *Record, SourceLocation Loc,
1439                             bool Mutable, Expr *BitfieldWidth,
1440                             InClassInitStyle InitStyle,
1441                             SourceLocation TSSL,
1442                             AccessSpecifier AS, NamedDecl *PrevDecl,
1443                             Declarator *D = 0);
1444
1445   enum CXXSpecialMember {
1446     CXXDefaultConstructor,
1447     CXXCopyConstructor,
1448     CXXMoveConstructor,
1449     CXXCopyAssignment,
1450     CXXMoveAssignment,
1451     CXXDestructor,
1452     CXXInvalid
1453   };
1454   bool CheckNontrivialField(FieldDecl *FD);
1455   void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem);
1456   CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD);
1457   void ActOnLastBitfield(SourceLocation DeclStart,
1458                          SmallVectorImpl<Decl *> &AllIvarDecls);
1459   Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
1460                   Declarator &D, Expr *BitfieldWidth,
1461                   tok::ObjCKeywordKind visibility);
1462
1463   // This is used for both record definitions and ObjC interface declarations.
1464   void ActOnFields(Scope* S, SourceLocation RecLoc, Decl *TagDecl,
1465                    llvm::ArrayRef<Decl *> Fields,
1466                    SourceLocation LBrac, SourceLocation RBrac,
1467                    AttributeList *AttrList);
1468
1469   /// ActOnTagStartDefinition - Invoked when we have entered the
1470   /// scope of a tag's definition (e.g., for an enumeration, class,
1471   /// struct, or union).
1472   void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
1473
1474   Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
1475
1476   /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
1477   /// C++ record definition's base-specifiers clause and are starting its
1478   /// member declarations.
1479   void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
1480                                        SourceLocation FinalLoc,
1481                                        SourceLocation LBraceLoc);
1482
1483   /// ActOnTagFinishDefinition - Invoked once we have finished parsing
1484   /// the definition of a tag (enumeration, class, struct, or union).
1485   void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
1486                                 SourceLocation RBraceLoc);
1487
1488   void ActOnObjCContainerFinishDefinition();
1489
1490   /// \brief Invoked when we must temporarily exit the objective-c container
1491   /// scope for parsing/looking-up C constructs.
1492   ///
1493   /// Must be followed by a call to \see ActOnObjCReenterContainerContext
1494   void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
1495   void ActOnObjCReenterContainerContext(DeclContext *DC);
1496
1497   /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
1498   /// error parsing the definition of a tag.
1499   void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
1500
1501   EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
1502                                       EnumConstantDecl *LastEnumConst,
1503                                       SourceLocation IdLoc,
1504                                       IdentifierInfo *Id,
1505                                       Expr *val);
1506   bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
1507   bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
1508                               QualType EnumUnderlyingTy, const EnumDecl *Prev);
1509
1510   Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
1511                           SourceLocation IdLoc, IdentifierInfo *Id,
1512                           AttributeList *Attrs,
1513                           SourceLocation EqualLoc, Expr *Val);
1514   void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
1515                      SourceLocation RBraceLoc, Decl *EnumDecl,
1516                      Decl **Elements, unsigned NumElements,
1517                      Scope *S, AttributeList *Attr);
1518
1519   DeclContext *getContainingDC(DeclContext *DC);
1520
1521   /// Set the current declaration context until it gets popped.
1522   void PushDeclContext(Scope *S, DeclContext *DC);
1523   void PopDeclContext();
1524
1525   /// EnterDeclaratorContext - Used when we must lookup names in the context
1526   /// of a declarator's nested name specifier.
1527   void EnterDeclaratorContext(Scope *S, DeclContext *DC);
1528   void ExitDeclaratorContext(Scope *S);
1529
1530   /// Push the parameters of D, which must be a function, into scope.
1531   void ActOnReenterFunctionContext(Scope* S, Decl* D);
1532   void ActOnExitFunctionContext();
1533
1534   DeclContext *getFunctionLevelDeclContext();
1535
1536   /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1537   /// to the function decl for the function being parsed.  If we're currently
1538   /// in a 'block', this returns the containing context.
1539   FunctionDecl *getCurFunctionDecl();
1540
1541   /// getCurMethodDecl - If inside of a method body, this returns a pointer to
1542   /// the method decl for the method being parsed.  If we're currently
1543   /// in a 'block', this returns the containing context.
1544   ObjCMethodDecl *getCurMethodDecl();
1545
1546   /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
1547   /// or C function we're in, otherwise return null.  If we're currently
1548   /// in a 'block', this returns the containing context.
1549   NamedDecl *getCurFunctionOrMethodDecl();
1550
1551   /// Add this decl to the scope shadowed decl chains.
1552   void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
1553
1554   /// \brief Make the given externally-produced declaration visible at the
1555   /// top level scope.
1556   ///
1557   /// \param D The externally-produced declaration to push.
1558   ///
1559   /// \param Name The name of the externally-produced declaration.
1560   void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name);
1561
1562   /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
1563   /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
1564   /// true if 'D' belongs to the given declaration context.
1565   ///
1566   /// \param ExplicitInstantiationOrSpecialization When true, we are checking
1567   /// whether the declaration is in scope for the purposes of explicit template
1568   /// instantiation or specialization. The default is false.
1569   bool isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S = 0,
1570                      bool ExplicitInstantiationOrSpecialization = false);
1571
1572   /// Finds the scope corresponding to the given decl context, if it
1573   /// happens to be an enclosing scope.  Otherwise return NULL.
1574   static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
1575
1576   /// Subroutines of ActOnDeclarator().
1577   TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
1578                                 TypeSourceInfo *TInfo);
1579   bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
1580
1581   /// Attribute merging methods. Return true if a new attribute was added.
1582   AvailabilityAttr *mergeAvailabilityAttr(Decl *D, SourceRange Range,
1583                                           IdentifierInfo *Platform,
1584                                           VersionTuple Introduced,
1585                                           VersionTuple Deprecated,
1586                                           VersionTuple Obsoleted,
1587                                           bool IsUnavailable,
1588                                           StringRef Message);
1589   VisibilityAttr *mergeVisibilityAttr(Decl *D, SourceRange Range,
1590                                       VisibilityAttr::VisibilityType Vis);
1591   DLLImportAttr *mergeDLLImportAttr(Decl *D, SourceRange Range);
1592   DLLExportAttr *mergeDLLExportAttr(Decl *D, SourceRange Range);
1593   FormatAttr *mergeFormatAttr(Decl *D, SourceRange Range, StringRef Format,
1594                               int FormatIdx, int FirstArg);
1595   SectionAttr *mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name);
1596   bool mergeDeclAttribute(Decl *New, InheritableAttr *Attr);
1597
1598   void mergeDeclAttributes(Decl *New, Decl *Old, bool MergeDeprecation = true);
1599   void MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls);
1600   bool MergeFunctionDecl(FunctionDecl *New, Decl *Old, Scope *S);
1601   bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
1602                                     Scope *S);
1603   void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
1604   void MergeVarDecl(VarDecl *New, LookupResult &OldDecls);
1605   void MergeVarDeclTypes(VarDecl *New, VarDecl *Old);
1606   void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
1607   bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
1608
1609   // AssignmentAction - This is used by all the assignment diagnostic functions
1610   // to represent what is actually causing the operation
1611   enum AssignmentAction {
1612     AA_Assigning,
1613     AA_Passing,
1614     AA_Returning,
1615     AA_Converting,
1616     AA_Initializing,
1617     AA_Sending,
1618     AA_Casting
1619   };
1620
1621   /// C++ Overloading.
1622   enum OverloadKind {
1623     /// This is a legitimate overload: the existing declarations are
1624     /// functions or function templates with different signatures.
1625     Ovl_Overload,
1626
1627     /// This is not an overload because the signature exactly matches
1628     /// an existing declaration.
1629     Ovl_Match,
1630
1631     /// This is not an overload because the lookup results contain a
1632     /// non-function.
1633     Ovl_NonFunction
1634   };
1635   OverloadKind CheckOverload(Scope *S,
1636                              FunctionDecl *New,
1637                              const LookupResult &OldDecls,
1638                              NamedDecl *&OldDecl,
1639                              bool IsForUsingDecl);
1640   bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl);
1641
1642   /// \brief Checks availability of the function depending on the current
1643   /// function context.Inside an unavailable function,unavailability is ignored.
1644   ///
1645   /// \returns true if \arg FD is unavailable and current context is inside
1646   /// an available function, false otherwise.
1647   bool isFunctionConsideredUnavailable(FunctionDecl *FD);
1648
1649   ImplicitConversionSequence
1650   TryImplicitConversion(Expr *From, QualType ToType,
1651                         bool SuppressUserConversions,
1652                         bool AllowExplicit,
1653                         bool InOverloadResolution,
1654                         bool CStyle,
1655                         bool AllowObjCWritebackConversion);
1656
1657   bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
1658   bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
1659   bool IsComplexPromotion(QualType FromType, QualType ToType);
1660   bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
1661                            bool InOverloadResolution,
1662                            QualType& ConvertedType, bool &IncompatibleObjC);
1663   bool isObjCPointerConversion(QualType FromType, QualType ToType,
1664                                QualType& ConvertedType, bool &IncompatibleObjC);
1665   bool isObjCWritebackConversion(QualType FromType, QualType ToType,
1666                                  QualType &ConvertedType);
1667   bool IsBlockPointerConversion(QualType FromType, QualType ToType,
1668                                 QualType& ConvertedType);
1669   bool FunctionArgTypesAreEqual(const FunctionProtoType *OldType,
1670                                 const FunctionProtoType *NewType,
1671                                 unsigned *ArgPos = 0);
1672   void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
1673                                   QualType FromType, QualType ToType);
1674
1675   CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
1676   bool CheckPointerConversion(Expr *From, QualType ToType,
1677                               CastKind &Kind,
1678                               CXXCastPath& BasePath,
1679                               bool IgnoreBaseAccess);
1680   bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
1681                                  bool InOverloadResolution,
1682                                  QualType &ConvertedType);
1683   bool CheckMemberPointerConversion(Expr *From, QualType ToType,
1684                                     CastKind &Kind,
1685                                     CXXCastPath &BasePath,
1686                                     bool IgnoreBaseAccess);
1687   bool IsQualificationConversion(QualType FromType, QualType ToType,
1688                                  bool CStyle, bool &ObjCLifetimeConversion);
1689   bool IsNoReturnConversion(QualType FromType, QualType ToType,
1690                             QualType &ResultTy);
1691   bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
1692
1693
1694   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
1695                                              const VarDecl *NRVOCandidate,
1696                                              QualType ResultType,
1697                                              Expr *Value,
1698                                              bool AllowNRVO = true);
1699
1700   bool CanPerformCopyInitialization(const InitializedEntity &Entity,
1701                                     ExprResult Init);
1702   ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
1703                                        SourceLocation EqualLoc,
1704                                        ExprResult Init,
1705                                        bool TopLevelOfInitList = false,
1706                                        bool AllowExplicit = false);
1707   ExprResult PerformObjectArgumentInitialization(Expr *From,
1708                                                  NestedNameSpecifier *Qualifier,
1709                                                  NamedDecl *FoundDecl,
1710                                                  CXXMethodDecl *Method);
1711
1712   ExprResult PerformContextuallyConvertToBool(Expr *From);
1713   ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
1714
1715   /// Contexts in which a converted constant expression is required.
1716   enum CCEKind {
1717     CCEK_CaseValue,  ///< Expression in a case label.
1718     CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
1719     CCEK_TemplateArg ///< Value of a non-type template parameter.
1720   };
1721   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
1722                                               llvm::APSInt &Value, CCEKind CCE);
1723
1724   /// \brief Abstract base class used to diagnose problems that occur while
1725   /// trying to convert an expression to integral or enumeration type.
1726   class ICEConvertDiagnoser {
1727   public:
1728     bool Suppress;
1729     bool SuppressConversion;
1730
1731     ICEConvertDiagnoser(bool Suppress = false,
1732                         bool SuppressConversion = false)
1733       : Suppress(Suppress), SuppressConversion(SuppressConversion) { }
1734
1735     /// \brief Emits a diagnostic complaining that the expression does not have
1736     /// integral or enumeration type.
1737     virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1738                                              QualType T) = 0;
1739
1740     /// \brief Emits a diagnostic when the expression has incomplete class type.
1741     virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
1742                                                  QualType T) = 0;
1743
1744     /// \brief Emits a diagnostic when the only matching conversion function
1745     /// is explicit.
1746     virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
1747                                                    QualType T,
1748                                                    QualType ConvTy) = 0;
1749
1750     /// \brief Emits a note for the explicit conversion function.
1751     virtual DiagnosticBuilder
1752     noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
1753
1754     /// \brief Emits a diagnostic when there are multiple possible conversion
1755     /// functions.
1756     virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
1757                                                 QualType T) = 0;
1758
1759     /// \brief Emits a note for one of the candidate conversions.
1760     virtual DiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
1761                                             QualType ConvTy) = 0;
1762
1763     /// \brief Emits a diagnostic when we picked a conversion function
1764     /// (for cases when we are not allowed to pick a conversion function).
1765     virtual DiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
1766                                                  QualType T,
1767                                                  QualType ConvTy) = 0;
1768
1769     virtual ~ICEConvertDiagnoser() {}
1770   };
1771
1772   ExprResult
1773   ConvertToIntegralOrEnumerationType(SourceLocation Loc, Expr *FromE,
1774                                      ICEConvertDiagnoser &Diagnoser,
1775                                      bool AllowScopedEnumerations);
1776
1777   enum ObjCSubscriptKind {
1778     OS_Array,
1779     OS_Dictionary,
1780     OS_Error
1781   };
1782   ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
1783
1784   ExprResult PerformObjectMemberConversion(Expr *From,
1785                                            NestedNameSpecifier *Qualifier,
1786                                            NamedDecl *FoundDecl,
1787                                            NamedDecl *Member);
1788
1789   // Members have to be NamespaceDecl* or TranslationUnitDecl*.
1790   // TODO: make this is a typesafe union.
1791   typedef llvm::SmallPtrSet<DeclContext   *, 16> AssociatedNamespaceSet;
1792   typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
1793
1794   void AddOverloadCandidate(FunctionDecl *Function,
1795                             DeclAccessPair FoundDecl,
1796                             llvm::ArrayRef<Expr *> Args,
1797                             OverloadCandidateSet& CandidateSet,
1798                             bool SuppressUserConversions = false,
1799                             bool PartialOverloading = false,
1800                             bool AllowExplicit = false);
1801   void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
1802                              llvm::ArrayRef<Expr *> Args,
1803                              OverloadCandidateSet& CandidateSet,
1804                              bool SuppressUserConversions = false,
1805                             TemplateArgumentListInfo *ExplicitTemplateArgs = 0);
1806   void AddMethodCandidate(DeclAccessPair FoundDecl,
1807                           QualType ObjectType,
1808                           Expr::Classification ObjectClassification,
1809                           Expr **Args, unsigned NumArgs,
1810                           OverloadCandidateSet& CandidateSet,
1811                           bool SuppressUserConversion = false);
1812   void AddMethodCandidate(CXXMethodDecl *Method,
1813                           DeclAccessPair FoundDecl,
1814                           CXXRecordDecl *ActingContext, QualType ObjectType,
1815                           Expr::Classification ObjectClassification,
1816                           llvm::ArrayRef<Expr *> Args,
1817                           OverloadCandidateSet& CandidateSet,
1818                           bool SuppressUserConversions = false);
1819   void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
1820                                   DeclAccessPair FoundDecl,
1821                                   CXXRecordDecl *ActingContext,
1822                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
1823                                   QualType ObjectType,
1824                                   Expr::Classification ObjectClassification,
1825                                   llvm::ArrayRef<Expr *> Args,
1826                                   OverloadCandidateSet& CandidateSet,
1827                                   bool SuppressUserConversions = false);
1828   void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
1829                                     DeclAccessPair FoundDecl,
1830                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
1831                                     llvm::ArrayRef<Expr *> Args,
1832                                     OverloadCandidateSet& CandidateSet,
1833                                     bool SuppressUserConversions = false);
1834   void AddConversionCandidate(CXXConversionDecl *Conversion,
1835                               DeclAccessPair FoundDecl,
1836                               CXXRecordDecl *ActingContext,
1837                               Expr *From, QualType ToType,
1838                               OverloadCandidateSet& CandidateSet);
1839   void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
1840                                       DeclAccessPair FoundDecl,
1841                                       CXXRecordDecl *ActingContext,
1842                                       Expr *From, QualType ToType,
1843                                       OverloadCandidateSet &CandidateSet);
1844   void AddSurrogateCandidate(CXXConversionDecl *Conversion,
1845                              DeclAccessPair FoundDecl,
1846                              CXXRecordDecl *ActingContext,
1847                              const FunctionProtoType *Proto,
1848                              Expr *Object, llvm::ArrayRef<Expr*> Args,
1849                              OverloadCandidateSet& CandidateSet);
1850   void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
1851                                    SourceLocation OpLoc,
1852                                    Expr **Args, unsigned NumArgs,
1853                                    OverloadCandidateSet& CandidateSet,
1854                                    SourceRange OpRange = SourceRange());
1855   void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
1856                            Expr **Args, unsigned NumArgs,
1857                            OverloadCandidateSet& CandidateSet,
1858                            bool IsAssignmentOperator = false,
1859                            unsigned NumContextualBoolArguments = 0);
1860   void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
1861                                     SourceLocation OpLoc,
1862                                     Expr **Args, unsigned NumArgs,
1863                                     OverloadCandidateSet& CandidateSet);
1864   void AddArgumentDependentLookupCandidates(DeclarationName Name,
1865                                             bool Operator, SourceLocation Loc,
1866                                             llvm::ArrayRef<Expr *> Args,
1867                                 TemplateArgumentListInfo *ExplicitTemplateArgs,
1868                                             OverloadCandidateSet& CandidateSet,
1869                                             bool PartialOverloading = false,
1870                                         bool StdNamespaceIsAssociated = false);
1871
1872   // Emit as a 'note' the specific overload candidate
1873   void NoteOverloadCandidate(FunctionDecl *Fn, QualType DestType = QualType());
1874
1875   // Emit as a series of 'note's all template and non-templates
1876   // identified by the expression Expr
1877   void NoteAllOverloadCandidates(Expr* E, QualType DestType = QualType());
1878
1879   // [PossiblyAFunctionType]  -->   [Return]
1880   // NonFunctionType --> NonFunctionType
1881   // R (A) --> R(A)
1882   // R (*)(A) --> R (A)
1883   // R (&)(A) --> R (A)
1884   // R (S::*)(A) --> R (A)
1885   QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
1886
1887   FunctionDecl *
1888   ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
1889                                      QualType TargetType,
1890                                      bool Complain,
1891                                      DeclAccessPair &Found,
1892                                      bool *pHadMultipleCandidates = 0);
1893
1894   FunctionDecl *ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
1895                                                    bool Complain = false,
1896                                                    DeclAccessPair* Found = 0);
1897
1898   bool ResolveAndFixSingleFunctionTemplateSpecialization(
1899                       ExprResult &SrcExpr,
1900                       bool DoFunctionPointerConverion = false,
1901                       bool Complain = false,
1902                       const SourceRange& OpRangeForComplaining = SourceRange(),
1903                       QualType DestTypeForComplaining = QualType(),
1904                       unsigned DiagIDForComplaining = 0);
1905
1906
1907   Expr *FixOverloadedFunctionReference(Expr *E,
1908                                        DeclAccessPair FoundDecl,
1909                                        FunctionDecl *Fn);
1910   ExprResult FixOverloadedFunctionReference(ExprResult,
1911                                             DeclAccessPair FoundDecl,
1912                                             FunctionDecl *Fn);
1913
1914   void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
1915                                    llvm::ArrayRef<Expr *> Args,
1916                                    OverloadCandidateSet &CandidateSet,
1917                                    bool PartialOverloading = false);
1918
1919   ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
1920                                      UnresolvedLookupExpr *ULE,
1921                                      SourceLocation LParenLoc,
1922                                      Expr **Args, unsigned NumArgs,
1923                                      SourceLocation RParenLoc,
1924                                      Expr *ExecConfig,
1925                                      bool AllowTypoCorrection=true);
1926
1927   ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
1928                                      unsigned Opc,
1929                                      const UnresolvedSetImpl &Fns,
1930                                      Expr *input);
1931
1932   ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
1933                                    unsigned Opc,
1934                                    const UnresolvedSetImpl &Fns,
1935                                    Expr *LHS, Expr *RHS);
1936
1937   ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
1938                                                 SourceLocation RLoc,
1939                                                 Expr *Base,Expr *Idx);
1940
1941   ExprResult
1942   BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
1943                             SourceLocation LParenLoc, Expr **Args,
1944                             unsigned NumArgs, SourceLocation RParenLoc);
1945   ExprResult
1946   BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
1947                                Expr **Args, unsigned NumArgs,
1948                                SourceLocation RParenLoc);
1949
1950   ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
1951                                       SourceLocation OpLoc);
1952
1953   /// CheckCallReturnType - Checks that a call expression's return type is
1954   /// complete. Returns true on failure. The location passed in is the location
1955   /// that best represents the call.
1956   bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
1957                            CallExpr *CE, FunctionDecl *FD);
1958
1959   /// Helpers for dealing with blocks and functions.
1960   bool CheckParmsForFunctionDef(ParmVarDecl **Param, ParmVarDecl **ParamEnd,
1961                                 bool CheckParameterNames);
1962   void CheckCXXDefaultArguments(FunctionDecl *FD);
1963   void CheckExtraCXXDefaultArguments(Declarator &D);
1964   Scope *getNonFieldDeclScope(Scope *S);
1965
1966   /// \name Name lookup
1967   ///
1968   /// These routines provide name lookup that is used during semantic
1969   /// analysis to resolve the various kinds of names (identifiers,
1970   /// overloaded operator names, constructor names, etc.) into zero or
1971   /// more declarations within a particular scope. The major entry
1972   /// points are LookupName, which performs unqualified name lookup,
1973   /// and LookupQualifiedName, which performs qualified name lookup.
1974   ///
1975   /// All name lookup is performed based on some specific criteria,
1976   /// which specify what names will be visible to name lookup and how
1977   /// far name lookup should work. These criteria are important both
1978   /// for capturing language semantics (certain lookups will ignore
1979   /// certain names, for example) and for performance, since name
1980   /// lookup is often a bottleneck in the compilation of C++. Name
1981   /// lookup criteria is specified via the LookupCriteria enumeration.
1982   ///
1983   /// The results of name lookup can vary based on the kind of name
1984   /// lookup performed, the current language, and the translation
1985   /// unit. In C, for example, name lookup will either return nothing
1986   /// (no entity found) or a single declaration. In C++, name lookup
1987   /// can additionally refer to a set of overloaded functions or
1988   /// result in an ambiguity. All of the possible results of name
1989   /// lookup are captured by the LookupResult class, which provides
1990   /// the ability to distinguish among them.
1991   //@{
1992
1993   /// @brief Describes the kind of name lookup to perform.
1994   enum LookupNameKind {
1995     /// Ordinary name lookup, which finds ordinary names (functions,
1996     /// variables, typedefs, etc.) in C and most kinds of names
1997     /// (functions, variables, members, types, etc.) in C++.
1998     LookupOrdinaryName = 0,
1999     /// Tag name lookup, which finds the names of enums, classes,
2000     /// structs, and unions.
2001     LookupTagName,
2002     /// Label name lookup.
2003     LookupLabel,
2004     /// Member name lookup, which finds the names of
2005     /// class/struct/union members.
2006     LookupMemberName,
2007     /// Look up of an operator name (e.g., operator+) for use with
2008     /// operator overloading. This lookup is similar to ordinary name
2009     /// lookup, but will ignore any declarations that are class members.
2010     LookupOperatorName,
2011     /// Look up of a name that precedes the '::' scope resolution
2012     /// operator in C++. This lookup completely ignores operator, object,
2013     /// function, and enumerator names (C++ [basic.lookup.qual]p1).
2014     LookupNestedNameSpecifierName,
2015     /// Look up a namespace name within a C++ using directive or
2016     /// namespace alias definition, ignoring non-namespace names (C++
2017     /// [basic.lookup.udir]p1).
2018     LookupNamespaceName,
2019     /// Look up all declarations in a scope with the given name,
2020     /// including resolved using declarations.  This is appropriate
2021     /// for checking redeclarations for a using declaration.
2022     LookupUsingDeclName,
2023     /// Look up an ordinary name that is going to be redeclared as a
2024     /// name with linkage. This lookup ignores any declarations that
2025     /// are outside of the current scope unless they have linkage. See
2026     /// C99 6.2.2p4-5 and C++ [basic.link]p6.
2027     LookupRedeclarationWithLinkage,
2028     /// Look up the name of an Objective-C protocol.
2029     LookupObjCProtocolName,
2030     /// Look up implicit 'self' parameter of an objective-c method.
2031     LookupObjCImplicitSelfParam,
2032     /// \brief Look up any declaration with any name.
2033     LookupAnyName
2034   };
2035
2036   /// \brief Specifies whether (or how) name lookup is being performed for a
2037   /// redeclaration (vs. a reference).
2038   enum RedeclarationKind {
2039     /// \brief The lookup is a reference to this name that is not for the
2040     /// purpose of redeclaring the name.
2041     NotForRedeclaration = 0,
2042     /// \brief The lookup results will be used for redeclaration of a name,
2043     /// if an entity by that name already exists.
2044     ForRedeclaration
2045   };
2046
2047   /// \brief The possible outcomes of name lookup for a literal operator.
2048   enum LiteralOperatorLookupResult {
2049     /// \brief The lookup resulted in an error.
2050     LOLR_Error,
2051     /// \brief The lookup found a single 'cooked' literal operator, which
2052     /// expects a normal literal to be built and passed to it.
2053     LOLR_Cooked,
2054     /// \brief The lookup found a single 'raw' literal operator, which expects
2055     /// a string literal containing the spelling of the literal token.
2056     LOLR_Raw,
2057     /// \brief The lookup found an overload set of literal operator templates,
2058     /// which expect the characters of the spelling of the literal token to be
2059     /// passed as a non-type template argument pack.
2060     LOLR_Template
2061   };
2062
2063   SpecialMemberOverloadResult *LookupSpecialMember(CXXRecordDecl *D,
2064                                                    CXXSpecialMember SM,
2065                                                    bool ConstArg,
2066                                                    bool VolatileArg,
2067                                                    bool RValueThis,
2068                                                    bool ConstThis,
2069                                                    bool VolatileThis);
2070
2071 private:
2072   bool CppLookupName(LookupResult &R, Scope *S);
2073
2074   // \brief The set of known/encountered (unique, canonicalized) NamespaceDecls.
2075   //
2076   // The boolean value will be true to indicate that the namespace was loaded
2077   // from an AST/PCH file, or false otherwise.
2078   llvm::DenseMap<NamespaceDecl*, bool> KnownNamespaces;
2079
2080   /// \brief Whether we have already loaded known namespaces from an extenal
2081   /// source.
2082   bool LoadedExternalKnownNamespaces;
2083
2084 public:
2085   /// \brief Look up a name, looking for a single declaration.  Return
2086   /// null if the results were absent, ambiguous, or overloaded.
2087   ///
2088   /// It is preferable to use the elaborated form and explicitly handle
2089   /// ambiguity and overloaded.
2090   NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
2091                               SourceLocation Loc,
2092                               LookupNameKind NameKind,
2093                               RedeclarationKind Redecl
2094                                 = NotForRedeclaration);
2095   bool LookupName(LookupResult &R, Scope *S,
2096                   bool AllowBuiltinCreation = false);
2097   bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
2098                            bool InUnqualifiedLookup = false);
2099   bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
2100                         bool AllowBuiltinCreation = false,
2101                         bool EnteringContext = false);
2102   ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
2103                                    RedeclarationKind Redecl
2104                                      = NotForRedeclaration);
2105
2106   void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
2107                                     QualType T1, QualType T2,
2108                                     UnresolvedSetImpl &Functions);
2109
2110   LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
2111                                  SourceLocation GnuLabelLoc = SourceLocation());
2112
2113   DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
2114   CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
2115   CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
2116                                                unsigned Quals);
2117   CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
2118                                          bool RValueThis, unsigned ThisQuals);
2119   CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
2120                                               unsigned Quals);
2121   CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
2122                                         bool RValueThis, unsigned ThisQuals);
2123   CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
2124
2125   LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R,
2126                                                     ArrayRef<QualType> ArgTys,
2127                                                     bool AllowRawAndTemplate);
2128   bool isKnownName(StringRef name);
2129
2130   void ArgumentDependentLookup(DeclarationName Name, bool Operator,
2131                                SourceLocation Loc,
2132                                llvm::ArrayRef<Expr *> Args,
2133                                ADLResult &Functions,
2134                                bool StdNamespaceIsAssociated = false);
2135
2136   void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
2137                           VisibleDeclConsumer &Consumer,
2138                           bool IncludeGlobalScope = true);
2139   void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
2140                           VisibleDeclConsumer &Consumer,
2141                           bool IncludeGlobalScope = true);
2142
2143   TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
2144                              Sema::LookupNameKind LookupKind,
2145                              Scope *S, CXXScopeSpec *SS,
2146                              CorrectionCandidateCallback &CCC,
2147                              DeclContext *MemberContext = 0,
2148                              bool EnteringContext = false,
2149                              const ObjCObjectPointerType *OPT = 0);
2150
2151   void FindAssociatedClassesAndNamespaces(llvm::ArrayRef<Expr *> Args,
2152                                    AssociatedNamespaceSet &AssociatedNamespaces,
2153                                    AssociatedClassSet &AssociatedClasses);
2154
2155   void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
2156                             bool ConsiderLinkage,
2157                             bool ExplicitInstantiationOrSpecialization);
2158
2159   bool DiagnoseAmbiguousLookup(LookupResult &Result);
2160   //@}
2161
2162   ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
2163                                           SourceLocation IdLoc,
2164                                           bool TypoCorrection = false);
2165   NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
2166                                  Scope *S, bool ForRedeclaration,
2167                                  SourceLocation Loc);
2168   NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
2169                                       Scope *S);
2170   void AddKnownFunctionAttributes(FunctionDecl *FD);
2171
2172   // More parsing and symbol table subroutines.
2173
2174   // Decl attributes - this routine is the top level dispatcher.
2175   void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
2176                            bool NonInheritable = true, bool Inheritable = true);
2177   void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL,
2178                            bool NonInheritable = true, bool Inheritable = true);
2179   bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
2180                                       const AttributeList *AttrList);
2181
2182   void checkUnusedDeclAttributes(Declarator &D);
2183
2184   bool CheckRegparmAttr(const AttributeList &attr, unsigned &value);
2185   bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC);
2186   bool CheckNoReturnAttr(const AttributeList &attr);
2187
2188   /// \brief Stmt attributes - this routine is the top level dispatcher.
2189   StmtResult ProcessStmtAttributes(Stmt *Stmt, AttributeList *Attrs,
2190                                    SourceRange Range);
2191
2192   void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
2193                            bool &IncompleteImpl, unsigned DiagID);
2194   void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
2195                                    ObjCMethodDecl *MethodDecl,
2196                                    bool IsProtocolMethodDecl);
2197
2198   void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
2199                                    ObjCMethodDecl *Overridden,
2200                                    bool IsProtocolMethodDecl);
2201
2202   /// WarnExactTypedMethods - This routine issues a warning if method
2203   /// implementation declaration matches exactly that of its declaration.
2204   void WarnExactTypedMethods(ObjCMethodDecl *Method,
2205                              ObjCMethodDecl *MethodDecl,
2206                              bool IsProtocolMethodDecl);
2207
2208   bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
2209                           ObjCInterfaceDecl *IDecl);
2210
2211   typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;
2212   typedef llvm::DenseMap<Selector, ObjCMethodDecl*> ProtocolsMethodsMap;
2213
2214   /// CheckProtocolMethodDefs - This routine checks unimplemented
2215   /// methods declared in protocol, and those referenced by it.
2216   void CheckProtocolMethodDefs(SourceLocation ImpLoc,
2217                                ObjCProtocolDecl *PDecl,
2218                                bool& IncompleteImpl,
2219                                const SelectorSet &InsMap,
2220                                const SelectorSet &ClsMap,
2221                                ObjCContainerDecl *CDecl);
2222
2223   /// CheckImplementationIvars - This routine checks if the instance variables
2224   /// listed in the implelementation match those listed in the interface.
2225   void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
2226                                 ObjCIvarDecl **Fields, unsigned nIvars,
2227                                 SourceLocation Loc);
2228
2229   /// ImplMethodsVsClassMethods - This is main routine to warn if any method
2230   /// remains unimplemented in the class or category \@implementation.
2231   void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
2232                                  ObjCContainerDecl* IDecl,
2233                                  bool IncompleteImpl = false);
2234
2235   /// DiagnoseUnimplementedProperties - This routine warns on those properties
2236   /// which must be implemented by this implementation.
2237   void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
2238                                        ObjCContainerDecl *CDecl,
2239                                        const SelectorSet &InsMap);
2240
2241   /// DefaultSynthesizeProperties - This routine default synthesizes all
2242   /// properties which must be synthesized in the class's \@implementation.
2243   void DefaultSynthesizeProperties (Scope *S, ObjCImplDecl* IMPDecl,
2244                                     ObjCInterfaceDecl *IDecl);
2245   void DefaultSynthesizeProperties(Scope *S, Decl *D);
2246
2247   /// CollectImmediateProperties - This routine collects all properties in
2248   /// the class and its conforming protocols; but not those it its super class.
2249   void CollectImmediateProperties(ObjCContainerDecl *CDecl,
2250             llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& PropMap,
2251             llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& SuperPropMap);
2252
2253
2254   /// LookupPropertyDecl - Looks up a property in the current class and all
2255   /// its protocols.
2256   ObjCPropertyDecl *LookupPropertyDecl(const ObjCContainerDecl *CDecl,
2257                                        IdentifierInfo *II);
2258
2259   /// Called by ActOnProperty to handle \@property declarations in
2260   /// class extensions.
2261   Decl *HandlePropertyInClassExtension(Scope *S,
2262                                        SourceLocation AtLoc,
2263                                        SourceLocation LParenLoc,
2264                                        FieldDeclarator &FD,
2265                                        Selector GetterSel,
2266                                        Selector SetterSel,
2267                                        const bool isAssign,
2268                                        const bool isReadWrite,
2269                                        const unsigned Attributes,
2270                                        const unsigned AttributesAsWritten,
2271                                        bool *isOverridingProperty,
2272                                        TypeSourceInfo *T,
2273                                        tok::ObjCKeywordKind MethodImplKind);
2274
2275   /// Called by ActOnProperty and HandlePropertyInClassExtension to
2276   /// handle creating the ObjcPropertyDecl for a category or \@interface.
2277   ObjCPropertyDecl *CreatePropertyDecl(Scope *S,
2278                                        ObjCContainerDecl *CDecl,
2279                                        SourceLocation AtLoc,
2280                                        SourceLocation LParenLoc,
2281                                        FieldDeclarator &FD,
2282                                        Selector GetterSel,
2283                                        Selector SetterSel,
2284                                        const bool isAssign,
2285                                        const bool isReadWrite,
2286                                        const unsigned Attributes,
2287                                        const unsigned AttributesAsWritten,
2288                                        TypeSourceInfo *T,
2289                                        tok::ObjCKeywordKind MethodImplKind,
2290                                        DeclContext *lexicalDC = 0);
2291
2292   /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
2293   /// warning) when atomic property has one but not the other user-declared
2294   /// setter or getter.
2295   void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
2296                                        ObjCContainerDecl* IDecl);
2297
2298   void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
2299
2300   void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);
2301
2302   enum MethodMatchStrategy {
2303     MMS_loose,
2304     MMS_strict
2305   };
2306
2307   /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
2308   /// true, or false, accordingly.
2309   bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
2310                                   const ObjCMethodDecl *PrevMethod,
2311                                   MethodMatchStrategy strategy = MMS_strict);
2312
2313   /// MatchAllMethodDeclarations - Check methods declaraed in interface or
2314   /// or protocol against those declared in their implementations.
2315   void MatchAllMethodDeclarations(const SelectorSet &InsMap,
2316                                   const SelectorSet &ClsMap,
2317                                   SelectorSet &InsMapSeen,
2318                                   SelectorSet &ClsMapSeen,
2319                                   ObjCImplDecl* IMPDecl,
2320                                   ObjCContainerDecl* IDecl,
2321                                   bool &IncompleteImpl,
2322                                   bool ImmediateClass,
2323                                   bool WarnCategoryMethodImpl=false);
2324
2325   /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
2326   /// category matches with those implemented in its primary class and
2327   /// warns each time an exact match is found.
2328   void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
2329
2330   /// \brief Add the given method to the list of globally-known methods.
2331   void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);
2332
2333 private:
2334   /// AddMethodToGlobalPool - Add an instance or factory method to the global
2335   /// pool. See descriptoin of AddInstanceMethodToGlobalPool.
2336   void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);
2337
2338   /// LookupMethodInGlobalPool - Returns the instance or factory method and
2339   /// optionally warns if there are multiple signatures.
2340   ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
2341                                            bool receiverIdOrClass,
2342                                            bool warn, bool instance);
2343
2344 public:
2345   /// AddInstanceMethodToGlobalPool - All instance methods in a translation
2346   /// unit are added to a global pool. This allows us to efficiently associate
2347   /// a selector with a method declaraation for purposes of typechecking
2348   /// messages sent to "id" (where the class of the object is unknown).
2349   void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
2350     AddMethodToGlobalPool(Method, impl, /*instance*/true);
2351   }
2352
2353   /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
2354   void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
2355     AddMethodToGlobalPool(Method, impl, /*instance*/false);
2356   }
2357
2358   /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
2359   /// pool.
2360   void AddAnyMethodToGlobalPool(Decl *D);
2361
2362   /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
2363   /// there are multiple signatures.
2364   ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
2365                                                    bool receiverIdOrClass=false,
2366                                                    bool warn=true) {
2367     return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
2368                                     warn, /*instance*/true);
2369   }
2370
2371   /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
2372   /// there are multiple signatures.
2373   ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,
2374                                                   bool receiverIdOrClass=false,
2375                                                   bool warn=true) {
2376     return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
2377                                     warn, /*instance*/false);
2378   }
2379
2380   /// LookupImplementedMethodInGlobalPool - Returns the method which has an
2381   /// implementation.
2382   ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
2383
2384   /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
2385   /// initialization.
2386   void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
2387                                   SmallVectorImpl<ObjCIvarDecl*> &Ivars);
2388
2389   //===--------------------------------------------------------------------===//
2390   // Statement Parsing Callbacks: SemaStmt.cpp.
2391 public:
2392   class FullExprArg {
2393   public:
2394     FullExprArg(Sema &actions) : E(0) { }
2395
2396     // FIXME: The const_cast here is ugly. RValue references would make this
2397     // much nicer (or we could duplicate a bunch of the move semantics
2398     // emulation code from Ownership.h).
2399     FullExprArg(const FullExprArg& Other) : E(Other.E) {}
2400
2401     ExprResult release() {
2402       return move(E);
2403     }
2404
2405     Expr *get() const { return E; }
2406
2407     Expr *operator->() {
2408       return E;
2409     }
2410
2411   private:
2412     // FIXME: No need to make the entire Sema class a friend when it's just
2413     // Sema::MakeFullExpr that needs access to the constructor below.
2414     friend class Sema;
2415
2416     explicit FullExprArg(Expr *expr) : E(expr) {}
2417
2418     Expr *E;
2419   };
2420
2421   FullExprArg MakeFullExpr(Expr *Arg) {
2422     return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());
2423   }
2424   FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
2425     return FullExprArg(ActOnFinishFullExpr(Arg, CC).release());
2426   }
2427
2428   StmtResult ActOnExprStmt(FullExprArg Expr);
2429
2430   StmtResult ActOnNullStmt(SourceLocation SemiLoc,
2431                            bool HasLeadingEmptyMacro = false);
2432
2433   void ActOnStartOfCompoundStmt();
2434   void ActOnFinishOfCompoundStmt();
2435   StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
2436                                        MultiStmtArg Elts,
2437                                        bool isStmtExpr);
2438
2439   /// \brief A RAII object to enter scope of a compound statement.
2440   class CompoundScopeRAII {
2441   public:
2442     CompoundScopeRAII(Sema &S): S(S) {
2443       S.ActOnStartOfCompoundStmt();
2444     }
2445
2446     ~CompoundScopeRAII() {
2447       S.ActOnFinishOfCompoundStmt();
2448     }
2449
2450   private:
2451     Sema &S;
2452   };
2453
2454   StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
2455                                    SourceLocation StartLoc,
2456                                    SourceLocation EndLoc);
2457   void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
2458   StmtResult ActOnForEachLValueExpr(Expr *E);
2459   StmtResult ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
2460                                    SourceLocation DotDotDotLoc, Expr *RHSVal,
2461                                    SourceLocation ColonLoc);
2462   void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
2463
2464   StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
2465                                       SourceLocation ColonLoc,
2466                                       Stmt *SubStmt, Scope *CurScope);
2467   StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
2468                             SourceLocation ColonLoc, Stmt *SubStmt);
2469
2470   StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,
2471                                  ArrayRef<const Attr*> Attrs,
2472                                  Stmt *SubStmt);
2473
2474   StmtResult ActOnIfStmt(SourceLocation IfLoc,
2475                          FullExprArg CondVal, Decl *CondVar,
2476                          Stmt *ThenVal,
2477                          SourceLocation ElseLoc, Stmt *ElseVal);
2478   StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
2479                                             Expr *Cond,
2480                                             Decl *CondVar);
2481   StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
2482                                            Stmt *Switch, Stmt *Body);
2483   StmtResult ActOnWhileStmt(SourceLocation WhileLoc,
2484                             FullExprArg Cond,
2485                             Decl *CondVar, Stmt *Body);
2486   StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
2487                                  SourceLocation WhileLoc,
2488                                  SourceLocation CondLParen, Expr *Cond,
2489                                  SourceLocation CondRParen);
2490
2491   StmtResult ActOnForStmt(SourceLocation ForLoc,
2492                           SourceLocation LParenLoc,
2493                           Stmt *First, FullExprArg Second,
2494                           Decl *SecondVar,
2495                           FullExprArg Third,
2496                           SourceLocation RParenLoc,
2497                           Stmt *Body);
2498   ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
2499                                            Expr *collection);
2500   StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
2501                                         Stmt *First, Expr *collection,
2502                                         SourceLocation RParenLoc);
2503   StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
2504
2505   StmtResult ActOnCXXForRangeStmt(SourceLocation ForLoc, Stmt *LoopVar,
2506                                   SourceLocation ColonLoc, Expr *Collection,
2507                                   SourceLocation RParenLoc);
2508   StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
2509                                   SourceLocation ColonLoc,
2510                                   Stmt *RangeDecl, Stmt *BeginEndDecl,
2511                                   Expr *Cond, Expr *Inc,
2512                                   Stmt *LoopVarDecl,
2513                                   SourceLocation RParenLoc);
2514   StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
2515
2516   StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
2517                            SourceLocation LabelLoc,
2518                            LabelDecl *TheDecl);
2519   StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
2520                                    SourceLocation StarLoc,
2521                                    Expr *DestExp);
2522   StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
2523   StmtResult ActOnBreakStmt(SourceLocation GotoLoc, Scope *CurScope);
2524
2525   const VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,
2526                                          bool AllowFunctionParameters);
2527
2528   StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
2529   StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
2530
2531   StmtResult ActOnAsmStmt(SourceLocation AsmLoc,
2532                           bool IsSimple, bool IsVolatile,
2533                           unsigned NumOutputs, unsigned NumInputs,
2534                           IdentifierInfo **Names,
2535                           MultiExprArg Constraints,
2536                           MultiExprArg Exprs,
2537                           Expr *AsmString,
2538                           MultiExprArg Clobbers,
2539                           SourceLocation RParenLoc,
2540                           bool MSAsm = false);
2541
2542   StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc,
2543                             SourceLocation LBraceLoc,
2544                             ArrayRef<Token> AsmToks,
2545                             SourceLocation EndLoc);
2546
2547   VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
2548                                   SourceLocation StartLoc,
2549                                   SourceLocation IdLoc, IdentifierInfo *Id,
2550                                   bool Invalid = false);
2551
2552   Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
2553
2554   StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
2555                                   Decl *Parm, Stmt *Body);
2556
2557   StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
2558
2559   StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
2560                                 MultiStmtArg Catch, Stmt *Finally);
2561
2562   StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
2563   StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2564                                   Scope *CurScope);
2565   ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
2566                                             Expr *operand);
2567   StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
2568                                          Expr *SynchExpr,
2569                                          Stmt *SynchBody);
2570
2571   StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
2572
2573   VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
2574                                      SourceLocation StartLoc,
2575                                      SourceLocation IdLoc,
2576                                      IdentifierInfo *Id);
2577
2578   Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
2579
2580   StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
2581                                 Decl *ExDecl, Stmt *HandlerBlock);
2582   StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
2583                               MultiStmtArg Handlers);
2584
2585   StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
2586                               SourceLocation TryLoc,
2587                               Stmt *TryBlock,
2588                               Stmt *Handler);
2589
2590   StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
2591                                  Expr *FilterExpr,
2592                                  Stmt *Block);
2593
2594   StmtResult ActOnSEHFinallyBlock(SourceLocation Loc,
2595                                   Stmt *Block);
2596
2597   void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
2598
2599   bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
2600
2601   /// \brief If it's a file scoped decl that must warn if not used, keep track
2602   /// of it.
2603   void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
2604
2605   /// DiagnoseUnusedExprResult - If the statement passed in is an expression
2606   /// whose result is unused, warn.
2607   void DiagnoseUnusedExprResult(const Stmt *S);
2608   void DiagnoseUnusedDecl(const NamedDecl *ND);
2609
2610   /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
2611   /// statement as a \p Body, and it is located on the same line.
2612   ///
2613   /// This helps prevent bugs due to typos, such as:
2614   ///     if (condition);
2615   ///       do_stuff();
2616   void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
2617                              const Stmt *Body,
2618                              unsigned DiagID);
2619
2620   /// Warn if a for/while loop statement \p S, which is followed by
2621   /// \p PossibleBody, has a suspicious null statement as a body.
2622   void DiagnoseEmptyLoopBody(const Stmt *S,
2623                              const Stmt *PossibleBody);
2624
2625   ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
2626     return DelayedDiagnostics.push(pool);
2627   }
2628   void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
2629
2630   typedef ProcessingContextState ParsingClassState;
2631   ParsingClassState PushParsingClass() {
2632     return DelayedDiagnostics.pushUndelayed();
2633   }
2634   void PopParsingClass(ParsingClassState state) {
2635     DelayedDiagnostics.popUndelayed(state);
2636   }
2637
2638   void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
2639
2640   void EmitDeprecationWarning(NamedDecl *D, StringRef Message,
2641                               SourceLocation Loc,
2642                               const ObjCInterfaceDecl *UnknownObjCClass=0);
2643
2644   void HandleDelayedDeprecationCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
2645
2646   bool makeUnavailableInSystemHeader(SourceLocation loc,
2647                                      StringRef message);
2648
2649   //===--------------------------------------------------------------------===//
2650   // Expression Parsing Callbacks: SemaExpr.cpp.
2651
2652   bool CanUseDecl(NamedDecl *D);
2653   bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
2654                          const ObjCInterfaceDecl *UnknownObjCClass=0);
2655   void NoteDeletedFunction(FunctionDecl *FD);
2656   std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD);
2657   bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
2658                                         ObjCMethodDecl *Getter,
2659                                         SourceLocation Loc);
2660   void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
2661                              Expr **Args, unsigned NumArgs);
2662
2663   void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
2664                                        Decl *LambdaContextDecl = 0,
2665                                        bool IsDecltype = false);
2666
2667   void PopExpressionEvaluationContext();
2668
2669   void DiscardCleanupsInEvaluationContext();
2670
2671   ExprResult TranformToPotentiallyEvaluated(Expr *E);
2672   ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
2673
2674   ExprResult ActOnConstantExpression(ExprResult Res);
2675
2676   // Functions for marking a declaration referenced.  These functions also
2677   // contain the relevant logic for marking if a reference to a function or
2678   // variable is an odr-use (in the C++11 sense).  There are separate variants
2679   // for expressions referring to a decl; these exist because odr-use marking
2680   // needs to be delayed for some constant variables when we build one of the
2681   // named expressions.
2682   void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D);
2683   void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func);
2684   void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
2685   void MarkDeclRefReferenced(DeclRefExpr *E);
2686   void MarkMemberReferenced(MemberExpr *E);
2687
2688   void UpdateMarkingForLValueToRValue(Expr *E);
2689   void CleanupVarDeclMarking();
2690
2691   enum TryCaptureKind {
2692     TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
2693   };
2694
2695   /// \brief Try to capture the given variable.
2696   ///
2697   /// \param Var The variable to capture.
2698   ///
2699   /// \param Loc The location at which the capture occurs.
2700   ///
2701   /// \param Kind The kind of capture, which may be implicit (for either a
2702   /// block or a lambda), or explicit by-value or by-reference (for a lambda).
2703   ///
2704   /// \param EllipsisLoc The location of the ellipsis, if one is provided in
2705   /// an explicit lambda capture.
2706   ///
2707   /// \param BuildAndDiagnose Whether we are actually supposed to add the
2708   /// captures or diagnose errors. If false, this routine merely check whether
2709   /// the capture can occur without performing the capture itself or complaining
2710   /// if the variable cannot be captured.
2711   ///
2712   /// \param CaptureType Will be set to the type of the field used to capture
2713   /// this variable in the innermost block or lambda. Only valid when the
2714   /// variable can be captured.
2715   ///
2716   /// \param DeclRefType Will be set to the type of a reference to the capture
2717   /// from within the current scope. Only valid when the variable can be
2718   /// captured.
2719   ///
2720   /// \returns true if an error occurred (i.e., the variable cannot be
2721   /// captured) and false if the capture succeeded.
2722   bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
2723                           SourceLocation EllipsisLoc, bool BuildAndDiagnose,
2724                           QualType &CaptureType,
2725                           QualType &DeclRefType);
2726
2727   /// \brief Try to capture the given variable.
2728   bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
2729                           TryCaptureKind Kind = TryCapture_Implicit,
2730                           SourceLocation EllipsisLoc = SourceLocation());
2731
2732   /// \brief Given a variable, determine the type that a reference to that
2733   /// variable will have in the given scope.
2734   QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
2735
2736   void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
2737   void MarkDeclarationsReferencedInExpr(Expr *E,
2738                                         bool SkipLocalVariables = false);
2739
2740   /// \brief Try to recover by turning the given expression into a
2741   /// call.  Returns true if recovery was attempted or an error was
2742   /// emitted; this may also leave the ExprResult invalid.
2743   bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2744                             bool ForceComplain = false,
2745                             bool (*IsPlausibleResult)(QualType) = 0);
2746
2747   /// \brief Figure out if an expression could be turned into a call.
2748   bool isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
2749                       UnresolvedSetImpl &NonTemplateOverloads);
2750
2751   /// \brief Conditionally issue a diagnostic based on the current
2752   /// evaluation context.
2753   ///
2754   /// \param Statement If Statement is non-null, delay reporting the
2755   /// diagnostic until the function body is parsed, and then do a basic
2756   /// reachability analysis to determine if the statement is reachable.
2757   /// If it is unreachable, the diagnostic will not be emitted.
2758   bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
2759                            const PartialDiagnostic &PD);
2760
2761   // Primary Expressions.
2762   SourceRange getExprRange(Expr *E) const;
2763
2764   ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
2765                                SourceLocation TemplateKWLoc,
2766                                UnqualifiedId &Id,
2767                                bool HasTrailingLParen, bool IsAddressOfOperand,
2768                                CorrectionCandidateCallback *CCC = 0);
2769
2770   void DecomposeUnqualifiedId(const UnqualifiedId &Id,
2771                               TemplateArgumentListInfo &Buffer,
2772                               DeclarationNameInfo &NameInfo,
2773                               const TemplateArgumentListInfo *&TemplateArgs);
2774
2775   bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
2776                            CorrectionCandidateCallback &CCC,
2777                            TemplateArgumentListInfo *ExplicitTemplateArgs = 0,
2778                        llvm::ArrayRef<Expr *> Args = llvm::ArrayRef<Expr *>());
2779
2780   ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
2781                                 IdentifierInfo *II,
2782                                 bool AllowBuiltinCreation=false);
2783
2784   ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
2785                                         SourceLocation TemplateKWLoc,
2786                                         const DeclarationNameInfo &NameInfo,
2787                                         bool isAddressOfOperand,
2788                                 const TemplateArgumentListInfo *TemplateArgs);
2789
2790   ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty,
2791                               ExprValueKind VK,
2792                               SourceLocation Loc,
2793                               const CXXScopeSpec *SS = 0);
2794   ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty,
2795                               ExprValueKind VK,
2796                               const DeclarationNameInfo &NameInfo,
2797                               const CXXScopeSpec *SS = 0);
2798   ExprResult
2799   BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
2800                                            SourceLocation nameLoc,
2801                                            IndirectFieldDecl *indirectField,
2802                                            Expr *baseObjectExpr = 0,
2803                                       SourceLocation opLoc = SourceLocation());
2804   ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
2805                                              SourceLocation TemplateKWLoc,
2806                                              LookupResult &R,
2807                                 const TemplateArgumentListInfo *TemplateArgs);
2808   ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
2809                                      SourceLocation TemplateKWLoc,
2810                                      LookupResult &R,
2811                                 const TemplateArgumentListInfo *TemplateArgs,
2812                                      bool IsDefiniteInstance);
2813   bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
2814                                   const LookupResult &R,
2815                                   bool HasTrailingLParen);
2816
2817   ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
2818                                          const DeclarationNameInfo &NameInfo);
2819   ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
2820                                        SourceLocation TemplateKWLoc,
2821                                 const DeclarationNameInfo &NameInfo,
2822                                 const TemplateArgumentListInfo *TemplateArgs);
2823
2824   ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
2825                                       LookupResult &R,
2826                                       bool NeedsADL);
2827   ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
2828                                       const DeclarationNameInfo &NameInfo,
2829                                       NamedDecl *D);
2830
2831   ExprResult BuildLiteralOperatorCall(LookupResult &R,
2832                                       DeclarationNameInfo &SuffixInfo,
2833                                       ArrayRef<Expr*> Args,
2834                                       SourceLocation LitEndLoc,
2835                             TemplateArgumentListInfo *ExplicitTemplateArgs = 0);
2836
2837   ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
2838   ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
2839   ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = 0);
2840   ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope = 0);
2841   ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
2842   ExprResult ActOnParenListExpr(SourceLocation L,
2843                                 SourceLocation R,
2844                                 MultiExprArg Val);
2845
2846   /// ActOnStringLiteral - The specified tokens were lexed as pasted string
2847   /// fragments (e.g. "foo" "bar" L"baz").
2848   ExprResult ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks,
2849                                 Scope *UDLScope = 0);
2850
2851   ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
2852                                        SourceLocation DefaultLoc,
2853                                        SourceLocation RParenLoc,
2854                                        Expr *ControllingExpr,
2855                                        MultiTypeArg ArgTypes,
2856                                        MultiExprArg ArgExprs);
2857   ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
2858                                         SourceLocation DefaultLoc,
2859                                         SourceLocation RParenLoc,
2860                                         Expr *ControllingExpr,
2861                                         TypeSourceInfo **Types,
2862                                         Expr **Exprs,
2863                                         unsigned NumAssocs);
2864
2865   // Binary/Unary Operators.  'Tok' is the token for the operator.
2866   ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
2867                                   Expr *InputExpr);
2868   ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
2869                           UnaryOperatorKind Opc, Expr *Input);
2870   ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
2871                           tok::TokenKind Op, Expr *Input);
2872
2873   ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
2874                                             SourceLocation OpLoc,
2875                                             UnaryExprOrTypeTrait ExprKind,
2876                                             SourceRange R);
2877   ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
2878                                             UnaryExprOrTypeTrait ExprKind);
2879   ExprResult
2880     ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
2881                                   UnaryExprOrTypeTrait ExprKind,
2882                                   bool IsType, void *TyOrEx,
2883                                   const SourceRange &ArgRange);
2884
2885   ExprResult CheckPlaceholderExpr(Expr *E);
2886   bool CheckVecStepExpr(Expr *E);
2887
2888   bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
2889   bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
2890                                         SourceRange ExprRange,
2891                                         UnaryExprOrTypeTrait ExprKind);
2892   ExprResult ActOnSizeofParameterPackExpr(Scope *S,
2893                                           SourceLocation OpLoc,
2894                                           IdentifierInfo &Name,
2895                                           SourceLocation NameLoc,
2896                                           SourceLocation RParenLoc);
2897   ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
2898                                  tok::TokenKind Kind, Expr *Input);
2899
2900   ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
2901                                      Expr *Idx, SourceLocation RLoc);
2902   ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
2903                                              Expr *Idx, SourceLocation RLoc);
2904
2905   ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
2906                                       SourceLocation OpLoc, bool IsArrow,
2907                                       CXXScopeSpec &SS,
2908                                       SourceLocation TemplateKWLoc,
2909                                       NamedDecl *FirstQualifierInScope,
2910                                 const DeclarationNameInfo &NameInfo,
2911                                 const TemplateArgumentListInfo *TemplateArgs);
2912
2913   // This struct is for use by ActOnMemberAccess to allow
2914   // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
2915   // changing the access operator from a '.' to a '->' (to see if that is the
2916   // change needed to fix an error about an unknown member, e.g. when the class
2917   // defines a custom operator->).
2918   struct ActOnMemberAccessExtraArgs {
2919     Scope *S;
2920     UnqualifiedId &Id;
2921     Decl *ObjCImpDecl;
2922     bool HasTrailingLParen;
2923   };
2924
2925   ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
2926                                       SourceLocation OpLoc, bool IsArrow,
2927                                       const CXXScopeSpec &SS,
2928                                       SourceLocation TemplateKWLoc,
2929                                       NamedDecl *FirstQualifierInScope,
2930                                       LookupResult &R,
2931                                  const TemplateArgumentListInfo *TemplateArgs,
2932                                       bool SuppressQualifierCheck = false,
2933                                      ActOnMemberAccessExtraArgs *ExtraArgs = 0);
2934
2935   ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
2936   ExprResult LookupMemberExpr(LookupResult &R, ExprResult &Base,
2937                               bool &IsArrow, SourceLocation OpLoc,
2938                               CXXScopeSpec &SS,
2939                               Decl *ObjCImpDecl,
2940                               bool HasTemplateArgs);
2941
2942   bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
2943                                      const CXXScopeSpec &SS,
2944                                      const LookupResult &R);
2945
2946   ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
2947                                       bool IsArrow, SourceLocation OpLoc,
2948                                       const CXXScopeSpec &SS,
2949                                       SourceLocation TemplateKWLoc,
2950                                       NamedDecl *FirstQualifierInScope,
2951                                const DeclarationNameInfo &NameInfo,
2952                                const TemplateArgumentListInfo *TemplateArgs);
2953
2954   ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
2955                                    SourceLocation OpLoc,
2956                                    tok::TokenKind OpKind,
2957                                    CXXScopeSpec &SS,
2958                                    SourceLocation TemplateKWLoc,
2959                                    UnqualifiedId &Member,
2960                                    Decl *ObjCImpDecl,
2961                                    bool HasTrailingLParen);
2962
2963   void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
2964   bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
2965                                FunctionDecl *FDecl,
2966                                const FunctionProtoType *Proto,
2967                                Expr **Args, unsigned NumArgs,
2968                                SourceLocation RParenLoc,
2969                                bool ExecConfig = false);
2970   void CheckStaticArrayArgument(SourceLocation CallLoc,
2971                                 ParmVarDecl *Param,
2972                                 const Expr *ArgExpr);
2973
2974   /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
2975   /// This provides the location of the left/right parens and a list of comma
2976   /// locations.
2977   ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
2978                            MultiExprArg ArgExprs, SourceLocation RParenLoc,
2979                            Expr *ExecConfig = 0, bool IsExecConfig = false);
2980   ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
2981                                    SourceLocation LParenLoc,
2982                                    Expr **Args, unsigned NumArgs,
2983                                    SourceLocation RParenLoc,
2984                                    Expr *Config = 0,
2985                                    bool IsExecConfig = false);
2986
2987   ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
2988                                      MultiExprArg ExecConfig,
2989                                      SourceLocation GGGLoc);
2990
2991   ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
2992                            Declarator &D, ParsedType &Ty,
2993                            SourceLocation RParenLoc, Expr *CastExpr);
2994   ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
2995                                  TypeSourceInfo *Ty,
2996                                  SourceLocation RParenLoc,
2997                                  Expr *Op);
2998   CastKind PrepareScalarCast(ExprResult &src, QualType destType);
2999
3000   /// \brief Build an altivec or OpenCL literal.
3001   ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
3002                                 SourceLocation RParenLoc, Expr *E,
3003                                 TypeSourceInfo *TInfo);
3004
3005   ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
3006
3007   ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
3008                                   ParsedType Ty,
3009                                   SourceLocation RParenLoc,
3010                                   Expr *InitExpr);
3011
3012   ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
3013                                       TypeSourceInfo *TInfo,
3014                                       SourceLocation RParenLoc,
3015                                       Expr *LiteralExpr);
3016
3017   ExprResult ActOnInitList(SourceLocation LBraceLoc,
3018                            MultiExprArg InitArgList,
3019                            SourceLocation RBraceLoc);
3020
3021   ExprResult ActOnDesignatedInitializer(Designation &Desig,
3022                                         SourceLocation Loc,
3023                                         bool GNUSyntax,
3024                                         ExprResult Init);
3025
3026   ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
3027                         tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
3028   ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
3029                         BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
3030   ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
3031                                 Expr *LHSExpr, Expr *RHSExpr);
3032
3033   /// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
3034   /// in the case of a the GNU conditional expr extension.
3035   ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
3036                                 SourceLocation ColonLoc,
3037                                 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
3038
3039   /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
3040   ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
3041                             LabelDecl *TheDecl);
3042
3043   void ActOnStartStmtExpr();
3044   ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
3045                            SourceLocation RPLoc); // "({..})"
3046   void ActOnStmtExprError();
3047
3048   // __builtin_offsetof(type, identifier(.identifier|[expr])*)
3049   struct OffsetOfComponent {
3050     SourceLocation LocStart, LocEnd;
3051     bool isBrackets;  // true if [expr], false if .ident
3052     union {
3053       IdentifierInfo *IdentInfo;
3054       Expr *E;
3055     } U;
3056   };
3057
3058   /// __builtin_offsetof(type, a.b[123][456].c)
3059   ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
3060                                   TypeSourceInfo *TInfo,
3061                                   OffsetOfComponent *CompPtr,
3062                                   unsigned NumComponents,
3063                                   SourceLocation RParenLoc);
3064   ExprResult ActOnBuiltinOffsetOf(Scope *S,
3065                                   SourceLocation BuiltinLoc,
3066                                   SourceLocation TypeLoc,
3067                                   ParsedType ParsedArgTy,
3068                                   OffsetOfComponent *CompPtr,
3069                                   unsigned NumComponents,
3070                                   SourceLocation RParenLoc);
3071
3072   // __builtin_choose_expr(constExpr, expr1, expr2)
3073   ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
3074                              Expr *CondExpr, Expr *LHSExpr,
3075                              Expr *RHSExpr, SourceLocation RPLoc);
3076
3077   // __builtin_va_arg(expr, type)
3078   ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
3079                         SourceLocation RPLoc);
3080   ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
3081                             TypeSourceInfo *TInfo, SourceLocation RPLoc);
3082
3083   // __null
3084   ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
3085
3086   bool CheckCaseExpression(Expr *E);
3087
3088   /// \brief Describes the result of an "if-exists" condition check.
3089   enum IfExistsResult {
3090     /// \brief The symbol exists.
3091     IER_Exists,
3092
3093     /// \brief The symbol does not exist.
3094     IER_DoesNotExist,
3095
3096     /// \brief The name is a dependent name, so the results will differ
3097     /// from one instantiation to the next.
3098     IER_Dependent,
3099
3100     /// \brief An error occurred.
3101     IER_Error
3102   };
3103
3104   IfExistsResult
3105   CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
3106                                const DeclarationNameInfo &TargetNameInfo);
3107
3108   IfExistsResult
3109   CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
3110                                bool IsIfExists, CXXScopeSpec &SS,
3111                                UnqualifiedId &Name);
3112
3113   StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
3114                                         bool IsIfExists,
3115                                         NestedNameSpecifierLoc QualifierLoc,
3116                                         DeclarationNameInfo NameInfo,
3117                                         Stmt *Nested);
3118   StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
3119                                         bool IsIfExists,
3120                                         CXXScopeSpec &SS, UnqualifiedId &Name,
3121                                         Stmt *Nested);
3122
3123   //===------------------------- "Block" Extension ------------------------===//
3124
3125   /// ActOnBlockStart - This callback is invoked when a block literal is
3126   /// started.
3127   void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
3128
3129   /// ActOnBlockArguments - This callback allows processing of block arguments.
3130   /// If there are no arguments, this is still invoked.
3131   void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
3132                            Scope *CurScope);
3133
3134   /// ActOnBlockError - If there is an error parsing a block, this callback
3135   /// is invoked to pop the information about the block from the action impl.
3136   void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
3137
3138   /// ActOnBlockStmtExpr - This is called when the body of a block statement
3139   /// literal was successfully completed.  ^(int x){...}
3140   ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
3141                                 Scope *CurScope);
3142
3143   //===---------------------------- OpenCL Features -----------------------===//
3144
3145   /// __builtin_astype(...)
3146   ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
3147                              SourceLocation BuiltinLoc,
3148                              SourceLocation RParenLoc);
3149
3150   //===---------------------------- C++ Features --------------------------===//
3151
3152   // Act on C++ namespaces
3153   Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
3154                                SourceLocation NamespaceLoc,
3155                                SourceLocation IdentLoc,
3156                                IdentifierInfo *Ident,
3157                                SourceLocation LBrace,
3158                                AttributeList *AttrList);
3159   void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
3160
3161   NamespaceDecl *getStdNamespace() const;
3162   NamespaceDecl *getOrCreateStdNamespace();
3163
3164   CXXRecordDecl *getStdBadAlloc() const;
3165
3166   /// \brief Tests whether Ty is an instance of std::initializer_list and, if
3167   /// it is and Element is not NULL, assigns the element type to Element.
3168   bool isStdInitializerList(QualType Ty, QualType *Element);
3169
3170   /// \brief Looks for the std::initializer_list template and instantiates it
3171   /// with Element, or emits an error if it's not found.
3172   ///
3173   /// \returns The instantiated template, or null on error.
3174   QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
3175
3176   /// \brief Determine whether Ctor is an initializer-list constructor, as
3177   /// defined in [dcl.init.list]p2.
3178   bool isInitListConstructor(const CXXConstructorDecl *Ctor);
3179
3180   Decl *ActOnUsingDirective(Scope *CurScope,
3181                             SourceLocation UsingLoc,
3182                             SourceLocation NamespcLoc,
3183                             CXXScopeSpec &SS,
3184                             SourceLocation IdentLoc,
3185                             IdentifierInfo *NamespcName,
3186                             AttributeList *AttrList);
3187
3188   void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
3189
3190   Decl *ActOnNamespaceAliasDef(Scope *CurScope,
3191                                SourceLocation NamespaceLoc,
3192                                SourceLocation AliasLoc,
3193                                IdentifierInfo *Alias,
3194                                CXXScopeSpec &SS,
3195                                SourceLocation IdentLoc,
3196                                IdentifierInfo *Ident);
3197
3198   void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
3199   bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target,
3200                             const LookupResult &PreviousDecls);
3201   UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,
3202                                         NamedDecl *Target);
3203
3204   bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
3205                                    bool isTypeName,
3206                                    const CXXScopeSpec &SS,
3207                                    SourceLocation NameLoc,
3208                                    const LookupResult &Previous);
3209   bool CheckUsingDeclQualifier(SourceLocation UsingLoc,
3210                                const CXXScopeSpec &SS,
3211                                SourceLocation NameLoc);
3212
3213   NamedDecl *BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
3214                                    SourceLocation UsingLoc,
3215                                    CXXScopeSpec &SS,
3216                                    const DeclarationNameInfo &NameInfo,
3217                                    AttributeList *AttrList,
3218                                    bool IsInstantiation,
3219                                    bool IsTypeName,
3220                                    SourceLocation TypenameLoc);
3221
3222   bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
3223
3224   Decl *ActOnUsingDeclaration(Scope *CurScope,
3225                               AccessSpecifier AS,
3226                               bool HasUsingKeyword,
3227                               SourceLocation UsingLoc,
3228                               CXXScopeSpec &SS,
3229                               UnqualifiedId &Name,
3230                               AttributeList *AttrList,
3231                               bool IsTypeName,
3232                               SourceLocation TypenameLoc);
3233   Decl *ActOnAliasDeclaration(Scope *CurScope,
3234                               AccessSpecifier AS,
3235                               MultiTemplateParamsArg TemplateParams,
3236                               SourceLocation UsingLoc,
3237                               UnqualifiedId &Name,
3238                               TypeResult Type);
3239
3240   /// InitializeVarWithConstructor - Creates an CXXConstructExpr
3241   /// and sets it as the initializer for&nbs