e1365e84a0b3f81b74a6cc0ca9dff957ae684f79
[lldb.git] / clang / include / clang / Sema / Sema.h
1 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the Sema class, which performs semantic analysis and
10 // builds ASTs.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_CLANG_SEMA_SEMA_H
15 #define LLVM_CLANG_SEMA_SEMA_H
16
17 #include "clang/AST/ASTConcept.h"
18 #include "clang/AST/ASTFwd.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/Availability.h"
21 #include "clang/AST/ComparisonCategories.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/DeclarationName.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprConcepts.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/ExprOpenMP.h"
29 #include "clang/AST/ExternalASTSource.h"
30 #include "clang/AST/LocInfoType.h"
31 #include "clang/AST/MangleNumberingContext.h"
32 #include "clang/AST/NSAPI.h"
33 #include "clang/AST/PrettyPrinter.h"
34 #include "clang/AST/StmtCXX.h"
35 #include "clang/AST/TypeLoc.h"
36 #include "clang/AST/TypeOrdering.h"
37 #include "clang/Basic/BitmaskEnum.h"
38 #include "clang/Basic/ExpressionTraits.h"
39 #include "clang/Basic/Module.h"
40 #include "clang/Basic/OpenCLOptions.h"
41 #include "clang/Basic/OpenMPKinds.h"
42 #include "clang/Basic/PragmaKinds.h"
43 #include "clang/Basic/Specifiers.h"
44 #include "clang/Basic/TemplateKinds.h"
45 #include "clang/Basic/TypeTraits.h"
46 #include "clang/Sema/AnalysisBasedWarnings.h"
47 #include "clang/Sema/CleanupInfo.h"
48 #include "clang/Sema/DeclSpec.h"
49 #include "clang/Sema/ExternalSemaSource.h"
50 #include "clang/Sema/IdentifierResolver.h"
51 #include "clang/Sema/ObjCMethodList.h"
52 #include "clang/Sema/Ownership.h"
53 #include "clang/Sema/Scope.h"
54 #include "clang/Sema/SemaConcept.h"
55 #include "clang/Sema/TypoCorrection.h"
56 #include "clang/Sema/Weak.h"
57 #include "llvm/ADT/ArrayRef.h"
58 #include "llvm/ADT/Optional.h"
59 #include "llvm/ADT/SetVector.h"
60 #include "llvm/ADT/SmallBitVector.h"
61 #include "llvm/ADT/SmallPtrSet.h"
62 #include "llvm/ADT/SmallVector.h"
63 #include "llvm/ADT/TinyPtrVector.h"
64 #include "llvm/Frontend/OpenMP/OMPConstants.h"
65 #include <deque>
66 #include <memory>
67 #include <string>
68 #include <tuple>
69 #include <vector>
70
71 namespace llvm {
72   class APSInt;
73   template <typename ValueT> struct DenseMapInfo;
74   template <typename ValueT, typename ValueInfoT> class DenseSet;
75   class SmallBitVector;
76   struct InlineAsmIdentifierInfo;
77 }
78
79 namespace clang {
80   class ADLResult;
81   class ASTConsumer;
82   class ASTContext;
83   class ASTMutationListener;
84   class ASTReader;
85   class ASTWriter;
86   class ArrayType;
87   class ParsedAttr;
88   class BindingDecl;
89   class BlockDecl;
90   class CapturedDecl;
91   class CXXBasePath;
92   class CXXBasePaths;
93   class CXXBindTemporaryExpr;
94   typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
95   class CXXConstructorDecl;
96   class CXXConversionDecl;
97   class CXXDeleteExpr;
98   class CXXDestructorDecl;
99   class CXXFieldCollector;
100   class CXXMemberCallExpr;
101   class CXXMethodDecl;
102   class CXXScopeSpec;
103   class CXXTemporary;
104   class CXXTryStmt;
105   class CallExpr;
106   class ClassTemplateDecl;
107   class ClassTemplatePartialSpecializationDecl;
108   class ClassTemplateSpecializationDecl;
109   class VarTemplatePartialSpecializationDecl;
110   class CodeCompleteConsumer;
111   class CodeCompletionAllocator;
112   class CodeCompletionTUInfo;
113   class CodeCompletionResult;
114   class CoroutineBodyStmt;
115   class Decl;
116   class DeclAccessPair;
117   class DeclContext;
118   class DeclRefExpr;
119   class DeclaratorDecl;
120   class DeducedTemplateArgument;
121   class DependentDiagnostic;
122   class DesignatedInitExpr;
123   class Designation;
124   class EnableIfAttr;
125   class EnumConstantDecl;
126   class Expr;
127   class ExtVectorType;
128   class FormatAttr;
129   class FriendDecl;
130   class FunctionDecl;
131   class FunctionProtoType;
132   class FunctionTemplateDecl;
133   class ImplicitConversionSequence;
134   typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
135   class InitListExpr;
136   class InitializationKind;
137   class InitializationSequence;
138   class InitializedEntity;
139   class IntegerLiteral;
140   class LabelStmt;
141   class LambdaExpr;
142   class LangOptions;
143   class LocalInstantiationScope;
144   class LookupResult;
145   class MacroInfo;
146   typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
147   class ModuleLoader;
148   class MultiLevelTemplateArgumentList;
149   class NamedDecl;
150   class ObjCCategoryDecl;
151   class ObjCCategoryImplDecl;
152   class ObjCCompatibleAliasDecl;
153   class ObjCContainerDecl;
154   class ObjCImplDecl;
155   class ObjCImplementationDecl;
156   class ObjCInterfaceDecl;
157   class ObjCIvarDecl;
158   template <class T> class ObjCList;
159   class ObjCMessageExpr;
160   class ObjCMethodDecl;
161   class ObjCPropertyDecl;
162   class ObjCProtocolDecl;
163   class OMPThreadPrivateDecl;
164   class OMPRequiresDecl;
165   class OMPDeclareReductionDecl;
166   class OMPDeclareSimdDecl;
167   class OMPClause;
168   struct OMPVarListLocTy;
169   struct OverloadCandidate;
170   enum class OverloadCandidateParamOrder : char;
171   enum OverloadCandidateRewriteKind : unsigned;
172   class OverloadCandidateSet;
173   class OverloadExpr;
174   class ParenListExpr;
175   class ParmVarDecl;
176   class Preprocessor;
177   class PseudoDestructorTypeStorage;
178   class PseudoObjectExpr;
179   class QualType;
180   class StandardConversionSequence;
181   class Stmt;
182   class StringLiteral;
183   class SwitchStmt;
184   class TemplateArgument;
185   class TemplateArgumentList;
186   class TemplateArgumentLoc;
187   class TemplateDecl;
188   class TemplateInstantiationCallback;
189   class TemplateParameterList;
190   class TemplatePartialOrderingContext;
191   class TemplateTemplateParmDecl;
192   class Token;
193   class TypeAliasDecl;
194   class TypedefDecl;
195   class TypedefNameDecl;
196   class TypeLoc;
197   class TypoCorrectionConsumer;
198   class UnqualifiedId;
199   class UnresolvedLookupExpr;
200   class UnresolvedMemberExpr;
201   class UnresolvedSetImpl;
202   class UnresolvedSetIterator;
203   class UsingDecl;
204   class UsingShadowDecl;
205   class ValueDecl;
206   class VarDecl;
207   class VarTemplateSpecializationDecl;
208   class VisibilityAttr;
209   class VisibleDeclConsumer;
210   class IndirectFieldDecl;
211   struct DeductionFailureInfo;
212   class TemplateSpecCandidateSet;
213
214 namespace sema {
215   class AccessedEntity;
216   class BlockScopeInfo;
217   class Capture;
218   class CapturedRegionScopeInfo;
219   class CapturingScopeInfo;
220   class CompoundScopeInfo;
221   class DelayedDiagnostic;
222   class DelayedDiagnosticPool;
223   class FunctionScopeInfo;
224   class LambdaScopeInfo;
225   class PossiblyUnreachableDiag;
226   class SemaPPCallbacks;
227   class TemplateDeductionInfo;
228 }
229
230 namespace threadSafety {
231   class BeforeSet;
232   void threadSafetyCleanup(BeforeSet* Cache);
233 }
234
235 // FIXME: No way to easily map from TemplateTypeParmTypes to
236 // TemplateTypeParmDecls, so we have this horrible PointerUnion.
237 typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
238                   SourceLocation> UnexpandedParameterPack;
239
240 /// Describes whether we've seen any nullability information for the given
241 /// file.
242 struct FileNullability {
243   /// The first pointer declarator (of any pointer kind) in the file that does
244   /// not have a corresponding nullability annotation.
245   SourceLocation PointerLoc;
246
247   /// The end location for the first pointer declarator in the file. Used for
248   /// placing fix-its.
249   SourceLocation PointerEndLoc;
250
251   /// Which kind of pointer declarator we saw.
252   uint8_t PointerKind;
253
254   /// Whether we saw any type nullability annotations in the given file.
255   bool SawTypeNullability = false;
256 };
257
258 /// A mapping from file IDs to a record of whether we've seen nullability
259 /// information in that file.
260 class FileNullabilityMap {
261   /// A mapping from file IDs to the nullability information for each file ID.
262   llvm::DenseMap<FileID, FileNullability> Map;
263
264   /// A single-element cache based on the file ID.
265   struct {
266     FileID File;
267     FileNullability Nullability;
268   } Cache;
269
270 public:
271   FileNullability &operator[](FileID file) {
272     // Check the single-element cache.
273     if (file == Cache.File)
274       return Cache.Nullability;
275
276     // It's not in the single-element cache; flush the cache if we have one.
277     if (!Cache.File.isInvalid()) {
278       Map[Cache.File] = Cache.Nullability;
279     }
280
281     // Pull this entry into the cache.
282     Cache.File = file;
283     Cache.Nullability = Map[file];
284     return Cache.Nullability;
285   }
286 };
287
288 /// Keeps track of expected type during expression parsing. The type is tied to
289 /// a particular token, all functions that update or consume the type take a
290 /// start location of the token they are looking at as a parameter. This allows
291 /// to avoid updating the type on hot paths in the parser.
292 class PreferredTypeBuilder {
293 public:
294   PreferredTypeBuilder() = default;
295   explicit PreferredTypeBuilder(QualType Type) : Type(Type) {}
296
297   void enterCondition(Sema &S, SourceLocation Tok);
298   void enterReturn(Sema &S, SourceLocation Tok);
299   void enterVariableInit(SourceLocation Tok, Decl *D);
300   /// Computing a type for the function argument may require running
301   /// overloading, so we postpone its computation until it is actually needed.
302   ///
303   /// Clients should be very careful when using this funciton, as it stores a
304   /// function_ref, clients should make sure all calls to get() with the same
305   /// location happen while function_ref is alive.
306   void enterFunctionArgument(SourceLocation Tok,
307                              llvm::function_ref<QualType()> ComputeType);
308
309   void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc);
310   void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind,
311                   SourceLocation OpLoc);
312   void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);
313   void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);
314   void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);
315   /// Handles all type casts, including C-style cast, C++ casts, etc.
316   void enterTypeCast(SourceLocation Tok, QualType CastType);
317
318   QualType get(SourceLocation Tok) const {
319     if (Tok != ExpectedLoc)
320       return QualType();
321     if (!Type.isNull())
322       return Type;
323     if (ComputeType)
324       return ComputeType();
325     return QualType();
326   }
327
328 private:
329   /// Start position of a token for which we store expected type.
330   SourceLocation ExpectedLoc;
331   /// Expected type for a token starting at ExpectedLoc.
332   QualType Type;
333   /// A function to compute expected type at ExpectedLoc. It is only considered
334   /// if Type is null.
335   llvm::function_ref<QualType()> ComputeType;
336 };
337
338 /// Sema - This implements semantic analysis and AST building for C.
339 class Sema final {
340   Sema(const Sema &) = delete;
341   void operator=(const Sema &) = delete;
342
343   /// A key method to reduce duplicate debug info from Sema.
344   virtual void anchor();
345
346   ///Source of additional semantic information.
347   ExternalSemaSource *ExternalSource;
348
349   ///Whether Sema has generated a multiplexer and has to delete it.
350   bool isMultiplexExternalSource;
351
352   static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
353
354   bool isVisibleSlow(const NamedDecl *D);
355
356   /// Determine whether two declarations should be linked together, given that
357   /// the old declaration might not be visible and the new declaration might
358   /// not have external linkage.
359   bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
360                                     const NamedDecl *New) {
361     if (isVisible(Old))
362      return true;
363     // See comment in below overload for why it's safe to compute the linkage
364     // of the new declaration here.
365     if (New->isExternallyDeclarable()) {
366       assert(Old->isExternallyDeclarable() &&
367              "should not have found a non-externally-declarable previous decl");
368       return true;
369     }
370     return false;
371   }
372   bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
373
374   void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
375                                       QualType ResultTy,
376                                       ArrayRef<QualType> Args);
377
378 public:
379   /// The maximum alignment, same as in llvm::Value. We duplicate them here
380   /// because that allows us not to duplicate the constants in clang code,
381   /// which we must to since we can't directly use the llvm constants.
382   /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp
383   ///
384   /// This is the greatest alignment value supported by load, store, and alloca
385   /// instructions, and global values.
386   static const unsigned MaxAlignmentExponent = 29;
387   static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
388
389   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
390   typedef OpaquePtr<TemplateName> TemplateTy;
391   typedef OpaquePtr<QualType> TypeTy;
392
393   OpenCLOptions OpenCLFeatures;
394   FPOptions FPFeatures;
395
396   const LangOptions &LangOpts;
397   Preprocessor &PP;
398   ASTContext &Context;
399   ASTConsumer &Consumer;
400   DiagnosticsEngine &Diags;
401   SourceManager &SourceMgr;
402
403   /// Flag indicating whether or not to collect detailed statistics.
404   bool CollectStats;
405
406   /// Code-completion consumer.
407   CodeCompleteConsumer *CodeCompleter;
408
409   /// CurContext - This is the current declaration context of parsing.
410   DeclContext *CurContext;
411
412   /// Generally null except when we temporarily switch decl contexts,
413   /// like in \see ActOnObjCTemporaryExitContainerContext.
414   DeclContext *OriginalLexicalContext;
415
416   /// VAListTagName - The declaration name corresponding to __va_list_tag.
417   /// This is used as part of a hack to omit that class from ADL results.
418   DeclarationName VAListTagName;
419
420   bool MSStructPragmaOn; // True when \#pragma ms_struct on
421
422   /// Controls member pointer representation format under the MS ABI.
423   LangOptions::PragmaMSPointersToMembersKind
424       MSPointerToMemberRepresentationMethod;
425
426   /// Stack of active SEH __finally scopes.  Can be empty.
427   SmallVector<Scope*, 2> CurrentSEHFinally;
428
429   /// Source location for newly created implicit MSInheritanceAttrs
430   SourceLocation ImplicitMSInheritanceAttrLoc;
431
432   /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by
433   /// `TransformTypos` in order to keep track of any TypoExprs that are created
434   /// recursively during typo correction and wipe them away if the correction
435   /// fails.
436   llvm::SmallVector<TypoExpr *, 2> TypoExprs;
437
438   /// pragma clang section kind
439   enum PragmaClangSectionKind {
440     PCSK_Invalid      = 0,
441     PCSK_BSS          = 1,
442     PCSK_Data         = 2,
443     PCSK_Rodata       = 3,
444     PCSK_Text         = 4,
445     PCSK_Relro        = 5
446    };
447
448   enum PragmaClangSectionAction {
449     PCSA_Set     = 0,
450     PCSA_Clear   = 1
451   };
452
453   struct PragmaClangSection {
454     std::string SectionName;
455     bool Valid = false;
456     SourceLocation PragmaLocation;
457
458     void Act(SourceLocation PragmaLocation,
459              PragmaClangSectionAction Action,
460              StringLiteral* Name);
461    };
462
463    PragmaClangSection PragmaClangBSSSection;
464    PragmaClangSection PragmaClangDataSection;
465    PragmaClangSection PragmaClangRodataSection;
466    PragmaClangSection PragmaClangRelroSection;
467    PragmaClangSection PragmaClangTextSection;
468
469   enum PragmaMsStackAction {
470     PSK_Reset     = 0x0,                // #pragma ()
471     PSK_Set       = 0x1,                // #pragma (value)
472     PSK_Push      = 0x2,                // #pragma (push[, id])
473     PSK_Pop       = 0x4,                // #pragma (pop[, id])
474     PSK_Show      = 0x8,                // #pragma (show) -- only for "pack"!
475     PSK_Push_Set  = PSK_Push | PSK_Set, // #pragma (push[, id], value)
476     PSK_Pop_Set   = PSK_Pop | PSK_Set,  // #pragma (pop[, id], value)
477   };
478
479   template<typename ValueType>
480   struct PragmaStack {
481     struct Slot {
482       llvm::StringRef StackSlotLabel;
483       ValueType Value;
484       SourceLocation PragmaLocation;
485       SourceLocation PragmaPushLocation;
486       Slot(llvm::StringRef StackSlotLabel, ValueType Value,
487            SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
488           : StackSlotLabel(StackSlotLabel), Value(Value),
489             PragmaLocation(PragmaLocation),
490             PragmaPushLocation(PragmaPushLocation) {}
491     };
492     void Act(SourceLocation PragmaLocation,
493              PragmaMsStackAction Action,
494              llvm::StringRef StackSlotLabel,
495              ValueType Value);
496
497     // MSVC seems to add artificial slots to #pragma stacks on entering a C++
498     // method body to restore the stacks on exit, so it works like this:
499     //
500     //   struct S {
501     //     #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
502     //     void Method {}
503     //     #pragma <name>(pop, InternalPragmaSlot)
504     //   };
505     //
506     // It works even with #pragma vtordisp, although MSVC doesn't support
507     //   #pragma vtordisp(push [, id], n)
508     // syntax.
509     //
510     // Push / pop a named sentinel slot.
511     void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
512       assert((Action == PSK_Push || Action == PSK_Pop) &&
513              "Can only push / pop #pragma stack sentinels!");
514       Act(CurrentPragmaLocation, Action, Label, CurrentValue);
515     }
516
517     // Constructors.
518     explicit PragmaStack(const ValueType &Default)
519         : DefaultValue(Default), CurrentValue(Default) {}
520
521     bool hasValue() const { return CurrentValue != DefaultValue; }
522
523     SmallVector<Slot, 2> Stack;
524     ValueType DefaultValue; // Value used for PSK_Reset action.
525     ValueType CurrentValue;
526     SourceLocation CurrentPragmaLocation;
527   };
528   // FIXME: We should serialize / deserialize these if they occur in a PCH (but
529   // we shouldn't do so if they're in a module).
530
531   /// Whether to insert vtordisps prior to virtual bases in the Microsoft
532   /// C++ ABI.  Possible values are 0, 1, and 2, which mean:
533   ///
534   /// 0: Suppress all vtordisps
535   /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
536   ///    structors
537   /// 2: Always insert vtordisps to support RTTI on partially constructed
538   ///    objects
539   PragmaStack<MSVtorDispMode> VtorDispStack;
540   // #pragma pack.
541   // Sentinel to represent when the stack is set to mac68k alignment.
542   static const unsigned kMac68kAlignmentSentinel = ~0U;
543   PragmaStack<unsigned> PackStack;
544   // The current #pragma pack values and locations at each #include.
545   struct PackIncludeState {
546     unsigned CurrentValue;
547     SourceLocation CurrentPragmaLocation;
548     bool HasNonDefaultValue, ShouldWarnOnInclude;
549   };
550   SmallVector<PackIncludeState, 8> PackIncludeStack;
551   // Segment #pragmas.
552   PragmaStack<StringLiteral *> DataSegStack;
553   PragmaStack<StringLiteral *> BSSSegStack;
554   PragmaStack<StringLiteral *> ConstSegStack;
555   PragmaStack<StringLiteral *> CodeSegStack;
556
557   // RAII object to push / pop sentinel slots for all MS #pragma stacks.
558   // Actions should be performed only if we enter / exit a C++ method body.
559   class PragmaStackSentinelRAII {
560   public:
561     PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
562     ~PragmaStackSentinelRAII();
563
564   private:
565     Sema &S;
566     StringRef SlotLabel;
567     bool ShouldAct;
568   };
569
570   /// A mapping that describes the nullability we've seen in each header file.
571   FileNullabilityMap NullabilityMap;
572
573   /// Last section used with #pragma init_seg.
574   StringLiteral *CurInitSeg;
575   SourceLocation CurInitSegLoc;
576
577   /// VisContext - Manages the stack for \#pragma GCC visibility.
578   void *VisContext; // Really a "PragmaVisStack*"
579
580   /// This an attribute introduced by \#pragma clang attribute.
581   struct PragmaAttributeEntry {
582     SourceLocation Loc;
583     ParsedAttr *Attribute;
584     SmallVector<attr::SubjectMatchRule, 4> MatchRules;
585     bool IsUsed;
586   };
587
588   /// A push'd group of PragmaAttributeEntries.
589   struct PragmaAttributeGroup {
590     /// The location of the push attribute.
591     SourceLocation Loc;
592     /// The namespace of this push group.
593     const IdentifierInfo *Namespace;
594     SmallVector<PragmaAttributeEntry, 2> Entries;
595   };
596
597   SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;
598
599   /// The declaration that is currently receiving an attribute from the
600   /// #pragma attribute stack.
601   const Decl *PragmaAttributeCurrentTargetDecl;
602
603   /// This represents the last location of a "#pragma clang optimize off"
604   /// directive if such a directive has not been closed by an "on" yet. If
605   /// optimizations are currently "on", this is set to an invalid location.
606   SourceLocation OptimizeOffPragmaLocation;
607
608   /// Flag indicating if Sema is building a recovery call expression.
609   ///
610   /// This flag is used to avoid building recovery call expressions
611   /// if Sema is already doing so, which would cause infinite recursions.
612   bool IsBuildingRecoveryCallExpr;
613
614   /// Used to control the generation of ExprWithCleanups.
615   CleanupInfo Cleanup;
616
617   /// ExprCleanupObjects - This is the stack of objects requiring
618   /// cleanup that are created by the current full expression.
619   SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;
620
621   /// Store a set of either DeclRefExprs or MemberExprs that contain a reference
622   /// to a variable (constant) that may or may not be odr-used in this Expr, and
623   /// we won't know until all lvalue-to-rvalue and discarded value conversions
624   /// have been applied to all subexpressions of the enclosing full expression.
625   /// This is cleared at the end of each full expression.
626   using MaybeODRUseExprSet = llvm::SmallPtrSet<Expr *, 2>;
627   MaybeODRUseExprSet MaybeODRUseExprs;
628
629   std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
630
631   /// Stack containing information about each of the nested
632   /// function, block, and method scopes that are currently active.
633   SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
634
635   /// The index of the first FunctionScope that corresponds to the current
636   /// context.
637   unsigned FunctionScopesStart = 0;
638
639   ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {
640     return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart,
641                               FunctionScopes.end());
642   }
643
644   /// Stack containing information needed when in C++2a an 'auto' is encountered
645   /// in a function declaration parameter type specifier in order to invent a
646   /// corresponding template parameter in the enclosing abbreviated function
647   /// template. This information is also present in LambdaScopeInfo, stored in
648   /// the FunctionScopes stack.
649   SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos;
650
651   /// The index of the first InventedParameterInfo that refers to the current
652   /// context.
653   unsigned InventedParameterInfosStart = 0;
654
655   ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
656     return llvm::makeArrayRef(InventedParameterInfos.begin() +
657                                   InventedParameterInfosStart,
658                               InventedParameterInfos.end());
659   }
660
661   typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
662                      &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
663     ExtVectorDeclsType;
664
665   /// ExtVectorDecls - This is a list all the extended vector types. This allows
666   /// us to associate a raw vector type with one of the ext_vector type names.
667   /// This is only necessary for issuing pretty diagnostics.
668   ExtVectorDeclsType ExtVectorDecls;
669
670   /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
671   std::unique_ptr<CXXFieldCollector> FieldCollector;
672
673   typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
674
675   /// Set containing all declared private fields that are not used.
676   NamedDeclSetType UnusedPrivateFields;
677
678   /// Set containing all typedefs that are likely unused.
679   llvm::SmallSetVector<const TypedefNameDecl *, 4>
680       UnusedLocalTypedefNameCandidates;
681
682   /// Delete-expressions to be analyzed at the end of translation unit
683   ///
684   /// This list contains class members, and locations of delete-expressions
685   /// that could not be proven as to whether they mismatch with new-expression
686   /// used in initializer of the field.
687   typedef std::pair<SourceLocation, bool> DeleteExprLoc;
688   typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
689   llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
690
691   typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
692
693   /// PureVirtualClassDiagSet - a set of class declarations which we have
694   /// emitted a list of pure virtual functions. Used to prevent emitting the
695   /// same list more than once.
696   std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
697
698   /// ParsingInitForAutoVars - a set of declarations with auto types for which
699   /// we are currently parsing the initializer.
700   llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
701
702   /// Look for a locally scoped extern "C" declaration by the given name.
703   NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
704
705   typedef LazyVector<VarDecl *, ExternalSemaSource,
706                      &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
707     TentativeDefinitionsType;
708
709   /// All the tentative definitions encountered in the TU.
710   TentativeDefinitionsType TentativeDefinitions;
711
712   /// All the external declarations encoutered and used in the TU.
713   SmallVector<VarDecl *, 4> ExternalDeclarations;
714
715   typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
716                      &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
717     UnusedFileScopedDeclsType;
718
719   /// The set of file scoped decls seen so far that have not been used
720   /// and must warn if not used. Only contains the first declaration.
721   UnusedFileScopedDeclsType UnusedFileScopedDecls;
722
723   typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
724                      &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
725     DelegatingCtorDeclsType;
726
727   /// All the delegating constructors seen so far in the file, used for
728   /// cycle detection at the end of the TU.
729   DelegatingCtorDeclsType DelegatingCtorDecls;
730
731   /// All the overriding functions seen during a class definition
732   /// that had their exception spec checks delayed, plus the overridden
733   /// function.
734   SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>
735     DelayedOverridingExceptionSpecChecks;
736
737   /// All the function redeclarations seen during a class definition that had
738   /// their exception spec checks delayed, plus the prior declaration they
739   /// should be checked against. Except during error recovery, the new decl
740   /// should always be a friend declaration, as that's the only valid way to
741   /// redeclare a special member before its class is complete.
742   SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2>
743     DelayedEquivalentExceptionSpecChecks;
744
745   typedef llvm::MapVector<const FunctionDecl *,
746                           std::unique_ptr<LateParsedTemplate>>
747       LateParsedTemplateMapT;
748   LateParsedTemplateMapT LateParsedTemplateMap;
749
750   /// Callback to the parser to parse templated functions when needed.
751   typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
752   typedef void LateTemplateParserCleanupCB(void *P);
753   LateTemplateParserCB *LateTemplateParser;
754   LateTemplateParserCleanupCB *LateTemplateParserCleanup;
755   void *OpaqueParser;
756
757   void SetLateTemplateParser(LateTemplateParserCB *LTP,
758                              LateTemplateParserCleanupCB *LTPCleanup,
759                              void *P) {
760     LateTemplateParser = LTP;
761     LateTemplateParserCleanup = LTPCleanup;
762     OpaqueParser = P;
763   }
764
765   class DelayedDiagnostics;
766
767   class DelayedDiagnosticsState {
768     sema::DelayedDiagnosticPool *SavedPool;
769     friend class Sema::DelayedDiagnostics;
770   };
771   typedef DelayedDiagnosticsState ParsingDeclState;
772   typedef DelayedDiagnosticsState ProcessingContextState;
773
774   /// A class which encapsulates the logic for delaying diagnostics
775   /// during parsing and other processing.
776   class DelayedDiagnostics {
777     /// The current pool of diagnostics into which delayed
778     /// diagnostics should go.
779     sema::DelayedDiagnosticPool *CurPool;
780
781   public:
782     DelayedDiagnostics() : CurPool(nullptr) {}
783
784     /// Adds a delayed diagnostic.
785     void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
786
787     /// Determines whether diagnostics should be delayed.
788     bool shouldDelayDiagnostics() { return CurPool != nullptr; }
789
790     /// Returns the current delayed-diagnostics pool.
791     sema::DelayedDiagnosticPool *getCurrentPool() const {
792       return CurPool;
793     }
794
795     /// Enter a new scope.  Access and deprecation diagnostics will be
796     /// collected in this pool.
797     DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
798       DelayedDiagnosticsState state;
799       state.SavedPool = CurPool;
800       CurPool = &pool;
801       return state;
802     }
803
804     /// Leave a delayed-diagnostic state that was previously pushed.
805     /// Do not emit any of the diagnostics.  This is performed as part
806     /// of the bookkeeping of popping a pool "properly".
807     void popWithoutEmitting(DelayedDiagnosticsState state) {
808       CurPool = state.SavedPool;
809     }
810
811     /// Enter a new scope where access and deprecation diagnostics are
812     /// not delayed.
813     DelayedDiagnosticsState pushUndelayed() {
814       DelayedDiagnosticsState state;
815       state.SavedPool = CurPool;
816       CurPool = nullptr;
817       return state;
818     }
819
820     /// Undo a previous pushUndelayed().
821     void popUndelayed(DelayedDiagnosticsState state) {
822       assert(CurPool == nullptr);
823       CurPool = state.SavedPool;
824     }
825   } DelayedDiagnostics;
826
827   /// A RAII object to temporarily push a declaration context.
828   class ContextRAII {
829   private:
830     Sema &S;
831     DeclContext *SavedContext;
832     ProcessingContextState SavedContextState;
833     QualType SavedCXXThisTypeOverride;
834     unsigned SavedFunctionScopesStart;
835     unsigned SavedInventedParameterInfosStart;
836
837   public:
838     ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
839       : S(S), SavedContext(S.CurContext),
840         SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
841         SavedCXXThisTypeOverride(S.CXXThisTypeOverride),
842         SavedFunctionScopesStart(S.FunctionScopesStart),
843         SavedInventedParameterInfosStart(S.InventedParameterInfosStart)
844     {
845       assert(ContextToPush && "pushing null context");
846       S.CurContext = ContextToPush;
847       if (NewThisContext)
848         S.CXXThisTypeOverride = QualType();
849       // Any saved FunctionScopes do not refer to this context.
850       S.FunctionScopesStart = S.FunctionScopes.size();
851       S.InventedParameterInfosStart = S.InventedParameterInfos.size();
852     }
853
854     void pop() {
855       if (!SavedContext) return;
856       S.CurContext = SavedContext;
857       S.DelayedDiagnostics.popUndelayed(SavedContextState);
858       S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
859       S.FunctionScopesStart = SavedFunctionScopesStart;
860       S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
861       SavedContext = nullptr;
862     }
863
864     ~ContextRAII() {
865       pop();
866     }
867   };
868
869   /// Whether the AST is currently being rebuilt to correct immediate
870   /// invocations. Immediate invocation candidates and references to consteval
871   /// functions aren't tracked when this is set.
872   bool RebuildingImmediateInvocation = false;
873
874   /// Used to change context to isConstantEvaluated without pushing a heavy
875   /// ExpressionEvaluationContextRecord object.
876   bool isConstantEvaluatedOverride;
877
878   bool isConstantEvaluated() {
879     return ExprEvalContexts.back().isConstantEvaluated() ||
880            isConstantEvaluatedOverride;
881   }
882
883   /// RAII object to handle the state changes required to synthesize
884   /// a function body.
885   class SynthesizedFunctionScope {
886     Sema &S;
887     Sema::ContextRAII SavedContext;
888     bool PushedCodeSynthesisContext = false;
889
890   public:
891     SynthesizedFunctionScope(Sema &S, DeclContext *DC)
892         : S(S), SavedContext(S, DC) {
893       S.PushFunctionScope();
894       S.PushExpressionEvaluationContext(
895           Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
896       if (auto *FD = dyn_cast<FunctionDecl>(DC))
897         FD->setWillHaveBody(true);
898       else
899         assert(isa<ObjCMethodDecl>(DC));
900     }
901
902     void addContextNote(SourceLocation UseLoc) {
903       assert(!PushedCodeSynthesisContext);
904
905       Sema::CodeSynthesisContext Ctx;
906       Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
907       Ctx.PointOfInstantiation = UseLoc;
908       Ctx.Entity = cast<Decl>(S.CurContext);
909       S.pushCodeSynthesisContext(Ctx);
910
911       PushedCodeSynthesisContext = true;
912     }
913
914     ~SynthesizedFunctionScope() {
915       if (PushedCodeSynthesisContext)
916         S.popCodeSynthesisContext();
917       if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
918         FD->setWillHaveBody(false);
919       S.PopExpressionEvaluationContext();
920       S.PopFunctionScopeInfo();
921     }
922   };
923
924   /// WeakUndeclaredIdentifiers - Identifiers contained in
925   /// \#pragma weak before declared. rare. may alias another
926   /// identifier, declared or undeclared
927   llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
928
929   /// ExtnameUndeclaredIdentifiers - Identifiers contained in
930   /// \#pragma redefine_extname before declared.  Used in Solaris system headers
931   /// to define functions that occur in multiple standards to call the version
932   /// in the currently selected standard.
933   llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
934
935
936   /// Load weak undeclared identifiers from the external source.
937   void LoadExternalWeakUndeclaredIdentifiers();
938
939   /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
940   /// \#pragma weak during processing of other Decls.
941   /// I couldn't figure out a clean way to generate these in-line, so
942   /// we store them here and handle separately -- which is a hack.
943   /// It would be best to refactor this.
944   SmallVector<Decl*,2> WeakTopLevelDecl;
945
946   IdentifierResolver IdResolver;
947
948   /// Translation Unit Scope - useful to Objective-C actions that need
949   /// to lookup file scope declarations in the "ordinary" C decl namespace.
950   /// For example, user-defined classes, built-in "id" type, etc.
951   Scope *TUScope;
952
953   /// The C++ "std" namespace, where the standard library resides.
954   LazyDeclPtr StdNamespace;
955
956   /// The C++ "std::bad_alloc" class, which is defined by the C++
957   /// standard library.
958   LazyDeclPtr StdBadAlloc;
959
960   /// The C++ "std::align_val_t" enum class, which is defined by the C++
961   /// standard library.
962   LazyDeclPtr StdAlignValT;
963
964   /// The C++ "std::experimental" namespace, where the experimental parts
965   /// of the standard library resides.
966   NamespaceDecl *StdExperimentalNamespaceCache;
967
968   /// The C++ "std::initializer_list" template, which is defined in
969   /// \<initializer_list>.
970   ClassTemplateDecl *StdInitializerList;
971
972   /// The C++ "std::coroutine_traits" template, which is defined in
973   /// \<coroutine_traits>
974   ClassTemplateDecl *StdCoroutineTraitsCache;
975
976   /// The C++ "type_info" declaration, which is defined in \<typeinfo>.
977   RecordDecl *CXXTypeInfoDecl;
978
979   /// The MSVC "_GUID" struct, which is defined in MSVC header files.
980   RecordDecl *MSVCGuidDecl;
981
982   /// Caches identifiers/selectors for NSFoundation APIs.
983   std::unique_ptr<NSAPI> NSAPIObj;
984
985   /// The declaration of the Objective-C NSNumber class.
986   ObjCInterfaceDecl *NSNumberDecl;
987
988   /// The declaration of the Objective-C NSValue class.
989   ObjCInterfaceDecl *NSValueDecl;
990
991   /// Pointer to NSNumber type (NSNumber *).
992   QualType NSNumberPointer;
993
994   /// Pointer to NSValue type (NSValue *).
995   QualType NSValuePointer;
996
997   /// The Objective-C NSNumber methods used to create NSNumber literals.
998   ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
999
1000   /// The declaration of the Objective-C NSString class.
1001   ObjCInterfaceDecl *NSStringDecl;
1002
1003   /// Pointer to NSString type (NSString *).
1004   QualType NSStringPointer;
1005
1006   /// The declaration of the stringWithUTF8String: method.
1007   ObjCMethodDecl *StringWithUTF8StringMethod;
1008
1009   /// The declaration of the valueWithBytes:objCType: method.
1010   ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
1011
1012   /// The declaration of the Objective-C NSArray class.
1013   ObjCInterfaceDecl *NSArrayDecl;
1014
1015   /// The declaration of the arrayWithObjects:count: method.
1016   ObjCMethodDecl *ArrayWithObjectsMethod;
1017
1018   /// The declaration of the Objective-C NSDictionary class.
1019   ObjCInterfaceDecl *NSDictionaryDecl;
1020
1021   /// The declaration of the dictionaryWithObjects:forKeys:count: method.
1022   ObjCMethodDecl *DictionaryWithObjectsMethod;
1023
1024   /// id<NSCopying> type.
1025   QualType QIDNSCopying;
1026
1027   /// will hold 'respondsToSelector:'
1028   Selector RespondsToSelectorSel;
1029
1030   /// A flag to remember whether the implicit forms of operator new and delete
1031   /// have been declared.
1032   bool GlobalNewDeleteDeclared;
1033
1034   /// A flag to indicate that we're in a context that permits abstract
1035   /// references to fields.  This is really a
1036   bool AllowAbstractFieldReference;
1037
1038   /// Describes how the expressions currently being parsed are
1039   /// evaluated at run-time, if at all.
1040   enum class ExpressionEvaluationContext {
1041     /// The current expression and its subexpressions occur within an
1042     /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
1043     /// \c sizeof, where the type of the expression may be significant but
1044     /// no code will be generated to evaluate the value of the expression at
1045     /// run time.
1046     Unevaluated,
1047
1048     /// The current expression occurs within a braced-init-list within
1049     /// an unevaluated operand. This is mostly like a regular unevaluated
1050     /// context, except that we still instantiate constexpr functions that are
1051     /// referenced here so that we can perform narrowing checks correctly.
1052     UnevaluatedList,
1053
1054     /// The current expression occurs within a discarded statement.
1055     /// This behaves largely similarly to an unevaluated operand in preventing
1056     /// definitions from being required, but not in other ways.
1057     DiscardedStatement,
1058
1059     /// The current expression occurs within an unevaluated
1060     /// operand that unconditionally permits abstract references to
1061     /// fields, such as a SIZE operator in MS-style inline assembly.
1062     UnevaluatedAbstract,
1063
1064     /// The current context is "potentially evaluated" in C++11 terms,
1065     /// but the expression is evaluated at compile-time (like the values of
1066     /// cases in a switch statement).
1067     ConstantEvaluated,
1068
1069     /// The current expression is potentially evaluated at run time,
1070     /// which means that code may be generated to evaluate the value of the
1071     /// expression at run time.
1072     PotentiallyEvaluated,
1073
1074     /// The current expression is potentially evaluated, but any
1075     /// declarations referenced inside that expression are only used if
1076     /// in fact the current expression is used.
1077     ///
1078     /// This value is used when parsing default function arguments, for which
1079     /// we would like to provide diagnostics (e.g., passing non-POD arguments
1080     /// through varargs) but do not want to mark declarations as "referenced"
1081     /// until the default argument is used.
1082     PotentiallyEvaluatedIfUsed
1083   };
1084
1085   using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;
1086
1087   /// Data structure used to record current or nested
1088   /// expression evaluation contexts.
1089   struct ExpressionEvaluationContextRecord {
1090     /// The expression evaluation context.
1091     ExpressionEvaluationContext Context;
1092
1093     /// Whether the enclosing context needed a cleanup.
1094     CleanupInfo ParentCleanup;
1095
1096     /// Whether we are in a decltype expression.
1097     bool IsDecltype;
1098
1099     /// The number of active cleanup objects when we entered
1100     /// this expression evaluation context.
1101     unsigned NumCleanupObjects;
1102
1103     /// The number of typos encountered during this expression evaluation
1104     /// context (i.e. the number of TypoExprs created).
1105     unsigned NumTypos;
1106
1107     MaybeODRUseExprSet SavedMaybeODRUseExprs;
1108
1109     /// The lambdas that are present within this context, if it
1110     /// is indeed an unevaluated context.
1111     SmallVector<LambdaExpr *, 2> Lambdas;
1112
1113     /// The declaration that provides context for lambda expressions
1114     /// and block literals if the normal declaration context does not
1115     /// suffice, e.g., in a default function argument.
1116     Decl *ManglingContextDecl;
1117
1118     /// If we are processing a decltype type, a set of call expressions
1119     /// for which we have deferred checking the completeness of the return type.
1120     SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
1121
1122     /// If we are processing a decltype type, a set of temporary binding
1123     /// expressions for which we have deferred checking the destructor.
1124     SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
1125
1126     llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
1127
1128     /// Expressions appearing as the LHS of a volatile assignment in this
1129     /// context. We produce a warning for these when popping the context if
1130     /// they are not discarded-value expressions nor unevaluated operands.
1131     SmallVector<Expr*, 2> VolatileAssignmentLHSs;
1132
1133     /// Set of candidates for starting an immediate invocation.
1134     llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates;
1135
1136     /// Set of DeclRefExprs referencing a consteval function when used in a
1137     /// context not already known to be immediately invoked.
1138     llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval;
1139
1140     /// \brief Describes whether we are in an expression constext which we have
1141     /// to handle differently.
1142     enum ExpressionKind {
1143       EK_Decltype, EK_TemplateArgument, EK_Other
1144     } ExprContext;
1145
1146     ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
1147                                       unsigned NumCleanupObjects,
1148                                       CleanupInfo ParentCleanup,
1149                                       Decl *ManglingContextDecl,
1150                                       ExpressionKind ExprContext)
1151         : Context(Context), ParentCleanup(ParentCleanup),
1152           NumCleanupObjects(NumCleanupObjects), NumTypos(0),
1153           ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {}
1154
1155     bool isUnevaluated() const {
1156       return Context == ExpressionEvaluationContext::Unevaluated ||
1157              Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
1158              Context == ExpressionEvaluationContext::UnevaluatedList;
1159     }
1160     bool isConstantEvaluated() const {
1161       return Context == ExpressionEvaluationContext::ConstantEvaluated;
1162     }
1163   };
1164
1165   /// A stack of expression evaluation contexts.
1166   SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1167
1168   /// Emit a warning for all pending noderef expressions that we recorded.
1169   void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
1170
1171   /// Compute the mangling number context for a lambda expression or
1172   /// block literal. Also return the extra mangling decl if any.
1173   ///
1174   /// \param DC - The DeclContext containing the lambda expression or
1175   /// block literal.
1176   std::tuple<MangleNumberingContext *, Decl *>
1177   getCurrentMangleNumberContext(const DeclContext *DC);
1178
1179
1180   /// SpecialMemberOverloadResult - The overloading result for a special member
1181   /// function.
1182   ///
1183   /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1184   /// integer are used to determine whether overload resolution succeeded.
1185   class SpecialMemberOverloadResult {
1186   public:
1187     enum Kind {
1188       NoMemberOrDeleted,
1189       Ambiguous,
1190       Success
1191     };
1192
1193   private:
1194     llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1195
1196   public:
1197     SpecialMemberOverloadResult() : Pair() {}
1198     SpecialMemberOverloadResult(CXXMethodDecl *MD)
1199         : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1200
1201     CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1202     void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1203
1204     Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1205     void setKind(Kind K) { Pair.setInt(K); }
1206   };
1207
1208   class SpecialMemberOverloadResultEntry
1209       : public llvm::FastFoldingSetNode,
1210         public SpecialMemberOverloadResult {
1211   public:
1212     SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1213       : FastFoldingSetNode(ID)
1214     {}
1215   };
1216
1217   /// A cache of special member function overload resolution results
1218   /// for C++ records.
1219   llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1220
1221   /// A cache of the flags available in enumerations with the flag_bits
1222   /// attribute.
1223   mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1224
1225   /// The kind of translation unit we are processing.
1226   ///
1227   /// When we're processing a complete translation unit, Sema will perform
1228   /// end-of-translation-unit semantic tasks (such as creating
1229   /// initializers for tentative definitions in C) once parsing has
1230   /// completed. Modules and precompiled headers perform different kinds of
1231   /// checks.
1232   TranslationUnitKind TUKind;
1233
1234   llvm::BumpPtrAllocator BumpAlloc;
1235
1236   /// The number of SFINAE diagnostics that have been trapped.
1237   unsigned NumSFINAEErrors;
1238
1239   typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1240     UnparsedDefaultArgInstantiationsMap;
1241
1242   /// A mapping from parameters with unparsed default arguments to the
1243   /// set of instantiations of each parameter.
1244   ///
1245   /// This mapping is a temporary data structure used when parsing
1246   /// nested class templates or nested classes of class templates,
1247   /// where we might end up instantiating an inner class before the
1248   /// default arguments of its methods have been parsed.
1249   UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1250
1251   // Contains the locations of the beginning of unparsed default
1252   // argument locations.
1253   llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1254
1255   /// UndefinedInternals - all the used, undefined objects which require a
1256   /// definition in this translation unit.
1257   llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1258
1259   /// Determine if VD, which must be a variable or function, is an external
1260   /// symbol that nonetheless can't be referenced from outside this translation
1261   /// unit because its type has no linkage and it's not extern "C".
1262   bool isExternalWithNoLinkageType(ValueDecl *VD);
1263
1264   /// Obtain a sorted list of functions that are undefined but ODR-used.
1265   void getUndefinedButUsed(
1266       SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1267
1268   /// Retrieves list of suspicious delete-expressions that will be checked at
1269   /// the end of translation unit.
1270   const llvm::MapVector<FieldDecl *, DeleteLocs> &
1271   getMismatchingDeleteExpressions() const;
1272
1273   typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1274   typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1275
1276   /// Method Pool - allows efficient lookup when typechecking messages to "id".
1277   /// We need to maintain a list, since selectors can have differing signatures
1278   /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1279   /// of selectors are "overloaded").
1280   /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1281   /// methods inside categories with a particular selector.
1282   GlobalMethodPool MethodPool;
1283
1284   /// Method selectors used in a \@selector expression. Used for implementation
1285   /// of -Wselector.
1286   llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1287
1288   /// List of SourceLocations where 'self' is implicitly retained inside a
1289   /// block.
1290   llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1>
1291       ImplicitlyRetainedSelfLocs;
1292
1293   /// Kinds of C++ special members.
1294   enum CXXSpecialMember {
1295     CXXDefaultConstructor,
1296     CXXCopyConstructor,
1297     CXXMoveConstructor,
1298     CXXCopyAssignment,
1299     CXXMoveAssignment,
1300     CXXDestructor,
1301     CXXInvalid
1302   };
1303
1304   typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1305       SpecialMemberDecl;
1306
1307   /// The C++ special members which we are currently in the process of
1308   /// declaring. If this process recursively triggers the declaration of the
1309   /// same special member, we should act as if it is not yet declared.
1310   llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1311
1312   /// Kinds of defaulted comparison operator functions.
1313   enum class DefaultedComparisonKind : unsigned char {
1314     /// This is not a defaultable comparison operator.
1315     None,
1316     /// This is an operator== that should be implemented as a series of
1317     /// subobject comparisons.
1318     Equal,
1319     /// This is an operator<=> that should be implemented as a series of
1320     /// subobject comparisons.
1321     ThreeWay,
1322     /// This is an operator!= that should be implemented as a rewrite in terms
1323     /// of a == comparison.
1324     NotEqual,
1325     /// This is an <, <=, >, or >= that should be implemented as a rewrite in
1326     /// terms of a <=> comparison.
1327     Relational,
1328   };
1329
1330   /// The function definitions which were renamed as part of typo-correction
1331   /// to match their respective declarations. We want to keep track of them
1332   /// to ensure that we don't emit a "redefinition" error if we encounter a
1333   /// correctly named definition after the renamed definition.
1334   llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1335
1336   /// Stack of types that correspond to the parameter entities that are
1337   /// currently being copy-initialized. Can be empty.
1338   llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1339
1340   void ReadMethodPool(Selector Sel);
1341   void updateOutOfDateSelector(Selector Sel);
1342
1343   /// Private Helper predicate to check for 'self'.
1344   bool isSelfExpr(Expr *RExpr);
1345   bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1346
1347   /// Cause the active diagnostic on the DiagosticsEngine to be
1348   /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1349   /// should not be used elsewhere.
1350   void EmitCurrentDiagnostic(unsigned DiagID);
1351
1352   /// Records and restores the FPFeatures state on entry/exit of compound
1353   /// statements.
1354   class FPFeaturesStateRAII {
1355   public:
1356     FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.FPFeatures) {}
1357     ~FPFeaturesStateRAII() { S.FPFeatures = OldFPFeaturesState; }
1358
1359   private:
1360     Sema& S;
1361     FPOptions OldFPFeaturesState;
1362   };
1363
1364   void addImplicitTypedef(StringRef Name, QualType T);
1365
1366   bool WarnedStackExhausted = false;
1367
1368 public:
1369   Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1370        TranslationUnitKind TUKind = TU_Complete,
1371        CodeCompleteConsumer *CompletionConsumer = nullptr);
1372   ~Sema();
1373
1374   /// Perform initialization that occurs after the parser has been
1375   /// initialized but before it parses anything.
1376   void Initialize();
1377
1378   const LangOptions &getLangOpts() const { return LangOpts; }
1379   OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1380   FPOptions     &getFPOptions() { return FPFeatures; }
1381
1382   DiagnosticsEngine &getDiagnostics() const { return Diags; }
1383   SourceManager &getSourceManager() const { return SourceMgr; }
1384   Preprocessor &getPreprocessor() const { return PP; }
1385   ASTContext &getASTContext() const { return Context; }
1386   ASTConsumer &getASTConsumer() const { return Consumer; }
1387   ASTMutationListener *getASTMutationListener() const;
1388   ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1389
1390   ///Registers an external source. If an external source already exists,
1391   /// creates a multiplex external source and appends to it.
1392   ///
1393   ///\param[in] E - A non-null external sema source.
1394   ///
1395   void addExternalSource(ExternalSemaSource *E);
1396
1397   void PrintStats() const;
1398
1399   /// Warn that the stack is nearly exhausted.
1400   void warnStackExhausted(SourceLocation Loc);
1401
1402   /// Run some code with "sufficient" stack space. (Currently, at least 256K is
1403   /// guaranteed). Produces a warning if we're low on stack space and allocates
1404   /// more in that case. Use this in code that may recurse deeply (for example,
1405   /// in template instantiation) to avoid stack overflow.
1406   void runWithSufficientStackSpace(SourceLocation Loc,
1407                                    llvm::function_ref<void()> Fn);
1408
1409   /// Helper class that creates diagnostics with optional
1410   /// template instantiation stacks.
1411   ///
1412   /// This class provides a wrapper around the basic DiagnosticBuilder
1413   /// class that emits diagnostics. SemaDiagnosticBuilder is
1414   /// responsible for emitting the diagnostic (as DiagnosticBuilder
1415   /// does) and, if the diagnostic comes from inside a template
1416   /// instantiation, printing the template instantiation stack as
1417   /// well.
1418   class SemaDiagnosticBuilder : public DiagnosticBuilder {
1419     Sema &SemaRef;
1420     unsigned DiagID;
1421
1422   public:
1423     SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1424       : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
1425
1426     // This is a cunning lie. DiagnosticBuilder actually performs move
1427     // construction in its copy constructor (but due to varied uses, it's not
1428     // possible to conveniently express this as actual move construction). So
1429     // the default copy ctor here is fine, because the base class disables the
1430     // source anyway, so the user-defined ~SemaDiagnosticBuilder is a safe no-op
1431     // in that case anwyay.
1432     SemaDiagnosticBuilder(const SemaDiagnosticBuilder&) = default;
1433
1434     ~SemaDiagnosticBuilder() {
1435       // If we aren't active, there is nothing to do.
1436       if (!isActive()) return;
1437
1438       // Otherwise, we need to emit the diagnostic. First flush the underlying
1439       // DiagnosticBuilder data, and clear the diagnostic builder itself so it
1440       // won't emit the diagnostic in its own destructor.
1441       //
1442       // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1443       // do its own needless checks to see if the diagnostic needs to be
1444       // emitted. However, because we take care to ensure that the builder
1445       // objects never escape, a sufficiently smart compiler will be able to
1446       // eliminate that code.
1447       FlushCounts();
1448       Clear();
1449
1450       // Dispatch to Sema to emit the diagnostic.
1451       SemaRef.EmitCurrentDiagnostic(DiagID);
1452     }
1453
1454     /// Teach operator<< to produce an object of the correct type.
1455     template<typename T>
1456     friend const SemaDiagnosticBuilder &operator<<(
1457         const SemaDiagnosticBuilder &Diag, const T &Value) {
1458       const DiagnosticBuilder &BaseDiag = Diag;
1459       BaseDiag << Value;
1460       return Diag;
1461     }
1462   };
1463
1464   /// Emit a diagnostic.
1465   SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
1466     DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
1467     return SemaDiagnosticBuilder(DB, *this, DiagID);
1468   }
1469
1470   /// Emit a partial diagnostic.
1471   SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic& PD);
1472
1473   /// Build a partial diagnostic.
1474   PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1475
1476   bool findMacroSpelling(SourceLocation &loc, StringRef name);
1477
1478   /// Get a string to suggest for zero-initialization of a type.
1479   std::string
1480   getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1481   std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1482
1483   /// Calls \c Lexer::getLocForEndOfToken()
1484   SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1485
1486   /// Retrieve the module loader associated with the preprocessor.
1487   ModuleLoader &getModuleLoader() const;
1488
1489   /// Invent a new identifier for parameters of abbreviated templates.
1490   IdentifierInfo *
1491   InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
1492                                              unsigned Index);
1493
1494   void emitAndClearUnusedLocalTypedefWarnings();
1495
1496   private:
1497     /// Function or variable declarations to be checked for whether the deferred
1498     /// diagnostics should be emitted.
1499     SmallVector<Decl *, 4> DeclsToCheckForDeferredDiags;
1500
1501   public:
1502   // Emit all deferred diagnostics.
1503   void emitDeferredDiags();
1504   // Emit any deferred diagnostics for FD and erase them from the map in which
1505   // they're stored.
1506   void emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack);
1507
1508   enum TUFragmentKind {
1509     /// The global module fragment, between 'module;' and a module-declaration.
1510     Global,
1511     /// A normal translation unit fragment. For a non-module unit, this is the
1512     /// entire translation unit. Otherwise, it runs from the module-declaration
1513     /// to the private-module-fragment (if any) or the end of the TU (if not).
1514     Normal,
1515     /// The private module fragment, between 'module :private;' and the end of
1516     /// the translation unit.
1517     Private
1518   };
1519
1520   void ActOnStartOfTranslationUnit();
1521   void ActOnEndOfTranslationUnit();
1522   void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind);
1523
1524   void CheckDelegatingCtorCycles();
1525
1526   Scope *getScopeForContext(DeclContext *Ctx);
1527
1528   void PushFunctionScope();
1529   void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1530   sema::LambdaScopeInfo *PushLambdaScope();
1531
1532   /// This is used to inform Sema what the current TemplateParameterDepth
1533   /// is during Parsing.  Currently it is used to pass on the depth
1534   /// when parsing generic lambda 'auto' parameters.
1535   void RecordParsingTemplateParameterDepth(unsigned Depth);
1536
1537   void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1538                                RecordDecl *RD, CapturedRegionKind K,
1539                                unsigned OpenMPCaptureLevel = 0);
1540
1541   /// Custom deleter to allow FunctionScopeInfos to be kept alive for a short
1542   /// time after they've been popped.
1543   class PoppedFunctionScopeDeleter {
1544     Sema *Self;
1545
1546   public:
1547     explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {}
1548     void operator()(sema::FunctionScopeInfo *Scope) const;
1549   };
1550
1551   using PoppedFunctionScopePtr =
1552       std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1553
1554   PoppedFunctionScopePtr
1555   PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1556                        const Decl *D = nullptr,
1557                        QualType BlockType = QualType());
1558
1559   sema::FunctionScopeInfo *getCurFunction() const {
1560     return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1561   }
1562
1563   sema::FunctionScopeInfo *getEnclosingFunction() const;
1564
1565   void setFunctionHasBranchIntoScope();
1566   void setFunctionHasBranchProtectedScope();
1567   void setFunctionHasIndirectGoto();
1568
1569   void PushCompoundScope(bool IsStmtExpr);
1570   void PopCompoundScope();
1571
1572   sema::CompoundScopeInfo &getCurCompoundScope() const;
1573
1574   bool hasAnyUnrecoverableErrorsInThisFunction() const;
1575
1576   /// Retrieve the current block, if any.
1577   sema::BlockScopeInfo *getCurBlock();
1578
1579   /// Get the innermost lambda enclosing the current location, if any. This
1580   /// looks through intervening non-lambda scopes such as local functions and
1581   /// blocks.
1582   sema::LambdaScopeInfo *getEnclosingLambda() const;
1583
1584   /// Retrieve the current lambda scope info, if any.
1585   /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1586   /// lambda scope info ignoring all inner capturing scopes that are not
1587   /// lambda scopes.
1588   sema::LambdaScopeInfo *
1589   getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1590
1591   /// Retrieve the current generic lambda info, if any.
1592   sema::LambdaScopeInfo *getCurGenericLambda();
1593
1594   /// Retrieve the current captured region, if any.
1595   sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1596
1597   /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1598   SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1599
1600   /// Called before parsing a function declarator belonging to a function
1601   /// declaration.
1602   void ActOnStartFunctionDeclarationDeclarator(Declarator &D,
1603                                                unsigned TemplateParameterDepth);
1604
1605   /// Called after parsing a function declarator belonging to a function
1606   /// declaration.
1607   void ActOnFinishFunctionDeclarationDeclarator(Declarator &D);
1608
1609   void ActOnComment(SourceRange Comment);
1610
1611   //===--------------------------------------------------------------------===//
1612   // Type Analysis / Processing: SemaType.cpp.
1613   //
1614
1615   QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1616                               const DeclSpec *DS = nullptr);
1617   QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1618                               const DeclSpec *DS = nullptr);
1619   QualType BuildPointerType(QualType T,
1620                             SourceLocation Loc, DeclarationName Entity);
1621   QualType BuildReferenceType(QualType T, bool LValueRef,
1622                               SourceLocation Loc, DeclarationName Entity);
1623   QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1624                           Expr *ArraySize, unsigned Quals,
1625                           SourceRange Brackets, DeclarationName Entity);
1626   QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1627   QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1628                               SourceLocation AttrLoc);
1629   QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1630                                  SourceLocation AttrLoc);
1631
1632   /// Same as above, but constructs the AddressSpace index if not provided.
1633   QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1634                                  SourceLocation AttrLoc);
1635
1636   bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
1637
1638   bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1639
1640   /// Build a function type.
1641   ///
1642   /// This routine checks the function type according to C++ rules and
1643   /// under the assumption that the result type and parameter types have
1644   /// just been instantiated from a template. It therefore duplicates
1645   /// some of the behavior of GetTypeForDeclarator, but in a much
1646   /// simpler form that is only suitable for this narrow use case.
1647   ///
1648   /// \param T The return type of the function.
1649   ///
1650   /// \param ParamTypes The parameter types of the function. This array
1651   /// will be modified to account for adjustments to the types of the
1652   /// function parameters.
1653   ///
1654   /// \param Loc The location of the entity whose type involves this
1655   /// function type or, if there is no such entity, the location of the
1656   /// type that will have function type.
1657   ///
1658   /// \param Entity The name of the entity that involves the function
1659   /// type, if known.
1660   ///
1661   /// \param EPI Extra information about the function type. Usually this will
1662   /// be taken from an existing function with the same prototype.
1663   ///
1664   /// \returns A suitable function type, if there are no errors. The
1665   /// unqualified type will always be a FunctionProtoType.
1666   /// Otherwise, returns a NULL type.
1667   QualType BuildFunctionType(QualType T,
1668                              MutableArrayRef<QualType> ParamTypes,
1669                              SourceLocation Loc, DeclarationName Entity,
1670                              const FunctionProtoType::ExtProtoInfo &EPI);
1671
1672   QualType BuildMemberPointerType(QualType T, QualType Class,
1673                                   SourceLocation Loc,
1674                                   DeclarationName Entity);
1675   QualType BuildBlockPointerType(QualType T,
1676                                  SourceLocation Loc, DeclarationName Entity);
1677   QualType BuildParenType(QualType T);
1678   QualType BuildAtomicType(QualType T, SourceLocation Loc);
1679   QualType BuildReadPipeType(QualType T,
1680                          SourceLocation Loc);
1681   QualType BuildWritePipeType(QualType T,
1682                          SourceLocation Loc);
1683
1684   TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
1685   TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
1686
1687   /// Package the given type and TSI into a ParsedType.
1688   ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
1689   DeclarationNameInfo GetNameForDeclarator(Declarator &D);
1690   DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
1691   static QualType GetTypeFromParser(ParsedType Ty,
1692                                     TypeSourceInfo **TInfo = nullptr);
1693   CanThrowResult canThrow(const Stmt *E);
1694   const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
1695                                                 const FunctionProtoType *FPT);
1696   void UpdateExceptionSpec(FunctionDecl *FD,
1697                            const FunctionProtoType::ExceptionSpecInfo &ESI);
1698   bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
1699   bool CheckDistantExceptionSpec(QualType T);
1700   bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
1701   bool CheckEquivalentExceptionSpec(
1702       const FunctionProtoType *Old, SourceLocation OldLoc,
1703       const FunctionProtoType *New, SourceLocation NewLoc);
1704   bool CheckEquivalentExceptionSpec(
1705       const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
1706       const FunctionProtoType *Old, SourceLocation OldLoc,
1707       const FunctionProtoType *New, SourceLocation NewLoc);
1708   bool handlerCanCatch(QualType HandlerType, QualType ExceptionType);
1709   bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
1710                                 const PartialDiagnostic &NestedDiagID,
1711                                 const PartialDiagnostic &NoteID,
1712                                 const PartialDiagnostic &NoThrowDiagID,
1713                                 const FunctionProtoType *Superset,
1714                                 SourceLocation SuperLoc,
1715                                 const FunctionProtoType *Subset,
1716                                 SourceLocation SubLoc);
1717   bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
1718                                const PartialDiagnostic &NoteID,
1719                                const FunctionProtoType *Target,
1720                                SourceLocation TargetLoc,
1721                                const FunctionProtoType *Source,
1722                                SourceLocation SourceLoc);
1723
1724   TypeResult ActOnTypeName(Scope *S, Declarator &D);
1725
1726   /// The parser has parsed the context-sensitive type 'instancetype'
1727   /// in an Objective-C message declaration. Return the appropriate type.
1728   ParsedType ActOnObjCInstanceType(SourceLocation Loc);
1729
1730   /// Abstract class used to diagnose incomplete types.
1731   struct TypeDiagnoser {
1732     TypeDiagnoser() {}
1733
1734     virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
1735     virtual ~TypeDiagnoser() {}
1736   };
1737
1738   static int getPrintable(int I) { return I; }
1739   static unsigned getPrintable(unsigned I) { return I; }
1740   static bool getPrintable(bool B) { return B; }
1741   static const char * getPrintable(const char *S) { return S; }
1742   static StringRef getPrintable(StringRef S) { return S; }
1743   static const std::string &getPrintable(const std::string &S) { return S; }
1744   static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
1745     return II;
1746   }
1747   static DeclarationName getPrintable(DeclarationName N) { return N; }
1748   static QualType getPrintable(QualType T) { return T; }
1749   static SourceRange getPrintable(SourceRange R) { return R; }
1750   static SourceRange getPrintable(SourceLocation L) { return L; }
1751   static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
1752   static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
1753
1754   template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
1755   protected:
1756     unsigned DiagID;
1757     std::tuple<const Ts &...> Args;
1758
1759     template <std::size_t... Is>
1760     void emit(const SemaDiagnosticBuilder &DB,
1761               std::index_sequence<Is...>) const {
1762       // Apply all tuple elements to the builder in order.
1763       bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
1764       (void)Dummy;
1765     }
1766
1767   public:
1768     BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
1769         : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
1770       assert(DiagID != 0 && "no diagnostic for type diagnoser");
1771     }
1772
1773     void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
1774       const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
1775       emit(DB, std::index_sequence_for<Ts...>());
1776       DB << T;
1777     }
1778   };
1779
1780   /// A derivative of BoundTypeDiagnoser for which the diagnostic's type
1781   /// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless.
1782   /// For example, a diagnostic with no other parameters would generally have
1783   /// the form "...%select{incomplete|sizeless}0 type %1...".
1784   template <typename... Ts>
1785   class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> {
1786   public:
1787     SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args)
1788         : BoundTypeDiagnoser<Ts...>(DiagID, Args...) {}
1789
1790     void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
1791       const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID);
1792       this->emit(DB, std::index_sequence_for<Ts...>());
1793       DB << T->isSizelessType() << T;
1794     }
1795   };
1796
1797   enum class CompleteTypeKind {
1798     /// Apply the normal rules for complete types.  In particular,
1799     /// treat all sizeless types as incomplete.
1800     Normal,
1801
1802     /// Relax the normal rules for complete types so that they include
1803     /// sizeless built-in types.
1804     AcceptSizeless,
1805
1806     // FIXME: Eventually we should flip the default to Normal and opt in
1807     // to AcceptSizeless rather than opt out of it.
1808     Default = AcceptSizeless
1809   };
1810
1811 private:
1812   /// Methods for marking which expressions involve dereferencing a pointer
1813   /// marked with the 'noderef' attribute. Expressions are checked bottom up as
1814   /// they are parsed, meaning that a noderef pointer may not be accessed. For
1815   /// example, in `&*p` where `p` is a noderef pointer, we will first parse the
1816   /// `*p`, but need to check that `address of` is called on it. This requires
1817   /// keeping a container of all pending expressions and checking if the address
1818   /// of them are eventually taken.
1819   void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E);
1820   void CheckAddressOfNoDeref(const Expr *E);
1821   void CheckMemberAccessOfNoDeref(const MemberExpr *E);
1822
1823   bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
1824                                CompleteTypeKind Kind, TypeDiagnoser *Diagnoser);
1825
1826   struct ModuleScope {
1827     SourceLocation BeginLoc;
1828     clang::Module *Module = nullptr;
1829     bool ModuleInterface = false;
1830     bool ImplicitGlobalModuleFragment = false;
1831     VisibleModuleSet OuterVisibleModules;
1832   };
1833   /// The modules we're currently parsing.
1834   llvm::SmallVector<ModuleScope, 16> ModuleScopes;
1835
1836   /// Namespace definitions that we will export when they finish.
1837   llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
1838
1839   /// Get the module whose scope we are currently within.
1840   Module *getCurrentModule() const {
1841     return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
1842   }
1843
1844   VisibleModuleSet VisibleModules;
1845
1846 public:
1847   /// Get the module owning an entity.
1848   Module *getOwningModule(const Decl *Entity) {
1849     return Entity->getOwningModule();
1850   }
1851
1852   /// Make a merged definition of an existing hidden definition \p ND
1853   /// visible at the specified location.
1854   void makeMergedDefinitionVisible(NamedDecl *ND);
1855
1856   bool isModuleVisible(const Module *M, bool ModulePrivate = false);
1857
1858   /// Determine whether a declaration is visible to name lookup.
1859   bool isVisible(const NamedDecl *D) {
1860     return !D->isHidden() || isVisibleSlow(D);
1861   }
1862
1863   /// Determine whether any declaration of an entity is visible.
1864   bool
1865   hasVisibleDeclaration(const NamedDecl *D,
1866                         llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
1867     return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
1868   }
1869   bool hasVisibleDeclarationSlow(const NamedDecl *D,
1870                                  llvm::SmallVectorImpl<Module *> *Modules);
1871
1872   bool hasVisibleMergedDefinition(NamedDecl *Def);
1873   bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
1874
1875   /// Determine if \p D and \p Suggested have a structurally compatible
1876   /// layout as described in C11 6.2.7/1.
1877   bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
1878
1879   /// Determine if \p D has a visible definition. If not, suggest a declaration
1880   /// that should be made visible to expose the definition.
1881   bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
1882                             bool OnlyNeedComplete = false);
1883   bool hasVisibleDefinition(const NamedDecl *D) {
1884     NamedDecl *Hidden;
1885     return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
1886   }
1887
1888   /// Determine if the template parameter \p D has a visible default argument.
1889   bool
1890   hasVisibleDefaultArgument(const NamedDecl *D,
1891                             llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1892
1893   /// Determine if there is a visible declaration of \p D that is an explicit
1894   /// specialization declaration for a specialization of a template. (For a
1895   /// member specialization, use hasVisibleMemberSpecialization.)
1896   bool hasVisibleExplicitSpecialization(
1897       const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1898
1899   /// Determine if there is a visible declaration of \p D that is a member
1900   /// specialization declaration (as opposed to an instantiated declaration).
1901   bool hasVisibleMemberSpecialization(
1902       const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1903
1904   /// Determine if \p A and \p B are equivalent internal linkage declarations
1905   /// from different modules, and thus an ambiguity error can be downgraded to
1906   /// an extension warning.
1907   bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
1908                                               const NamedDecl *B);
1909   void diagnoseEquivalentInternalLinkageDeclarations(
1910       SourceLocation Loc, const NamedDecl *D,
1911       ArrayRef<const NamedDecl *> Equiv);
1912
1913   bool isUsualDeallocationFunction(const CXXMethodDecl *FD);
1914
1915   bool isCompleteType(SourceLocation Loc, QualType T,
1916                       CompleteTypeKind Kind = CompleteTypeKind::Default) {
1917     return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr);
1918   }
1919   bool RequireCompleteType(SourceLocation Loc, QualType T,
1920                            CompleteTypeKind Kind, TypeDiagnoser &Diagnoser);
1921   bool RequireCompleteType(SourceLocation Loc, QualType T,
1922                            CompleteTypeKind Kind, unsigned DiagID);
1923
1924   bool RequireCompleteType(SourceLocation Loc, QualType T,
1925                            TypeDiagnoser &Diagnoser) {
1926     return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser);
1927   }
1928   bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) {
1929     return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID);
1930   }
1931
1932   template <typename... Ts>
1933   bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
1934                            const Ts &...Args) {
1935     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1936     return RequireCompleteType(Loc, T, Diagnoser);
1937   }
1938
1939   template <typename... Ts>
1940   bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
1941                                 const Ts &... Args) {
1942     SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1943     return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
1944   }
1945
1946   void completeExprArrayBound(Expr *E);
1947   bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
1948                                TypeDiagnoser &Diagnoser);
1949   bool RequireCompleteExprType(Expr *E, unsigned DiagID);
1950
1951   template <typename... Ts>
1952   bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
1953     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1954     return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
1955   }
1956
1957   template <typename... Ts>
1958   bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID,
1959                                     const Ts &... Args) {
1960     SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1961     return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
1962   }
1963
1964   bool RequireLiteralType(SourceLocation Loc, QualType T,
1965                           TypeDiagnoser &Diagnoser);
1966   bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
1967
1968   template <typename... Ts>
1969   bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
1970                           const Ts &...Args) {
1971     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1972     return RequireLiteralType(Loc, T, Diagnoser);
1973   }
1974
1975   QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
1976                              const CXXScopeSpec &SS, QualType T,
1977                              TagDecl *OwnedTagDecl = nullptr);
1978
1979   QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
1980   /// If AsUnevaluated is false, E is treated as though it were an evaluated
1981   /// context, such as when building a type for decltype(auto).
1982   QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
1983                              bool AsUnevaluated = true);
1984   QualType BuildUnaryTransformType(QualType BaseType,
1985                                    UnaryTransformType::UTTKind UKind,
1986                                    SourceLocation Loc);
1987
1988   //===--------------------------------------------------------------------===//
1989   // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
1990   //
1991
1992   struct SkipBodyInfo {
1993     SkipBodyInfo()
1994         : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
1995           New(nullptr) {}
1996     bool ShouldSkip;
1997     bool CheckSameAsPrevious;
1998     NamedDecl *Previous;
1999     NamedDecl *New;
2000   };
2001
2002   DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
2003
2004   void DiagnoseUseOfUnimplementedSelectors();
2005
2006   bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
2007
2008   ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
2009                          Scope *S, CXXScopeSpec *SS = nullptr,
2010                          bool isClassName = false, bool HasTrailingDot = false,
2011                          ParsedType ObjectType = nullptr,
2012                          bool IsCtorOrDtorName = false,
2013                          bool WantNontrivialTypeSourceInfo = false,
2014                          bool IsClassTemplateDeductionContext = true,
2015                          IdentifierInfo **CorrectedII = nullptr);
2016   TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
2017   bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
2018   void DiagnoseUnknownTypeName(IdentifierInfo *&II,
2019                                SourceLocation IILoc,
2020                                Scope *S,
2021                                CXXScopeSpec *SS,
2022                                ParsedType &SuggestedType,
2023                                bool IsTemplateName = false);
2024
2025   /// Attempt to behave like MSVC in situations where lookup of an unqualified
2026   /// type name has failed in a dependent context. In these situations, we
2027   /// automatically form a DependentTypeName that will retry lookup in a related
2028   /// scope during instantiation.
2029   ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
2030                                       SourceLocation NameLoc,
2031                                       bool IsTemplateTypeArg);
2032
2033   /// Describes the result of the name lookup and resolution performed
2034   /// by \c ClassifyName().
2035   enum NameClassificationKind {
2036     /// This name is not a type or template in this context, but might be
2037     /// something else.
2038     NC_Unknown,
2039     /// Classification failed; an error has been produced.
2040     NC_Error,
2041     /// The name has been typo-corrected to a keyword.
2042     NC_Keyword,
2043     /// The name was classified as a type.
2044     NC_Type,
2045     /// The name was classified as a specific non-type, non-template
2046     /// declaration. ActOnNameClassifiedAsNonType should be called to
2047     /// convert the declaration to an expression.
2048     NC_NonType,
2049     /// The name was classified as an ADL-only function name.
2050     /// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the
2051     /// result to an expression.
2052     NC_UndeclaredNonType,
2053     /// The name denotes a member of a dependent type that could not be
2054     /// resolved. ActOnNameClassifiedAsDependentNonType should be called to
2055     /// convert the result to an expression.
2056     NC_DependentNonType,
2057     /// The name was classified as a non-type, and an expression representing
2058     /// that name has been formed.
2059     NC_ContextIndependentExpr,
2060     /// The name was classified as a template whose specializations are types.
2061     NC_TypeTemplate,
2062     /// The name was classified as a variable template name.
2063     NC_VarTemplate,
2064     /// The name was classified as a function template name.
2065     NC_FunctionTemplate,
2066     /// The name was classified as an ADL-only function template name.
2067     NC_UndeclaredTemplate,
2068     /// The name was classified as a concept name.
2069     NC_Concept,
2070   };
2071
2072   class NameClassification {
2073     NameClassificationKind Kind;
2074     union {
2075       ExprResult Expr;
2076       NamedDecl *NonTypeDecl;
2077       TemplateName Template;
2078       ParsedType Type;
2079     };
2080
2081     explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
2082
2083   public:
2084     NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
2085
2086     NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
2087
2088     static NameClassification Error() {
2089       return NameClassification(NC_Error);
2090     }
2091
2092     static NameClassification Unknown() {
2093       return NameClassification(NC_Unknown);
2094     }
2095
2096     static NameClassification ContextIndependentExpr(ExprResult E) {
2097       NameClassification Result(NC_ContextIndependentExpr);
2098       Result.Expr = E;
2099       return Result;
2100     }
2101
2102     static NameClassification NonType(NamedDecl *D) {
2103       NameClassification Result(NC_NonType);
2104       Result.NonTypeDecl = D;
2105       return Result;
2106     }
2107
2108     static NameClassification UndeclaredNonType() {
2109       return NameClassification(NC_UndeclaredNonType);
2110     }
2111
2112     static NameClassification DependentNonType() {
2113       return NameClassification(NC_DependentNonType);
2114     }
2115
2116     static NameClassification TypeTemplate(TemplateName Name) {
2117       NameClassification Result(NC_TypeTemplate);
2118       Result.Template = Name;
2119       return Result;
2120     }
2121
2122     static NameClassification VarTemplate(TemplateName Name) {
2123       NameClassification Result(NC_VarTemplate);
2124       Result.Template = Name;
2125       return Result;
2126     }
2127
2128     static NameClassification FunctionTemplate(TemplateName Name) {
2129       NameClassification Result(NC_FunctionTemplate);
2130       Result.Template = Name;
2131       return Result;
2132     }
2133
2134     static NameClassification Concept(TemplateName Name) {
2135       NameClassification Result(NC_Concept);
2136       Result.Template = Name;
2137       return Result;
2138     }
2139
2140     static NameClassification UndeclaredTemplate(TemplateName Name) {
2141       NameClassification Result(NC_UndeclaredTemplate);
2142       Result.Template = Name;
2143       return Result;
2144     }
2145
2146     NameClassificationKind getKind() const { return Kind; }
2147
2148     ExprResult getExpression() const {
2149       assert(Kind == NC_ContextIndependentExpr);
2150       return Expr;
2151     }
2152
2153     ParsedType getType() const {
2154       assert(Kind == NC_Type);
2155       return Type;
2156     }
2157
2158     NamedDecl *getNonTypeDecl() const {
2159       assert(Kind == NC_NonType);
2160       return NonTypeDecl;
2161     }
2162
2163     TemplateName getTemplateName() const {
2164       assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||
2165              Kind == NC_VarTemplate || Kind == NC_Concept ||
2166              Kind == NC_UndeclaredTemplate);
2167       return Template;
2168     }
2169
2170     TemplateNameKind getTemplateNameKind() const {
2171       switch (Kind) {
2172       case NC_TypeTemplate:
2173         return TNK_Type_template;
2174       case NC_FunctionTemplate:
2175         return TNK_Function_template;
2176       case NC_VarTemplate:
2177         return TNK_Var_template;
2178       case NC_Concept:
2179         return TNK_Concept_template;
2180       case NC_UndeclaredTemplate:
2181         return TNK_Undeclared_template;
2182       default:
2183         llvm_unreachable("unsupported name classification.");
2184       }
2185     }
2186   };
2187
2188   /// Perform name lookup on the given name, classifying it based on
2189   /// the results of name lookup and the following token.
2190   ///
2191   /// This routine is used by the parser to resolve identifiers and help direct
2192   /// parsing. When the identifier cannot be found, this routine will attempt
2193   /// to correct the typo and classify based on the resulting name.
2194   ///
2195   /// \param S The scope in which we're performing name lookup.
2196   ///
2197   /// \param SS The nested-name-specifier that precedes the name.
2198   ///
2199   /// \param Name The identifier. If typo correction finds an alternative name,
2200   /// this pointer parameter will be updated accordingly.
2201   ///
2202   /// \param NameLoc The location of the identifier.
2203   ///
2204   /// \param NextToken The token following the identifier. Used to help
2205   /// disambiguate the name.
2206   ///
2207   /// \param CCC The correction callback, if typo correction is desired.
2208   NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS,
2209                                   IdentifierInfo *&Name, SourceLocation NameLoc,
2210                                   const Token &NextToken,
2211                                   CorrectionCandidateCallback *CCC = nullptr);
2212
2213   /// Act on the result of classifying a name as an undeclared (ADL-only)
2214   /// non-type declaration.
2215   ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name,
2216                                                     SourceLocation NameLoc);
2217   /// Act on the result of classifying a name as an undeclared member of a
2218   /// dependent base class.
2219   ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS,
2220                                                    IdentifierInfo *Name,
2221                                                    SourceLocation NameLoc,
2222                                                    bool IsAddressOfOperand);
2223   /// Act on the result of classifying a name as a specific non-type
2224   /// declaration.
2225   ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS,
2226                                           NamedDecl *Found,
2227                                           SourceLocation NameLoc,
2228                                           const Token &NextToken);
2229
2230   /// Describes the detailed kind of a template name. Used in diagnostics.
2231   enum class TemplateNameKindForDiagnostics {
2232     ClassTemplate,
2233     FunctionTemplate,
2234     VarTemplate,
2235     AliasTemplate,
2236     TemplateTemplateParam,
2237     Concept,
2238     DependentTemplate
2239   };
2240   TemplateNameKindForDiagnostics
2241   getTemplateNameKindForDiagnostics(TemplateName Name);
2242
2243   /// Determine whether it's plausible that E was intended to be a
2244   /// template-name.
2245   bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) {
2246     if (!getLangOpts().CPlusPlus || E.isInvalid())
2247       return false;
2248     Dependent = false;
2249     if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
2250       return !DRE->hasExplicitTemplateArgs();
2251     if (auto *ME = dyn_cast<MemberExpr>(E.get()))
2252       return !ME->hasExplicitTemplateArgs();
2253     Dependent = true;
2254     if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get()))
2255       return !DSDRE->hasExplicitTemplateArgs();
2256     if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get()))
2257       return !DSME->hasExplicitTemplateArgs();
2258     // Any additional cases recognized here should also be handled by
2259     // diagnoseExprIntendedAsTemplateName.
2260     return false;
2261   }
2262   void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
2263                                           SourceLocation Less,
2264                                           SourceLocation Greater);
2265
2266   Decl *ActOnDeclarator(Scope *S, Declarator &D);
2267
2268   NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
2269                               MultiTemplateParamsArg TemplateParameterLists);
2270   void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
2271   bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
2272   bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
2273                                     DeclarationName Name, SourceLocation Loc,
2274                                     bool IsTemplateId);
2275   void
2276   diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2277                             SourceLocation FallbackLoc,
2278                             SourceLocation ConstQualLoc = SourceLocation(),
2279                             SourceLocation VolatileQualLoc = SourceLocation(),
2280                             SourceLocation RestrictQualLoc = SourceLocation(),
2281                             SourceLocation AtomicQualLoc = SourceLocation(),
2282                             SourceLocation UnalignedQualLoc = SourceLocation());
2283
2284   static bool adjustContextForLocalExternDecl(DeclContext *&DC);
2285   void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
2286   NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
2287                                     const LookupResult &R);
2288   NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
2289   void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
2290                    const LookupResult &R);
2291   void CheckShadow(Scope *S, VarDecl *D);
2292
2293   /// Warn if 'E', which is an expression that is about to be modified, refers
2294   /// to a shadowing declaration.
2295   void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
2296
2297   void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
2298
2299 private:
2300   /// Map of current shadowing declarations to shadowed declarations. Warn if
2301   /// it looks like the user is trying to modify the shadowing declaration.
2302   llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
2303
2304 public:
2305   void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
2306   void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
2307   void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
2308                                     TypedefNameDecl *NewTD);
2309   void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
2310   NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2311                                     TypeSourceInfo *TInfo,
2312                                     LookupResult &Previous);
2313   NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
2314                                   LookupResult &Previous, bool &Redeclaration);
2315   NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
2316                                      TypeSourceInfo *TInfo,
2317                                      LookupResult &Previous,
2318                                      MultiTemplateParamsArg TemplateParamLists,
2319                                      bool &AddToScope,
2320                                      ArrayRef<BindingDecl *> Bindings = None);
2321   NamedDecl *
2322   ActOnDecompositionDeclarator(Scope *S, Declarator &D,
2323                                MultiTemplateParamsArg TemplateParamLists);
2324   // Returns true if the variable declaration is a redeclaration
2325   bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
2326   void CheckVariableDeclarationType(VarDecl *NewVD);
2327   bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
2328                                      Expr *Init);
2329   void CheckCompleteVariableDeclaration(VarDecl *VD);
2330   void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
2331   void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
2332
2333   NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2334                                      TypeSourceInfo *TInfo,
2335                                      LookupResult &Previous,
2336                                      MultiTemplateParamsArg TemplateParamLists,
2337                                      bool &AddToScope);
2338   bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
2339
2340   enum class CheckConstexprKind {
2341     /// Diagnose issues that are non-constant or that are extensions.
2342     Diagnose,
2343     /// Identify whether this function satisfies the formal rules for constexpr
2344     /// functions in the current lanugage mode (with no extensions).
2345     CheckValid
2346   };
2347
2348   bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,
2349                                         CheckConstexprKind Kind);
2350
2351   void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
2352   void FindHiddenVirtualMethods(CXXMethodDecl *MD,
2353                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2354   void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
2355                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2356   // Returns true if the function declaration is a redeclaration
2357   bool CheckFunctionDeclaration(Scope *S,
2358                                 FunctionDecl *NewFD, LookupResult &Previous,
2359                                 bool IsMemberSpecialization);
2360   bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
2361   bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD,
2362                                       QualType NewT, QualType OldT);
2363   void CheckMain(FunctionDecl *FD, const DeclSpec &D);
2364   void CheckMSVCRTEntryPoint(FunctionDecl *FD);
2365   Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,
2366                                                    bool IsDefinition);
2367   void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);
2368   Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
2369   ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
2370                                           SourceLocation Loc,
2371                                           QualType T);
2372   ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
2373                               SourceLocation NameLoc, IdentifierInfo *Name,
2374                               QualType T, TypeSourceInfo *TSInfo,
2375                               StorageClass SC);
2376   void ActOnParamDefaultArgument(Decl *param,
2377                                  SourceLocation EqualLoc,
2378                                  Expr *defarg);
2379   void ActOnParamUnparsedDefaultArgument(Decl *param,
2380                                          SourceLocation EqualLoc,
2381                                          SourceLocation ArgLoc);
2382   void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
2383   bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2384                                SourceLocation EqualLoc);
2385
2386   // Contexts where using non-trivial C union types can be disallowed. This is
2387   // passed to err_non_trivial_c_union_in_invalid_context.
2388   enum NonTrivialCUnionContext {
2389     // Function parameter.
2390     NTCUC_FunctionParam,
2391     // Function return.
2392     NTCUC_FunctionReturn,
2393     // Default-initialized object.
2394     NTCUC_DefaultInitializedObject,
2395     // Variable with automatic storage duration.
2396     NTCUC_AutoVar,
2397     // Initializer expression that might copy from another object.
2398     NTCUC_CopyInit,
2399     // Assignment.
2400     NTCUC_Assignment,
2401     // Compound literal.
2402     NTCUC_CompoundLiteral,
2403     // Block capture.
2404     NTCUC_BlockCapture,
2405     // lvalue-to-rvalue conversion of volatile type.
2406     NTCUC_LValueToRValueVolatile,
2407   };
2408
2409   /// Emit diagnostics if the initializer or any of its explicit or
2410   /// implicitly-generated subexpressions require copying or
2411   /// default-initializing a type that is or contains a C union type that is
2412   /// non-trivial to copy or default-initialize.
2413   void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
2414
2415   // These flags are passed to checkNonTrivialCUnion.
2416   enum NonTrivialCUnionKind {
2417     NTCUK_Init = 0x1,
2418     NTCUK_Destruct = 0x2,
2419     NTCUK_Copy = 0x4,
2420   };
2421
2422   /// Emit diagnostics if a non-trivial C union type or a struct that contains
2423   /// a non-trivial C union is used in an invalid context.
2424   void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,
2425                              NonTrivialCUnionContext UseContext,
2426                              unsigned NonTrivialKind);
2427
2428   void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
2429   void ActOnUninitializedDecl(Decl *dcl);
2430   void ActOnInitializerError(Decl *Dcl);
2431
2432   void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
2433   void ActOnCXXForRangeDecl(Decl *D);
2434   StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
2435                                         IdentifierInfo *Ident,
2436                                         ParsedAttributes &Attrs,
2437                                         SourceLocation AttrEnd);
2438   void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
2439   void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
2440   void CheckStaticLocalForDllExport(VarDecl *VD);
2441   void FinalizeDeclaration(Decl *D);
2442   DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
2443                                          ArrayRef<Decl *> Group);
2444   DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
2445
2446   /// Should be called on all declarations that might have attached
2447   /// documentation comments.
2448   void ActOnDocumentableDecl(Decl *D);
2449   void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
2450
2451   void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
2452                                        SourceLocation LocAfterDecls);
2453   void CheckForFunctionRedefinition(
2454       FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
2455       SkipBodyInfo *SkipBody = nullptr);
2456   Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
2457                                 MultiTemplateParamsArg TemplateParamLists,
2458                                 SkipBodyInfo *SkipBody = nullptr);
2459   Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
2460                                 SkipBodyInfo *SkipBody = nullptr);
2461   void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);
2462   ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);
2463   void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
2464   bool isObjCMethodDecl(Decl *D) {
2465     return D && isa<ObjCMethodDecl>(D);
2466   }
2467
2468   /// Determine whether we can delay parsing the body of a function or
2469   /// function template until it is used, assuming we don't care about emitting
2470   /// code for that function.
2471   ///
2472   /// This will be \c false if we may need the body of the function in the
2473   /// middle of parsing an expression (where it's impractical to switch to
2474   /// parsing a different function), for instance, if it's constexpr in C++11
2475   /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2476   bool canDelayFunctionBody(const Declarator &D);
2477
2478   /// Determine whether we can skip parsing the body of a function
2479   /// definition, assuming we don't care about analyzing its body or emitting
2480   /// code for that function.
2481   ///
2482   /// This will be \c false only if we may need the body of the function in
2483   /// order to parse the rest of the program (for instance, if it is
2484   /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2485   bool canSkipFunctionBody(Decl *D);
2486
2487   void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2488   Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2489   Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2490   Decl *ActOnSkippedFunctionBody(Decl *Decl);
2491   void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2492
2493   /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2494   /// attribute for which parsing is delayed.
2495   void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2496
2497   /// Diagnose any unused parameters in the given sequence of
2498   /// ParmVarDecl pointers.
2499   void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2500
2501   /// Diagnose whether the size of parameters or return value of a
2502   /// function or obj-c method definition is pass-by-value and larger than a
2503   /// specified threshold.
2504   void
2505   DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2506                                          QualType ReturnTy, NamedDecl *D);
2507
2508   void DiagnoseInvalidJumps(Stmt *Body);
2509   Decl *ActOnFileScopeAsmDecl(Expr *expr,
2510                               SourceLocation AsmLoc,
2511                               SourceLocation RParenLoc);
2512
2513   /// Handle a C++11 empty-declaration and attribute-declaration.
2514   Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,
2515                               SourceLocation SemiLoc);
2516
2517   enum class ModuleDeclKind {
2518     Interface,      ///< 'export module X;'
2519     Implementation, ///< 'module X;'
2520   };
2521
2522   /// The parser has processed a module-declaration that begins the definition
2523   /// of a module interface or implementation.
2524   DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2525                                  SourceLocation ModuleLoc, ModuleDeclKind MDK,
2526                                  ModuleIdPath Path, bool IsFirstDecl);
2527
2528   /// The parser has processed a global-module-fragment declaration that begins
2529   /// the definition of the global module fragment of the current module unit.
2530   /// \param ModuleLoc The location of the 'module' keyword.
2531   DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);
2532
2533   /// The parser has processed a private-module-fragment declaration that begins
2534   /// the definition of the private module fragment of the current module unit.
2535   /// \param ModuleLoc The location of the 'module' keyword.
2536   /// \param PrivateLoc The location of the 'private' keyword.
2537   DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
2538                                                 SourceLocation PrivateLoc);
2539
2540   /// The parser has processed a module import declaration.
2541   ///
2542   /// \param StartLoc The location of the first token in the declaration. This
2543   ///        could be the location of an '@', 'export', or 'import'.
2544   /// \param ExportLoc The location of the 'export' keyword, if any.
2545   /// \param ImportLoc The location of the 'import' keyword.
2546   /// \param Path The module access path.
2547   DeclResult ActOnModuleImport(SourceLocation StartLoc,
2548                                SourceLocation ExportLoc,
2549                                SourceLocation ImportLoc, ModuleIdPath Path);
2550   DeclResult ActOnModuleImport(SourceLocation StartLoc,
2551                                SourceLocation ExportLoc,
2552                                SourceLocation ImportLoc, Module *M,
2553                                ModuleIdPath Path = {});
2554
2555   /// The parser has processed a module import translated from a
2556   /// #include or similar preprocessing directive.
2557   void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2558   void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2559
2560   /// The parsed has entered a submodule.
2561   void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2562   /// The parser has left a submodule.
2563   void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2564
2565   /// Create an implicit import of the given module at the given
2566   /// source location, for error recovery, if possible.
2567   ///
2568   /// This routine is typically used when an entity found by name lookup
2569   /// is actually hidden within a module that we know about but the user
2570   /// has forgotten to import.
2571   void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2572                                                   Module *Mod);
2573
2574   /// Kinds of missing import. Note, the values of these enumerators correspond
2575   /// to %select values in diagnostics.
2576   enum class MissingImportKind {
2577     Declaration,
2578     Definition,
2579     DefaultArgument,
2580     ExplicitSpecialization,
2581     PartialSpecialization
2582   };
2583
2584   /// Diagnose that the specified declaration needs to be visible but
2585   /// isn't, and suggest a module import that would resolve the problem.
2586   void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2587                              MissingImportKind MIK, bool Recover = true);
2588   void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2589                              SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2590                              MissingImportKind MIK, bool Recover);
2591
2592   Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2593                              SourceLocation LBraceLoc);
2594   Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2595                               SourceLocation RBraceLoc);
2596
2597   /// We've found a use of a templated declaration that would trigger an
2598   /// implicit instantiation. Check that any relevant explicit specializations
2599   /// and partial specializations are visible, and diagnose if not.
2600   void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2601
2602   /// We've found a use of a template specialization that would select a
2603   /// partial specialization. Check that the partial specialization is visible,
2604   /// and diagnose if not.
2605   void checkPartialSpecializationVisibility(SourceLocation Loc,
2606                                             NamedDecl *Spec);
2607
2608   /// Retrieve a suitable printing policy for diagnostics.
2609   PrintingPolicy getPrintingPolicy() const {
2610     return getPrintingPolicy(Context, PP);
2611   }
2612
2613   /// Retrieve a suitable printing policy for diagnostics.
2614   static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2615                                           const Preprocessor &PP);
2616
2617   /// Scope actions.
2618   void ActOnPopScope(SourceLocation Loc, Scope *S);
2619   void ActOnTranslationUnitScope(Scope *S);
2620
2621   Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2622                                    RecordDecl *&AnonRecord);
2623   Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2624                                    MultiTemplateParamsArg TemplateParams,
2625                                    bool IsExplicitInstantiation,
2626                                    RecordDecl *&AnonRecord);
2627
2628   Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2629                                     AccessSpecifier AS,
2630                                     RecordDecl *Record,
2631                                     const PrintingPolicy &Policy);
2632
2633   Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
2634                                        RecordDecl *Record);
2635
2636   /// Common ways to introduce type names without a tag for use in diagnostics.
2637   /// Keep in sync with err_tag_reference_non_tag.
2638   enum NonTagKind {
2639     NTK_NonStruct,
2640     NTK_NonClass,
2641     NTK_NonUnion,
2642     NTK_NonEnum,
2643     NTK_Typedef,
2644     NTK_TypeAlias,
2645     NTK_Template,
2646     NTK_TypeAliasTemplate,
2647     NTK_TemplateTemplateArgument,
2648   };
2649
2650   /// Given a non-tag type declaration, returns an enum useful for indicating
2651   /// what kind of non-tag type this is.
2652   NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
2653
2654   bool isAcceptableTagRedeclaration(const TagDecl *Previous,
2655                                     TagTypeKind NewTag, bool isDefinition,
2656                                     SourceLocation NewTagLoc,
2657                                     const IdentifierInfo *Name);
2658
2659   enum TagUseKind {
2660     TUK_Reference,   // Reference to a tag:  'struct foo *X;'
2661     TUK_Declaration, // Fwd decl of a tag:   'struct foo;'
2662     TUK_Definition,  // Definition of a tag: 'struct foo { int X; } Y;'
2663     TUK_Friend       // Friend declaration:  'friend struct foo;'
2664   };
2665
2666   Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
2667                  SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
2668                  SourceLocation NameLoc, const ParsedAttributesView &Attr,
2669                  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
2670                  MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
2671                  bool &IsDependent, SourceLocation ScopedEnumKWLoc,
2672                  bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
2673                  bool IsTypeSpecifier, bool IsTemplateParamOrArg,
2674                  SkipBodyInfo *SkipBody = nullptr);
2675
2676   Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
2677                                 unsigned TagSpec, SourceLocation TagLoc,
2678                                 CXXScopeSpec &SS, IdentifierInfo *Name,
2679                                 SourceLocation NameLoc,
2680                                 const ParsedAttributesView &Attr,
2681                                 MultiTemplateParamsArg TempParamLists);
2682
2683   TypeResult ActOnDependentTag(Scope *S,
2684                                unsigned TagSpec,
2685                                TagUseKind TUK,
2686                                const CXXScopeSpec &SS,
2687                                IdentifierInfo *Name,
2688                                SourceLocation TagLoc,
2689                                SourceLocation NameLoc);
2690
2691   void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
2692                  IdentifierInfo *ClassName,
2693                  SmallVectorImpl<Decl *> &Decls);
2694   Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
2695                    Declarator &D, Expr *BitfieldWidth);
2696
2697   FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
2698                          Declarator &D, Expr *BitfieldWidth,
2699                          InClassInitStyle InitStyle,
2700                          AccessSpecifier AS);
2701   MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,
2702                                    SourceLocation DeclStart, Declarator &D,
2703                                    Expr *BitfieldWidth,
2704                                    InClassInitStyle InitStyle,
2705                                    AccessSpecifier AS,
2706                                    const ParsedAttr &MSPropertyAttr);
2707
2708   FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
2709                             TypeSourceInfo *TInfo,
2710                             RecordDecl *Record, SourceLocation Loc,
2711                             bool Mutable, Expr *BitfieldWidth,
2712                             InClassInitStyle InitStyle,
2713                             SourceLocation TSSL,
2714                             AccessSpecifier AS, NamedDecl *PrevDecl,
2715                             Declarator *D = nullptr);
2716
2717   bool CheckNontrivialField(FieldDecl *FD);
2718   void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
2719
2720   enum TrivialABIHandling {
2721     /// The triviality of a method unaffected by "trivial_abi".
2722     TAH_IgnoreTrivialABI,
2723
2724     /// The triviality of a method affected by "trivial_abi".
2725     TAH_ConsiderTrivialABI
2726   };
2727
2728   bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
2729                               TrivialABIHandling TAH = TAH_IgnoreTrivialABI,
2730                               bool Diagnose = false);
2731
2732   /// For a defaulted function, the kind of defaulted function that it is.
2733   class DefaultedFunctionKind {
2734     CXXSpecialMember SpecialMember : 8;
2735     DefaultedComparisonKind Comparison : 8;
2736
2737   public:
2738     DefaultedFunctionKind()
2739         : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {
2740     }
2741     DefaultedFunctionKind(CXXSpecialMember CSM)
2742         : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}
2743     DefaultedFunctionKind(DefaultedComparisonKind Comp)
2744         : SpecialMember(CXXInvalid), Comparison(Comp) {}
2745
2746     bool isSpecialMember() const { return SpecialMember != CXXInvalid; }
2747     bool isComparison() const {
2748       return Comparison != DefaultedComparisonKind::None;
2749     }
2750
2751     explicit operator bool() const {
2752       return isSpecialMember() || isComparison();
2753     }
2754
2755     CXXSpecialMember asSpecialMember() const { return SpecialMember; }
2756     DefaultedComparisonKind asComparison() const { return Comparison; }
2757
2758     /// Get the index of this function kind for use in diagnostics.
2759     unsigned getDiagnosticIndex() const {
2760       static_assert(CXXInvalid > CXXDestructor,
2761                     "invalid should have highest index");
2762       static_assert((unsigned)DefaultedComparisonKind::None == 0,
2763                     "none should be equal to zero");
2764       return SpecialMember + (unsigned)Comparison;
2765     }
2766   };
2767
2768   DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);
2769
2770   CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {
2771     return getDefaultedFunctionKind(MD).asSpecialMember();
2772   }
2773   DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {
2774     return getDefaultedFunctionKind(FD).asComparison();
2775   }
2776
2777   void ActOnLastBitfield(SourceLocation DeclStart,
2778                          SmallVectorImpl<Decl *> &AllIvarDecls);
2779   Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
2780                   Declarator &D, Expr *BitfieldWidth,
2781                   tok::ObjCKeywordKind visibility);
2782
2783   // This is used for both record definitions and ObjC interface declarations.
2784   void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl,
2785                    ArrayRef<Decl *> Fields, SourceLocation LBrac,
2786                    SourceLocation RBrac, const ParsedAttributesView &AttrList);
2787
2788   /// ActOnTagStartDefinition - Invoked when we have entered the
2789   /// scope of a tag's definition (e.g., for an enumeration, class,
2790   /// struct, or union).
2791   void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
2792
2793   /// Perform ODR-like check for C/ObjC when merging tag types from modules.
2794   /// Differently from C++, actually parse the body and reject / error out
2795   /// in case of a structural mismatch.
2796   bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
2797                                 SkipBodyInfo &SkipBody);
2798
2799   typedef void *SkippedDefinitionContext;
2800
2801   /// Invoked when we enter a tag definition that we're skipping.
2802   SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);
2803
2804   Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
2805
2806   /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
2807   /// C++ record definition's base-specifiers clause and are starting its
2808   /// member declarations.
2809   void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
2810                                        SourceLocation FinalLoc,
2811                                        bool IsFinalSpelledSealed,
2812                                        SourceLocation LBraceLoc);
2813
2814   /// ActOnTagFinishDefinition - Invoked once we have finished parsing
2815   /// the definition of a tag (enumeration, class, struct, or union).
2816   void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
2817                                 SourceRange BraceRange);
2818
2819   void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
2820
2821   void ActOnObjCContainerFinishDefinition();
2822
2823   /// Invoked when we must temporarily exit the objective-c container
2824   /// scope for parsing/looking-up C constructs.
2825   ///
2826   /// Must be followed by a call to \see ActOnObjCReenterContainerContext
2827   void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
2828   void ActOnObjCReenterContainerContext(DeclContext *DC);
2829
2830   /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
2831   /// error parsing the definition of a tag.
2832   void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
2833
2834   EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
2835                                       EnumConstantDecl *LastEnumConst,
2836                                       SourceLocation IdLoc,
2837                                       IdentifierInfo *Id,
2838                                       Expr *val);
2839   bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
2840   bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
2841                               QualType EnumUnderlyingTy, bool IsFixed,
2842                               const EnumDecl *Prev);
2843
2844   /// Determine whether the body of an anonymous enumeration should be skipped.
2845   /// \param II The name of the first enumerator.
2846   SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
2847                                       SourceLocation IILoc);
2848
2849   Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
2850                           SourceLocation IdLoc, IdentifierInfo *Id,
2851                           const ParsedAttributesView &Attrs,
2852                           SourceLocation EqualLoc, Expr *Val);
2853   void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
2854                      Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S,
2855                      const ParsedAttributesView &Attr);
2856
2857   DeclContext *getContainingDC(DeclContext *DC);
2858
2859   /// Set the current declaration context until it gets popped.
2860   void PushDeclContext(Scope *S, DeclContext *DC);
2861   void PopDeclContext();
2862
2863   /// EnterDeclaratorContext - Used when we must lookup names in the context
2864   /// of a declarator's nested name specifier.
2865   void EnterDeclaratorContext(Scope *S, DeclContext *DC);
2866   void ExitDeclaratorContext(Scope *S);
2867
2868   /// Push the parameters of D, which must be a function, into scope.
2869   void ActOnReenterFunctionContext(Scope* S, Decl* D);
2870   void ActOnExitFunctionContext();
2871
2872   DeclContext *getFunctionLevelDeclContext();
2873
2874   /// getCurFunctionDecl - If inside of a function body, this returns a pointer
2875   /// to the function decl for the function being parsed.  If we're currently
2876   /// in a 'block', this returns the containing context.
2877   FunctionDecl *getCurFunctionDecl();
2878
2879   /// getCurMethodDecl - If inside of a method body, this returns a pointer to
2880   /// the method decl for the method being parsed.  If we're currently
2881   /// in a 'block', this returns the containing context.
2882   ObjCMethodDecl *getCurMethodDecl();
2883
2884   /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
2885   /// or C function we're in, otherwise return null.  If we're currently
2886   /// in a 'block', this returns the containing context.
2887   NamedDecl *getCurFunctionOrMethodDecl();
2888
2889   /// Add this decl to the scope shadowed decl chains.
2890   void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
2891
2892   /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
2893   /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
2894   /// true if 'D' belongs to the given declaration context.
2895   ///
2896   /// \param AllowInlineNamespace If \c true, allow the declaration to be in the
2897   ///        enclosing namespace set of the context, rather than contained
2898   ///        directly within it.
2899   bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,
2900                      bool AllowInlineNamespace = false);
2901
2902   /// Finds the scope corresponding to the given decl context, if it
2903   /// happens to be an enclosing scope.  Otherwise return NULL.
2904   static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
2905
2906   /// Subroutines of ActOnDeclarator().
2907   TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
2908                                 TypeSourceInfo *TInfo);
2909   bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
2910
2911   /// Describes the kind of merge to perform for availability
2912   /// attributes (including "deprecated", "unavailable", and "availability").
2913   enum AvailabilityMergeKind {
2914     /// Don't merge availability attributes at all.
2915     AMK_None,
2916     /// Merge availability attributes for a redeclaration, which requires
2917     /// an exact match.
2918     AMK_Redeclaration,
2919     /// Merge availability attributes for an override, which requires
2920     /// an exact match or a weakening of constraints.
2921     AMK_Override,
2922     /// Merge availability attributes for an implementation of
2923     /// a protocol requirement.
2924     AMK_ProtocolImplementation,
2925   };
2926
2927   /// Describes the kind of priority given to an availability attribute.
2928   ///
2929   /// The sum of priorities deteremines the final priority of the attribute.
2930   /// The final priority determines how the attribute will be merged.
2931   /// An attribute with a lower priority will always remove higher priority
2932   /// attributes for the specified platform when it is being applied. An
2933   /// attribute with a higher priority will not be applied if the declaration
2934   /// already has an availability attribute with a lower priority for the
2935   /// specified platform. The final prirority values are not expected to match
2936   /// the values in this enumeration, but instead should be treated as a plain
2937   /// integer value. This enumeration just names the priority weights that are
2938   /// used to calculate that final vaue.
2939   enum AvailabilityPriority : int {
2940     /// The availability attribute was specified explicitly next to the
2941     /// declaration.
2942     AP_Explicit = 0,
2943
2944     /// The availability attribute was applied using '#pragma clang attribute'.
2945     AP_PragmaClangAttribute = 1,
2946
2947     /// The availability attribute for a specific platform was inferred from
2948     /// an availability attribute for another platform.
2949     AP_InferredFromOtherPlatform = 2
2950   };
2951
2952   /// Attribute merging methods. Return true if a new attribute was added.
2953   AvailabilityAttr *
2954   mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI,
2955                         IdentifierInfo *Platform, bool Implicit,
2956                         VersionTuple Introduced, VersionTuple Deprecated,
2957                         VersionTuple Obsoleted, bool IsUnavailable,
2958                         StringRef Message, bool IsStrict, StringRef Replacement,
2959                         AvailabilityMergeKind AMK, int Priority);
2960   TypeVisibilityAttr *
2961   mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
2962                           TypeVisibilityAttr::VisibilityType Vis);
2963   VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
2964                                       VisibilityAttr::VisibilityType Vis);
2965   UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,
2966                           StringRef Uuid);
2967   DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI);
2968   DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI);
2969   MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D,
2970                                             const AttributeCommonInfo &CI,
2971                                             bool BestCase,
2972                                             MSInheritanceModel Model);
2973   FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,
2974                               IdentifierInfo *Format, int FormatIdx,
2975                               int FirstArg);
2976   SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,
2977                                 StringRef Name);
2978   CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,
2979                                 StringRef Name);
2980   AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D,
2981                                           const AttributeCommonInfo &CI,
2982                                           const IdentifierInfo *Ident);
2983   MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI);
2984   NoSpeculativeLoadHardeningAttr *
2985   mergeNoSpeculativeLoadHardeningAttr(Decl *D,
2986                                       const NoSpeculativeLoadHardeningAttr &AL);
2987   SpeculativeLoadHardeningAttr *
2988   mergeSpeculativeLoadHardeningAttr(Decl *D,
2989                                     const SpeculativeLoadHardeningAttr &AL);
2990   OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D,
2991                                           const AttributeCommonInfo &CI);
2992   InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL);
2993   InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D,
2994                                                 const InternalLinkageAttr &AL);
2995   CommonAttr *mergeCommonAttr(Decl *D, const ParsedAttr &AL);
2996   CommonAttr *mergeCommonAttr(Decl *D, const CommonAttr &AL);
2997
2998   void mergeDeclAttributes(NamedDecl *New, Decl *Old,
2999                            AvailabilityMergeKind AMK = AMK_Redeclaration);
3000   void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
3001                             LookupResult &OldDecls);
3002   bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,
3003                          bool MergeTypeWithOld);
3004   bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
3005                                     Scope *S, bool MergeTypeWithOld);
3006   void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
3007   void MergeVarDecl(VarDecl *New, LookupResult &Previous);
3008   void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);
3009   void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
3010   bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);
3011   void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
3012   bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
3013
3014   // AssignmentAction - This is used by all the assignment diagnostic functions
3015   // to represent what is actually causing the operation
3016   enum AssignmentAction {
3017     AA_Assigning,
3018     AA_Passing,
3019     AA_Returning,
3020     AA_Converting,
3021     AA_Initializing,
3022     AA_Sending,
3023     AA_Casting,
3024     AA_Passing_CFAudited
3025   };
3026
3027   /// C++ Overloading.
3028   enum OverloadKind {
3029     /// This is a legitimate overload: the existing declarations are
3030     /// functions or function templates with different signatures.
3031     Ovl_Overload,
3032
3033     /// This is not an overload because the signature exactly matches
3034     /// an existing declaration.
3035     Ovl_Match,
3036
3037     /// This is not an overload because the lookup results contain a
3038     /// non-function.
3039     Ovl_NonFunction
3040   };
3041   OverloadKind CheckOverload(Scope *S,
3042                              FunctionDecl *New,
3043                              const LookupResult &OldDecls,
3044                              NamedDecl *&OldDecl,
3045                              bool IsForUsingDecl);
3046   bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
3047                   bool ConsiderCudaAttrs = true,
3048                   bool ConsiderRequiresClauses = true);
3049
3050   enum class AllowedExplicit {
3051     /// Allow no explicit functions to be used.
3052     None,
3053     /// Allow explicit conversion functions but not explicit constructors.
3054     Conversions,
3055     /// Allow both explicit conversion functions and explicit constructors.
3056     All
3057   };
3058
3059   ImplicitConversionSequence
3060   TryImplicitConversion(Expr *From, QualType ToType,
3061                         bool SuppressUserConversions,
3062                         AllowedExplicit AllowExplicit,
3063                         bool InOverloadResolution,
3064                         bool CStyle,
3065                         bool AllowObjCWritebackConversion);
3066
3067   bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
3068   bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
3069   bool IsComplexPromotion(QualType FromType, QualType ToType);
3070   bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
3071                            bool InOverloadResolution,
3072                            QualType& ConvertedType, bool &IncompatibleObjC);
3073   bool isObjCPointerConversion(QualType FromType, QualType ToType,
3074                                QualType& ConvertedType, bool &IncompatibleObjC);
3075   bool isObjCWritebackConversion(QualType FromType, QualType ToType,
3076                                  QualType &ConvertedType);
3077   bool IsBlockPointerConversion(QualType FromType, QualType ToType,
3078                                 QualType& ConvertedType);
3079   bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
3080                                   const FunctionProtoType *NewType,
3081                                   unsigned *ArgPos = nullptr);
3082   void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
3083                                   QualType FromType, QualType ToType);
3084
3085   void maybeExtendBlockObject(ExprResult &E);
3086   CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
3087   bool CheckPointerConversion(Expr *From, QualType ToType,
3088                               CastKind &Kind,
3089                               CXXCastPath& BasePath,
3090                               bool IgnoreBaseAccess,
3091                               bool Diagnose = true);
3092   bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
3093                                  bool InOverloadResolution,
3094                                  QualType &ConvertedType);
3095   bool CheckMemberPointerConversion(Expr *From, QualType ToType,
3096                                     CastKind &Kind,
3097                                     CXXCastPath &BasePath,
3098                                     bool IgnoreBaseAccess);
3099   bool IsQualificationConversion(QualType FromType, QualType ToType,
3100                                  bool CStyle, bool &ObjCLifetimeConversion);
3101   bool IsFunctionConversion(QualType FromType, QualType ToType,
3102                             QualType &ResultTy);
3103   bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
3104   bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
3105
3106   ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
3107                                              const VarDecl *NRVOCandidate,
3108                                              QualType ResultType,
3109                                              Expr *Value,
3110                                              bool AllowNRVO = true);
3111
3112   bool CanPerformAggregateInitializationForOverloadResolution(
3113       const InitializedEntity &Entity, InitListExpr *From);
3114
3115   bool CanPerformCopyInitialization(const InitializedEntity &Entity,
3116                                     ExprResult Init);
3117   ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
3118                                        SourceLocation EqualLoc,
3119                                        ExprResult Init,
3120                                        bool TopLevelOfInitList = false,
3121                                        bool AllowExplicit = false);
3122   ExprResult PerformObjectArgumentInitialization(Expr *From,
3123                                                  NestedNameSpecifier *Qualifier,
3124                                                  NamedDecl *FoundDecl,
3125                                                  CXXMethodDecl *Method);
3126
3127   /// Check that the lifetime of the initializer (and its subobjects) is
3128   /// sufficient for initializing the entity, and perform lifetime extension
3129   /// (when permitted) if not.
3130   void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
3131
3132   ExprResult PerformContextuallyConvertToBool(Expr *From);
3133   ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
3134
3135   /// Contexts in which a converted constant expression is required.
3136   enum CCEKind {
3137     CCEK_CaseValue,   ///< Expression in a case label.
3138     CCEK_Enumerator,  ///< Enumerator value with fixed underlying type.
3139     CCEK_TemplateArg, ///< Value of a non-type template parameter.
3140     CCEK_NewExpr,     ///< Constant expression in a noptr-new-declarator.
3141     CCEK_ConstexprIf, ///< Condition in a constexpr if statement.
3142     CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
3143   };
3144   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3145                                               llvm::APSInt &Value, CCEKind CCE);
3146   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3147                                               APValue &Value, CCEKind CCE);
3148
3149   /// Abstract base class used to perform a contextual implicit
3150   /// conversion from an expression to any type passing a filter.
3151   class ContextualImplicitConverter {
3152   public:
3153     bool Suppress;
3154     bool SuppressConversion;
3155
3156     ContextualImplicitConverter(bool Suppress = false,
3157                                 bool SuppressConversion = false)
3158         : Suppress(Suppress), SuppressConversion(SuppressConversion) {}
3159
3160     /// Determine whether the specified type is a valid destination type
3161     /// for this conversion.
3162     virtual bool match(QualType T) = 0;
3163
3164     /// Emits a diagnostic complaining that the expression does not have
3165     /// integral or enumeration type.
3166     virtual SemaDiagnosticBuilder
3167     diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;
3168
3169     /// Emits a diagnostic when the expression has incomplete class type.
3170     virtual SemaDiagnosticBuilder
3171     diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;
3172
3173     /// Emits a diagnostic when the only matching conversion function
3174     /// is explicit.
3175     virtual SemaDiagnosticBuilder diagnoseExplicitConv(
3176         Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3177
3178     /// Emits a note for the explicit conversion function.
3179     virtual SemaDiagnosticBuilder
3180     noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3181
3182     /// Emits a diagnostic when there are multiple possible conversion
3183     /// functions.
3184     virtual SemaDiagnosticBuilder
3185     diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;
3186
3187     /// Emits a note for one of the candidate conversions.
3188     virtual SemaDiagnosticBuilder
3189     noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3190
3191     /// Emits a diagnostic when we picked a conversion function
3192     /// (for cases when we are not allowed to pick a conversion function).
3193     virtual SemaDiagnosticBuilder diagnoseConversion(
3194         Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3195
3196     virtual ~ContextualImplicitConverter() {}
3197   };
3198
3199   class ICEConvertDiagnoser : public ContextualImplicitConverter {
3200     bool AllowScopedEnumerations;
3201
3202   public:
3203     ICEConvertDiagnoser(bool AllowScopedEnumerations,
3204                         bool Suppress, bool SuppressConversion)
3205         : ContextualImplicitConverter(Suppress, SuppressConversion),
3206           AllowScopedEnumerations(AllowScopedEnumerations) {}
3207
3208     /// Match an integral or (possibly scoped) enumeration type.
3209     bool match(QualType T) override;
3210
3211     SemaDiagnosticBuilder
3212     diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {
3213       return diagnoseNotInt(S, Loc, T);
3214     }
3215
3216     /// Emits a diagnostic complaining that the expression does not have
3217     /// integral or enumeration type.
3218     virtual SemaDiagnosticBuilder
3219     diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;
3220   };
3221
3222   /// Perform a contextual implicit conversion.
3223   ExprResult PerformContextualImplicitConversion(
3224       SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
3225
3226
3227   enum ObjCSubscriptKind {
3228     OS_Array,
3229     OS_Dictionary,
3230     OS_Error
3231   };
3232   ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
3233
3234   // Note that LK_String is intentionally after the other literals, as
3235   // this is used for diagnostics logic.
3236   enum ObjCLiteralKind {
3237     LK_Array,
3238     LK_Dictionary,
3239     LK_Numeric,
3240     LK_Boxed,
3241     LK_String,
3242     LK_Block,
3243     LK_None
3244   };
3245   ObjCLiteralKind CheckLiteralKind(Expr *FromE);
3246
3247   ExprResult PerformObjectMemberConversion(Expr *From,
3248                                            NestedNameSpecifier *Qualifier,
3249                                            NamedDecl *FoundDecl,
3250                                            NamedDecl *Member);
3251
3252   // Members have to be NamespaceDecl* or TranslationUnitDecl*.
3253   // TODO: make this is a typesafe union.
3254   typedef llvm::SmallSetVector<DeclContext   *, 16> AssociatedNamespaceSet;
3255   typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;
3256
3257   using ADLCallKind = CallExpr::ADLCallKind;
3258
3259   void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
3260                             ArrayRef<Expr *> Args,
3261                             OverloadCandidateSet &CandidateSet,
3262                             bool SuppressUserConversions = false,
3263                             bool PartialOverloading = false,
3264                             bool AllowExplicit = true,
3265                             bool AllowExplicitConversion = false,
3266                             ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3267                             ConversionSequenceList EarlyConversions = None,
3268                             OverloadCandidateParamOrder PO = {});
3269   void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
3270                       ArrayRef<Expr *> Args,
3271                       OverloadCandidateSet &CandidateSet,
3272                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
3273                       bool SuppressUserConversions = false,
3274                       bool PartialOverloading = false,
3275                       bool FirstArgumentIsBase = false);
3276   void AddMethodCandidate(DeclAccessPair FoundDecl,
3277                           QualType ObjectType,
3278                           Expr::Classification ObjectClassification,
3279                           ArrayRef<Expr *> Args,
3280                           OverloadCandidateSet& CandidateSet,
3281                           bool SuppressUserConversion = false,
3282                           OverloadCandidateParamOrder PO = {});
3283   void AddMethodCandidate(CXXMethodDecl *Method,
3284                           DeclAccessPair FoundDecl,
3285                           CXXRecordDecl *ActingContext, QualType ObjectType,
3286                           Expr::Classification ObjectClassification,
3287                           ArrayRef<Expr *> Args,
3288                           OverloadCandidateSet& CandidateSet,
3289                           bool SuppressUserConversions = false,
3290                           bool PartialOverloading = false,
3291                           ConversionSequenceList EarlyConversions = None,
3292                           OverloadCandidateParamOrder PO = {});
3293   void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
3294                                   DeclAccessPair FoundDecl,
3295                                   CXXRecordDecl *ActingContext,
3296                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
3297                                   QualType ObjectType,
3298                                   Expr::Classification ObjectClassification,
3299                                   ArrayRef<Expr *> Args,
3300                                   OverloadCandidateSet& CandidateSet,
3301                                   bool SuppressUserConversions = false,
3302                                   bool PartialOverloading = false,
3303                                   OverloadCandidateParamOrder PO = {});
3304   void AddTemplateOverloadCandidate(
3305       FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3306       TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3307       OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
3308       bool PartialOverloading = false, bool AllowExplicit = true,
3309       ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3310       OverloadCandidateParamOrder PO = {});
3311   bool CheckNonDependentConversions(
3312       FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
3313       ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3314       ConversionSequenceList &Conversions, bool SuppressUserConversions,
3315       CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),
3316       Expr::Classification ObjectClassification = {},
3317       OverloadCandidateParamOrder PO = {});
3318   void AddConversionCandidate(
3319       CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
3320       CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3321       OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3322       bool AllowExplicit, bool AllowResultConversion = true);
3323   void AddTemplateConversionCandidate(
3324       FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3325       CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3326       OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3327       bool AllowExplicit, bool AllowResultConversion = true);
3328   void AddSurrogateCandidate(CXXConversionDecl *Conversion,
3329                              DeclAccessPair FoundDecl,
3330                              CXXRecordDecl *ActingContext,
3331                              const FunctionProtoType *Proto,
3332                              Expr *Object, ArrayRef<Expr *> Args,
3333                              OverloadCandidateSet& CandidateSet);
3334   void AddNonMemberOperatorCandidates(
3335       const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
3336       OverloadCandidateSet &CandidateSet,
3337       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
3338   void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
3339                                    SourceLocation OpLoc, ArrayRef<Expr *> Args,
3340                                    OverloadCandidateSet &CandidateSet,
3341                                    OverloadCandidateParamOrder PO = {});
3342   void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
3343                            OverloadCandidateSet& CandidateSet,
3344                            bool IsAssignmentOperator = false,
3345                            unsigned NumContextualBoolArguments = 0);
3346   void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
3347                                     SourceLocation OpLoc, ArrayRef<Expr *> Args,
3348                                     OverloadCandidateSet& CandidateSet);
3349   void AddArgumentDependentLookupCandidates(DeclarationName Name,
3350                                             SourceLocation Loc,
3351                                             ArrayRef<Expr *> Args,
3352                                 TemplateArgumentListInfo *ExplicitTemplateArgs,
3353                                             OverloadCandidateSet& CandidateSet,
3354                                             bool PartialOverloading = false);
3355
3356   // Emit as a 'note' the specific overload candidate
3357   void NoteOverloadCandidate(
3358       NamedDecl *Found, FunctionDecl *Fn,
3359       OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),
3360       QualType DestType = QualType(), bool TakingAddress = false);
3361
3362   // Emit as a series of 'note's all template and non-templates identified by
3363   // the expression Expr
3364   void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
3365                                  bool TakingAddress = false);
3366
3367   /// Check the enable_if expressions on the given function. Returns the first
3368   /// failing attribute, or NULL if they were all successful.
3369   EnableIfAttr *CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
3370                               bool MissingImplicitThis = false);
3371
3372   /// Find the failed Boolean condition within a given Boolean
3373   /// constant expression, and describe it with a string.
3374   std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);
3375
3376   /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3377   /// non-ArgDependent DiagnoseIfAttrs.
3378   ///
3379   /// Argument-dependent diagnose_if attributes should be checked each time a
3380   /// function is used as a direct callee of a function call.
3381   ///
3382   /// Returns true if any errors were emitted.
3383   bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
3384                                            const Expr *ThisArg,
3385                                            ArrayRef<const Expr *> Args,
3386                                            SourceLocation Loc);
3387
3388   /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3389   /// ArgDependent DiagnoseIfAttrs.
3390   ///
3391   /// Argument-independent diagnose_if attributes should be checked on every use
3392   /// of a function.
3393   ///
3394   /// Returns true if any errors were emitted.
3395   bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
3396                                              SourceLocation Loc);
3397
3398   /// Returns whether the given function's address can be taken or not,
3399   /// optionally emitting a diagnostic if the address can't be taken.
3400   ///
3401   /// Returns false if taking the address of the function is illegal.
3402   bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
3403                                          bool Complain = false,
3404                                          SourceLocation Loc = SourceLocation());
3405
3406   // [PossiblyAFunctionType]  -->   [Return]
3407   // NonFunctionType --> NonFunctionType
3408   // R (A) --> R(A)
3409   // R (*)(A) --> R (A)
3410   // R (&)(A) --> R (A)
3411   // R (S::*)(A) --> R (A)
3412   QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
3413
3414   FunctionDecl *
3415   ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
3416                                      QualType TargetType,
3417                                      bool Complain,
3418                                      DeclAccessPair &Found,
3419                                      bool *pHadMultipleCandidates = nullptr);
3420
3421   FunctionDecl *
3422   resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);
3423
3424   bool resolveAndFixAddressOfSingleOverloadCandidate(
3425       ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
3426
3427   FunctionDecl *
3428   ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
3429                                               bool Complain = false,
3430                                               DeclAccessPair *Found = nullptr);
3431
3432   bool ResolveAndFixSingleFunctionTemplateSpecialization(
3433                       ExprResult &SrcExpr,
3434                       bool DoFunctionPointerConverion = false,
3435                       bool Complain = false,
3436                       SourceRange OpRangeForComplaining = SourceRange(),
3437                       QualType DestTypeForComplaining = QualType(),
3438                       unsigned DiagIDForComplaining = 0);
3439
3440
3441   Expr *FixOverloadedFunctionReference(Expr *E,
3442                                        DeclAccessPair FoundDecl,
3443                                        FunctionDecl *Fn);
3444   ExprResult FixOverloadedFunctionReference(ExprResult,
3445                                             DeclAccessPair FoundDecl,
3446                                             FunctionDecl *Fn);
3447
3448   void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
3449                                    ArrayRef<Expr *> Args,
3450                                    OverloadCandidateSet &CandidateSet,
3451                                    bool PartialOverloading = false);
3452
3453   // An enum used to represent the different possible results of building a
3454   // range-based for loop.
3455   enum ForRangeStatus {
3456     FRS_Success,
3457     FRS_NoViableFunction,
3458     FRS_DiagnosticIssued
3459   };
3460
3461   ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
3462                                            SourceLocation RangeLoc,
3463                                            const DeclarationNameInfo &NameInfo,
3464                                            LookupResult &MemberLookup,
3465                                            OverloadCandidateSet *CandidateSet,
3466                                            Expr *Range, ExprResult *CallExpr);
3467
3468   ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
3469                                      UnresolvedLookupExpr *ULE,
3470                                      SourceLocation LParenLoc,
3471                                      MultiExprArg Args,
3472                                      SourceLocation RParenLoc,
3473                                      Expr *ExecConfig,
3474                                      bool AllowTypoCorrection=true,
3475                                      bool CalleesAddressIsTaken=false);
3476
3477   bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
3478                               MultiExprArg Args, SourceLocation RParenLoc,
3479                               OverloadCandidateSet *CandidateSet,
3480                               ExprResult *Result);
3481
3482   ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
3483                                      UnaryOperatorKind Opc,
3484                                      const UnresolvedSetImpl &Fns,
3485                                      Expr *input, bool RequiresADL = true);
3486
3487   void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
3488                              OverloadedOperatorKind Op,
3489                              const UnresolvedSetImpl &Fns,
3490                              ArrayRef<Expr *> Args, bool RequiresADL = true);
3491   ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
3492                                    BinaryOperatorKind Opc,
3493                                    const UnresolvedSetImpl &Fns,
3494                                    Expr *LHS, Expr *RHS,
3495                                    bool RequiresADL = true,
3496                                    bool AllowRewrittenCandidates = true,
3497                                    FunctionDecl *DefaultedFn = nullptr);
3498   ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,
3499                                                 const UnresolvedSetImpl &Fns,
3500                                                 Expr *LHS, Expr *RHS,
3501                                                 FunctionDecl *DefaultedFn);
3502
3503   ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
3504                                                 SourceLocation RLoc,
3505                                                 Expr *Base,Expr *Idx);
3506
3507   ExprResult
3508   BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
3509                             SourceLocation LParenLoc,
3510                             MultiExprArg Args,
3511                             SourceLocation RParenLoc);
3512   ExprResult
3513   BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
3514                                MultiExprArg Args,
3515                                SourceLocation RParenLoc);
3516
3517   ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
3518                                       SourceLocation OpLoc,
3519                                       bool *NoArrowOperatorFound = nullptr);
3520
3521   /// CheckCallReturnType - Checks that a call expression's return type is
3522   /// complete. Returns true on failure. The location passed in is the location
3523   /// that best represents the call.
3524   bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
3525                            CallExpr *CE, FunctionDecl *FD);
3526
3527   /// Helpers for dealing with blocks and functions.
3528   bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
3529                                 bool CheckParameterNames);
3530   void CheckCXXDefaultArguments(FunctionDecl *FD);
3531   void CheckExtraCXXDefaultArguments(Declarator &D);
3532   Scope *getNonFieldDeclScope(Scope *S);
3533
3534   /// \name Name lookup
3535   ///
3536   /// These routines provide name lookup that is used during semantic
3537   /// analysis to resolve the various kinds of names (identifiers,
3538   /// overloaded operator names, constructor names, etc.) into zero or
3539   /// more declarations within a particular scope. The major entry
3540   /// points are LookupName, which performs unqualified name lookup,
3541   /// and LookupQualifiedName, which performs qualified name lookup.
3542   ///
3543   /// All name lookup is performed based on some specific criteria,
3544   /// which specify what names will be visible to name lookup and how
3545   /// far name lookup should work. These criteria are important both
3546   /// for capturing language semantics (certain lookups will ignore
3547   /// certain names, for example) and for performance, since name
3548   /// lookup is often a bottleneck in the compilation of C++. Name
3549   /// lookup criteria is specified via the LookupCriteria enumeration.
3550   ///
3551   /// The results of name lookup can vary based on the kind of name
3552   /// lookup performed, the current language, and the translation
3553   /// unit. In C, for example, name lookup will either return nothing
3554   /// (no entity found) or a single declaration. In C++, name lookup
3555   /// can additionally refer to a set of overloaded functions or
3556   /// result in an ambiguity. All of the possible results of name
3557   /// lookup are captured by the LookupResult class, which provides
3558   /// the ability to distinguish among them.
3559   //@{
3560
3561   /// Describes the kind of name lookup to perform.
3562   enum LookupNameKind {
3563     /// Ordinary name lookup, which finds ordinary names (functions,
3564     /// variables, typedefs, etc.) in C and most kinds of names
3565     /// (functions, variables, members, types, etc.) in C++.
3566     LookupOrdinaryName = 0,
3567     /// Tag name lookup, which finds the names of enums, classes,
3568     /// structs, and unions.
3569     LookupTagName,
3570     /// Label name lookup.
3571     LookupLabel,
3572     /// Member name lookup, which finds the names of
3573     /// class/struct/union members.
3574     LookupMemberName,
3575     /// Look up of an operator name (e.g., operator+) for use with
3576     /// operator overloading. This lookup is similar to ordinary name
3577     /// lookup, but will ignore any declarations that are class members.
3578     LookupOperatorName,
3579     /// Look up a name following ~ in a destructor name. This is an ordinary
3580     /// lookup, but prefers tags to typedefs.
3581     LookupDestructorName,
3582     /// Look up of a name that precedes the '::' scope resolution
3583     /// operator in C++. This lookup completely ignores operator, object,
3584     /// function, and enumerator names (C++ [basic.lookup.qual]p1).
3585     LookupNestedNameSpecifierName,
3586     /// Look up a namespace name within a C++ using directive or
3587     /// namespace alias definition, ignoring non-namespace names (C++
3588     /// [basic.lookup.udir]p1).
3589     LookupNamespaceName,
3590     /// Look up all declarations in a scope with the given name,
3591     /// including resolved using declarations.  This is appropriate
3592     /// for checking redeclarations for a using declaration.
3593     LookupUsingDeclName,
3594     /// Look up an ordinary name that is going to be redeclared as a
3595     /// name with linkage. This lookup ignores any declarations that
3596     /// are outside of the current scope unless they have linkage. See
3597     /// C99 6.2.2p4-5 and C++ [basic.link]p6.
3598     LookupRedeclarationWithLinkage,
3599     /// Look up a friend of a local class. This lookup does not look
3600     /// outside the innermost non-class scope. See C++11 [class.friend]p11.
3601     LookupLocalFriendName,
3602     /// Look up the name of an Objective-C protocol.
3603     LookupObjCProtocolName,
3604     /// Look up implicit 'self' parameter of an objective-c method.
3605     LookupObjCImplicitSelfParam,
3606     /// Look up the name of an OpenMP user-defined reduction operation.
3607     LookupOMPReductionName,
3608     /// Look up the name of an OpenMP user-defined mapper.
3609     LookupOMPMapperName,
3610     /// Look up any declaration with any name.
3611     LookupAnyName
3612   };
3613
3614   /// Specifies whether (or how) name lookup is being performed for a
3615   /// redeclaration (vs. a reference).
3616   enum RedeclarationKind {
3617     /// The lookup is a reference to this name that is not for the
3618     /// purpose of redeclaring the name.
3619     NotForRedeclaration = 0,
3620     /// The lookup results will be used for redeclaration of a name,
3621     /// if an entity by that name already exists and is visible.
3622     ForVisibleRedeclaration,
3623     /// The lookup results will be used for redeclaration of a name
3624     /// with external linkage; non-visible lookup results with external linkage
3625     /// may also be found.
3626     ForExternalRedeclaration
3627   };
3628
3629   RedeclarationKind forRedeclarationInCurContext() {
3630     // A declaration with an owning module for linkage can never link against
3631     // anything that is not visible. We don't need to check linkage here; if
3632     // the context has internal linkage, redeclaration lookup won't find things
3633     // from other TUs, and we can't safely compute linkage yet in general.
3634     if (cast<Decl>(CurContext)
3635             ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
3636       return ForVisibleRedeclaration;
3637     return ForExternalRedeclaration;
3638   }
3639
3640   /// The possible outcomes of name lookup for a literal operator.
3641   enum LiteralOperatorLookupResult {
3642     /// The lookup resulted in an error.
3643     LOLR_Error,
3644     /// The lookup found no match but no diagnostic was issued.
3645     LOLR_ErrorNoDiagnostic,
3646     /// The lookup found a single 'cooked' literal operator, which
3647     /// expects a normal literal to be built and passed to it.
3648     LOLR_Cooked,
3649     /// The lookup found a single 'raw' literal operator, which expects
3650     /// a string literal containing the spelling of the literal token.
3651     LOLR_Raw,
3652     /// The lookup found an overload set of literal operator templates,
3653     /// which expect the characters of the spelling of the literal token to be
3654     /// passed as a non-type template argument pack.
3655     LOLR_Template,
3656     /// The lookup found an overload set of literal operator templates,
3657     /// which expect the character type and characters of the spelling of the
3658     /// string literal token to be passed as template arguments.
3659     LOLR_StringTemplate
3660   };
3661
3662   SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
3663                                                   CXXSpecialMember SM,
3664                                                   bool ConstArg,
3665                                                   bool VolatileArg,
3666                                                   bool RValueThis,
3667                                                   bool ConstThis,
3668                                                   bool VolatileThis);
3669
3670   typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
3671   typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
3672       TypoRecoveryCallback;
3673
3674 private:
3675   bool CppLookupName(LookupResult &R, Scope *S);
3676
3677   struct TypoExprState {
3678     std::unique_ptr<TypoCorrectionConsumer> Consumer;
3679     TypoDiagnosticGenerator DiagHandler;
3680     TypoRecoveryCallback RecoveryHandler;
3681     TypoExprState();
3682     TypoExprState(TypoExprState &&other) noexcept;
3683     TypoExprState &operator=(TypoExprState &&other) noexcept;
3684   };
3685
3686   /// The set of unhandled TypoExprs and their associated state.
3687   llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
3688
3689   /// Creates a new TypoExpr AST node.
3690   TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
3691                               TypoDiagnosticGenerator TDG,
3692                               TypoRecoveryCallback TRC);
3693
3694   // The set of known/encountered (unique, canonicalized) NamespaceDecls.
3695   //
3696   // The boolean value will be true to indicate that the namespace was loaded
3697   // from an AST/PCH file, or false otherwise.
3698   llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
3699
3700   /// Whether we have already loaded known namespaces from an extenal
3701   /// source.
3702   bool LoadedExternalKnownNamespaces;
3703
3704   /// Helper for CorrectTypo and CorrectTypoDelayed used to create and
3705   /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
3706   /// should be skipped entirely.
3707   std::unique_ptr<TypoCorrectionConsumer>
3708   makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
3709                              Sema::LookupNameKind LookupKind, Scope *S,
3710                              CXXScopeSpec *SS,
3711                              CorrectionCandidateCallback &CCC,
3712                              DeclContext *MemberContext, bool EnteringContext,
3713                              const ObjCObjectPointerType *OPT,
3714                              bool ErrorRecovery);
3715
3716 public:
3717   const TypoExprState &getTypoExprState(TypoExpr *TE) const;
3718
3719   /// Clears the state of the given TypoExpr.
3720   void clearDelayedTypo(TypoExpr *TE);
3721
3722   /// Look up a name, looking for a single declaration.  Return
3723   /// null if the results were absent, ambiguous, or overloaded.
3724   ///
3725   /// It is preferable to use the elaborated form and explicitly handle
3726   /// ambiguity and overloaded.
3727   NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
3728                               SourceLocation Loc,
3729                               LookupNameKind NameKind,
3730                               RedeclarationKind Redecl
3731                                 = NotForRedeclaration);
3732   bool LookupBuiltin(LookupResult &R);
3733   bool LookupName(LookupResult &R, Scope *S,
3734                   bool AllowBuiltinCreation = false);
3735   bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
3736                            bool InUnqualifiedLookup = false);
3737   bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
3738                            CXXScopeSpec &SS);
3739   bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
3740                         bool AllowBuiltinCreation = false,
3741                         bool EnteringContext = false);
3742   ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
3743                                    RedeclarationKind Redecl
3744                                      = NotForRedeclaration);
3745   bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
3746
3747   void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
3748                                     QualType T1, QualType T2,
3749                                     UnresolvedSetImpl &Functions);
3750
3751   LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
3752                                  SourceLocation GnuLabelLoc = SourceLocation());
3753
3754   DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
3755   CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
3756   CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
3757                                                unsigned Quals);
3758   CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
3759                                          bool RValueThis, unsigned ThisQuals);
3760   CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
3761                                               unsigned Quals);
3762   CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
3763                                         bool RValueThis, unsigned ThisQuals);
3764   CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
3765
3766   bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);
3767   LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R,
3768                                                     ArrayRef<QualType> ArgTys,
3769                                                     bool AllowRaw,
3770                                                     bool AllowTemplate,
3771                                                     bool AllowStringTemplate,
3772                                                     bool DiagnoseMissing);
3773   bool isKnownName(StringRef name);
3774
3775   /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
3776   enum class FunctionEmissionStatus {
3777     Emitted,
3778     CUDADiscarded,     // Discarded due to CUDA/HIP hostness
3779     OMPDiscarded,      // Discarded due to OpenMP hostness
3780     TemplateDiscarded, // Discarded due to uninstantiated templates
3781     Unknown,
3782   };
3783   FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,
3784                                            bool Final = false);
3785
3786   // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.
3787   bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);
3788
3789   void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
3790                                ArrayRef<Expr *> Args, ADLResult &Functions);
3791
3792   void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
3793                           VisibleDeclConsumer &Consumer,
3794                           bool IncludeGlobalScope = true,
3795                           bool LoadExternal = true);
3796   void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
3797                           VisibleDeclConsumer &Consumer,
3798                           bool IncludeGlobalScope = true,
3799                           bool IncludeDependentBases = false,
3800                           bool LoadExternal = true);
3801
3802   enum CorrectTypoKind {
3803     CTK_NonError,     // CorrectTypo used in a non error recovery situation.
3804     CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
3805   };
3806
3807   TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
3808                              Sema::LookupNameKind LookupKind,
3809                              Scope *S, CXXScopeSpec *SS,
3810                              CorrectionCandidateCallback &CCC,
3811                              CorrectTypoKind Mode,
3812                              DeclContext *MemberContext = nullptr,
3813                              bool EnteringContext = false,
3814                              const ObjCObjectPointerType *OPT = nullptr,
3815                              bool RecordFailure = true);
3816
3817   TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,
3818                                Sema::LookupNameKind LookupKind, Scope *S,
3819                                CXXScopeSpec *SS,
3820                                CorrectionCandidateCallback &CCC,
3821                                TypoDiagnosticGenerator TDG,
3822                                TypoRecoveryCallback TRC, CorrectTypoKind Mode,
3823                                DeclContext *MemberContext = nullptr,
3824                                bool EnteringContext = false,
3825                                const ObjCObjectPointerType *OPT = nullptr);
3826
3827   /// Process any TypoExprs in the given Expr and its children,
3828   /// generating diagnostics as appropriate and returning a new Expr if there
3829   /// were typos that were all successfully corrected and ExprError if one or
3830   /// more typos could not be corrected.
3831   ///
3832   /// \param E The Expr to check for TypoExprs.
3833   ///
3834   /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
3835   /// initializer.
3836   ///
3837   /// \param Filter A function applied to a newly rebuilt Expr to determine if
3838   /// it is an acceptable/usable result from a single combination of typo
3839   /// corrections. As long as the filter returns ExprError, different
3840   /// combinations of corrections will be tried until all are exhausted.
3841   ExprResult
3842   CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl = nullptr,
3843                             llvm::function_ref<ExprResult(Expr *)> Filter =
3844                                 [](Expr *E) -> ExprResult { return E; });
3845
3846   ExprResult
3847   CorrectDelayedTyposInExpr(Expr *E,
3848                             llvm::function_ref<ExprResult(Expr *)> Filter) {
3849     return CorrectDelayedTyposInExpr(E, nullptr, Filter);
3850   }
3851
3852   ExprResult
3853   CorrectDelayedTyposInExpr(ExprResult ER, VarDecl *InitDecl = nullptr,
3854                             llvm::function_ref<ExprResult(Expr *)> Filter =
3855                                 [](Expr *E) -> ExprResult { return E; }) {
3856     return ER.isInvalid() ? ER : CorrectDelayedTyposInExpr(ER.get(), Filter);
3857   }
3858
3859   ExprResult
3860   CorrectDelayedTyposInExpr(ExprResult ER,
3861                             llvm::function_ref<ExprResult(Expr *)> Filter) {
3862     return CorrectDelayedTyposInExpr(ER, nullptr, Filter);
3863   }
3864
3865   void diagnoseTypo(const TypoCorrection &Correction,
3866                     const PartialDiagnostic &TypoDiag,
3867                     bool ErrorRecovery = true);
3868
3869   void diagnoseTypo(const TypoCorrection &Correction,
3870                     const PartialDiagnostic &TypoDiag,
3871                     const PartialDiagnostic &PrevNote,
3872                     bool ErrorRecovery = true);
3873
3874   void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
3875
3876   void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
3877                                           ArrayRef<Expr *> Args,
3878                                    AssociatedNamespaceSet &AssociatedNamespaces,
3879                                    AssociatedClassSet &AssociatedClasses);
3880
3881   void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
3882                             bool ConsiderLinkage, bool AllowInlineNamespace);
3883
3884   bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);
3885
3886   void DiagnoseAmbiguousLookup(LookupResult &Result);
3887   //@}
3888
3889   /// Attempts to produce a RecoveryExpr after some AST node cannot be created.
3890   ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
3891                                 ArrayRef<Expr *> SubExprs);
3892
3893   ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
3894                                           SourceLocation IdLoc,
3895                                           bool TypoCorrection = false);
3896   NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
3897                                  Scope *S, bool ForRedeclaration,
3898                                  SourceLocation Loc);
3899   NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
3900                                       Scope *S);
3901   void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
3902       FunctionDecl *FD);
3903   void AddKnownFunctionAttributes(FunctionDecl *FD);
3904
3905   // More parsing and symbol table subroutines.
3906
3907   void ProcessPragmaWeak(Scope *S, Decl *D);
3908   // Decl attributes - this routine is the top level dispatcher.
3909   void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
3910   // Helper for delayed processing of attributes.
3911   void ProcessDeclAttributeDelayed(Decl *D,
3912                                    const ParsedAttributesView &AttrList);
3913   void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
3914                              bool IncludeCXX11Attributes = true);
3915   bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
3916                                    const ParsedAttributesView &AttrList);
3917
3918   void checkUnusedDeclAttributes(Declarator &D);
3919
3920   /// Determine if type T is a valid subject for a nonnull and similar
3921   /// attributes. By default, we look through references (the behavior used by
3922   /// nonnull), but if the second parameter is true, then we treat a reference
3923   /// type as valid.
3924   bool isValidPointerAttrType(QualType T, bool RefOkay = false);
3925
3926   bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);
3927   bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,
3928                             const FunctionDecl *FD = nullptr);
3929   bool CheckAttrTarget(const ParsedAttr &CurrAttr);
3930   bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
3931   bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,
3932                                       StringRef &Str,
3933                                       SourceLocation *ArgLocation = nullptr);
3934   bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
3935   bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
3936   bool checkMSInheritanceAttrOnDefinition(
3937       CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3938       MSInheritanceModel SemanticSpelling);
3939
3940   void CheckAlignasUnderalignment(Decl *D);
3941
3942   /// Adjust the calling convention of a method to be the ABI default if it
3943   /// wasn't specified explicitly.  This handles method types formed from
3944   /// function type typedefs and typename template arguments.
3945   void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
3946                               SourceLocation Loc);
3947
3948   // Check if there is an explicit attribute, but only look through parens.
3949   // The intent is to look for an attribute on the current declarator, but not
3950   // one that came from a typedef.
3951   bool hasExplicitCallingConv(QualType T);
3952
3953   /// Get the outermost AttributedType node that sets a calling convention.
3954   /// Valid types should not have multiple attributes with different CCs.
3955   const AttributedType *getCallingConvAttributedType(QualType T) const;
3956
3957   /// Stmt attributes - this routine is the top level dispatcher.
3958   StmtResult ProcessStmtAttributes(Stmt *Stmt,
3959                                    const ParsedAttributesView &Attrs,
3960                                    SourceRange Range);
3961
3962   void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
3963                                    ObjCMethodDecl *MethodDecl,
3964                                    bool IsProtocolMethodDecl);
3965
3966   void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
3967                                    ObjCMethodDecl *Overridden,