clang  6.0.0
Sema.h
Go to the documentation of this file.
1 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the Sema class, which performs semantic analysis and
11 // builds ASTs.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_SEMA_SEMA_H
16 #define LLVM_CLANG_SEMA_SEMA_H
17 
18 #include "clang/AST/Attr.h"
19 #include "clang/AST/Availability.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprObjC.h"
25 #include "clang/AST/LocInfoType.h"
27 #include "clang/AST/NSAPI.h"
29 #include "clang/AST/StmtCXX.h"
30 #include "clang/AST/TypeLoc.h"
31 #include "clang/AST/TypeOrdering.h"
34 #include "clang/Basic/Module.h"
37 #include "clang/Basic/Specifiers.h"
39 #include "clang/Basic/TypeTraits.h"
41 #include "clang/Sema/CleanupInfo.h"
42 #include "clang/Sema/DeclSpec.h"
46 #include "clang/Sema/Ownership.h"
47 #include "clang/Sema/Scope.h"
48 #include "clang/Sema/ScopeInfo.h"
50 #include "clang/Sema/Weak.h"
51 #include "llvm/ADT/ArrayRef.h"
52 #include "llvm/ADT/Optional.h"
53 #include "llvm/ADT/SetVector.h"
54 #include "llvm/ADT/SmallPtrSet.h"
55 #include "llvm/ADT/SmallVector.h"
56 #include "llvm/ADT/TinyPtrVector.h"
57 #include <deque>
58 #include <memory>
59 #include <string>
60 #include <vector>
61 
62 namespace llvm {
63  class APSInt;
64  template <typename ValueT> struct DenseMapInfo;
65  template <typename ValueT, typename ValueInfoT> class DenseSet;
66  class SmallBitVector;
67  struct InlineAsmIdentifierInfo;
68 }
69 
70 namespace clang {
71  class ADLResult;
72  class ASTConsumer;
73  class ASTContext;
74  class ASTMutationListener;
75  class ASTReader;
76  class ASTWriter;
77  class ArrayType;
78  class AttributeList;
79  class BindingDecl;
80  class BlockDecl;
81  class CapturedDecl;
82  class CXXBasePath;
83  class CXXBasePaths;
84  class CXXBindTemporaryExpr;
86  class CXXConstructorDecl;
87  class CXXConversionDecl;
88  class CXXDeleteExpr;
89  class CXXDestructorDecl;
90  class CXXFieldCollector;
91  class CXXMemberCallExpr;
92  class CXXMethodDecl;
93  class CXXScopeSpec;
94  class CXXTemporary;
95  class CXXTryStmt;
96  class CallExpr;
97  class ClassTemplateDecl;
98  class ClassTemplatePartialSpecializationDecl;
99  class ClassTemplateSpecializationDecl;
100  class VarTemplatePartialSpecializationDecl;
101  class CodeCompleteConsumer;
102  class CodeCompletionAllocator;
103  class CodeCompletionTUInfo;
104  class CodeCompletionResult;
105  class CoroutineBodyStmt;
106  class Decl;
107  class DeclAccessPair;
108  class DeclContext;
109  class DeclRefExpr;
110  class DeclaratorDecl;
111  class DeducedTemplateArgument;
112  class DependentDiagnostic;
113  class DesignatedInitExpr;
114  class Designation;
115  class EnableIfAttr;
116  class EnumConstantDecl;
117  class Expr;
118  class ExtVectorType;
119  class FormatAttr;
120  class FriendDecl;
121  class FunctionDecl;
122  class FunctionProtoType;
123  class FunctionTemplateDecl;
124  class ImplicitConversionSequence;
126  class InitListExpr;
127  class InitializationKind;
128  class InitializationSequence;
129  class InitializedEntity;
130  class IntegerLiteral;
131  class LabelStmt;
132  class LambdaExpr;
133  class LangOptions;
134  class LocalInstantiationScope;
135  class LookupResult;
136  class MacroInfo;
138  class ModuleLoader;
139  class MultiLevelTemplateArgumentList;
140  class NamedDecl;
141  class ObjCCategoryDecl;
142  class ObjCCategoryImplDecl;
143  class ObjCCompatibleAliasDecl;
144  class ObjCContainerDecl;
145  class ObjCImplDecl;
146  class ObjCImplementationDecl;
147  class ObjCInterfaceDecl;
148  class ObjCIvarDecl;
149  template <class T> class ObjCList;
150  class ObjCMessageExpr;
151  class ObjCMethodDecl;
152  class ObjCPropertyDecl;
153  class ObjCProtocolDecl;
154  class OMPThreadPrivateDecl;
155  class OMPDeclareReductionDecl;
156  class OMPDeclareSimdDecl;
157  class OMPClause;
158  struct OverloadCandidate;
159  class OverloadCandidateSet;
160  class OverloadExpr;
161  class ParenListExpr;
162  class ParmVarDecl;
163  class Preprocessor;
164  class PseudoDestructorTypeStorage;
165  class PseudoObjectExpr;
166  class QualType;
167  class StandardConversionSequence;
168  class Stmt;
169  class StringLiteral;
170  class SwitchStmt;
171  class TemplateArgument;
172  class TemplateArgumentList;
173  class TemplateArgumentLoc;
174  class TemplateDecl;
175  class TemplateParameterList;
176  class TemplatePartialOrderingContext;
177  class TemplateTemplateParmDecl;
178  class Token;
179  class TypeAliasDecl;
180  class TypedefDecl;
181  class TypedefNameDecl;
182  class TypeLoc;
183  class TypoCorrectionConsumer;
184  class UnqualifiedId;
185  class UnresolvedLookupExpr;
186  class UnresolvedMemberExpr;
187  class UnresolvedSetImpl;
188  class UnresolvedSetIterator;
189  class UsingDecl;
190  class UsingShadowDecl;
191  class ValueDecl;
192  class VarDecl;
193  class VarTemplateSpecializationDecl;
194  class VisibilityAttr;
195  class VisibleDeclConsumer;
196  class IndirectFieldDecl;
197  struct DeductionFailureInfo;
198  class TemplateSpecCandidateSet;
199 
200 namespace sema {
201  class AccessedEntity;
202  class BlockScopeInfo;
203  class CapturedRegionScopeInfo;
204  class CapturingScopeInfo;
205  class CompoundScopeInfo;
206  class DelayedDiagnostic;
207  class DelayedDiagnosticPool;
208  class FunctionScopeInfo;
209  class LambdaScopeInfo;
210  class PossiblyUnreachableDiag;
211  class SemaPPCallbacks;
212  class TemplateDeductionInfo;
213 }
214 
215 namespace threadSafety {
216  class BeforeSet;
217  void threadSafetyCleanup(BeforeSet* Cache);
218 }
219 
220 // FIXME: No way to easily map from TemplateTypeParmTypes to
221 // TemplateTypeParmDecls, so we have this horrible PointerUnion.
222 typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
224 
225 /// Describes whether we've seen any nullability information for the given
226 /// file.
228  /// The first pointer declarator (of any pointer kind) in the file that does
229  /// not have a corresponding nullability annotation.
231 
232  /// The end location for the first pointer declarator in the file. Used for
233  /// placing fix-its.
235 
236  /// Which kind of pointer declarator we saw.
237  uint8_t PointerKind;
238 
239  /// Whether we saw any type nullability annotations in the given file.
240  bool SawTypeNullability = false;
241 };
242 
243 /// A mapping from file IDs to a record of whether we've seen nullability
244 /// information in that file.
246  /// A mapping from file IDs to the nullability information for each file ID.
247  llvm::DenseMap<FileID, FileNullability> Map;
248 
249  /// A single-element cache based on the file ID.
250  struct {
253  } Cache;
254 
255 public:
257  // Check the single-element cache.
258  if (file == Cache.File)
259  return Cache.Nullability;
260 
261  // It's not in the single-element cache; flush the cache if we have one.
262  if (!Cache.File.isInvalid()) {
263  Map[Cache.File] = Cache.Nullability;
264  }
265 
266  // Pull this entry into the cache.
267  Cache.File = file;
268  Cache.Nullability = Map[file];
269  return Cache.Nullability;
270  }
271 };
272 
273 /// Sema - This implements semantic analysis and AST building for C.
274 class Sema {
275  Sema(const Sema &) = delete;
276  void operator=(const Sema &) = delete;
277 
278  ///\brief Source of additional semantic information.
279  ExternalSemaSource *ExternalSource;
280 
281  ///\brief Whether Sema has generated a multiplexer and has to delete it.
282  bool isMultiplexExternalSource;
283 
284  static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
285 
286  bool isVisibleSlow(const NamedDecl *D);
287 
288  /// Determine whether two declarations should be linked together, given that
289  /// the old declaration might not be visible and the new declaration might
290  /// not have external linkage.
291  bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
292  const NamedDecl *New) {
293  if (isVisible(Old))
294  return true;
295  // See comment in below overload for why it's safe to compute the linkage
296  // of the new declaration here.
297  if (New->isExternallyDeclarable()) {
298  assert(Old->isExternallyDeclarable() &&
299  "should not have found a non-externally-declarable previous decl");
300  return true;
301  }
302  return false;
303  }
304  bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
305 
306 public:
310 
313 
320 
321  /// \brief Flag indicating whether or not to collect detailed statistics.
323 
324  /// \brief Code-completion consumer.
326 
327  /// CurContext - This is the current declaration context of parsing.
329 
330  /// \brief Generally null except when we temporarily switch decl contexts,
331  /// like in \see ActOnObjCTemporaryExitContainerContext.
333 
334  /// VAListTagName - The declaration name corresponding to __va_list_tag.
335  /// This is used as part of a hack to omit that class from ADL results.
337 
338  bool MSStructPragmaOn; // True when \#pragma ms_struct on
339 
340  /// \brief Controls member pointer representation format under the MS ABI.
343 
344  /// Stack of active SEH __finally scopes. Can be empty.
346 
347  /// \brief Source location for newly created implicit MSInheritanceAttrs
349 
350  /// \brief pragma clang section kind
352  PCSK_Invalid = 0,
353  PCSK_BSS = 1,
354  PCSK_Data = 2,
355  PCSK_Rodata = 3,
356  PCSK_Text = 4
357  };
358 
360  PCSA_Set = 0,
361  PCSA_Clear = 1
362  };
363 
365  std::string SectionName;
366  bool Valid = false;
368 
369  void Act(SourceLocation PragmaLocation,
371  StringLiteral* Name);
372  };
373 
378 
380  PSK_Reset = 0x0, // #pragma ()
381  PSK_Set = 0x1, // #pragma (value)
382  PSK_Push = 0x2, // #pragma (push[, id])
383  PSK_Pop = 0x4, // #pragma (pop[, id])
384  PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
385  PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
386  PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
387  };
388 
389  template<typename ValueType>
390  struct PragmaStack {
391  struct Slot {
392  llvm::StringRef StackSlotLabel;
393  ValueType Value;
396  Slot(llvm::StringRef StackSlotLabel, ValueType Value,
397  SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
398  : StackSlotLabel(StackSlotLabel), Value(Value),
399  PragmaLocation(PragmaLocation),
400  PragmaPushLocation(PragmaPushLocation) {}
401  };
402  void Act(SourceLocation PragmaLocation,
403  PragmaMsStackAction Action,
404  llvm::StringRef StackSlotLabel,
405  ValueType Value);
406 
407  // MSVC seems to add artificial slots to #pragma stacks on entering a C++
408  // method body to restore the stacks on exit, so it works like this:
409  //
410  // struct S {
411  // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
412  // void Method {}
413  // #pragma <name>(pop, InternalPragmaSlot)
414  // };
415  //
416  // It works even with #pragma vtordisp, although MSVC doesn't support
417  // #pragma vtordisp(push [, id], n)
418  // syntax.
419  //
420  // Push / pop a named sentinel slot.
421  void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
422  assert((Action == PSK_Push || Action == PSK_Pop) &&
423  "Can only push / pop #pragma stack sentinels!");
424  Act(CurrentPragmaLocation, Action, Label, CurrentValue);
425  }
426 
427  // Constructors.
428  explicit PragmaStack(const ValueType &Default)
429  : DefaultValue(Default), CurrentValue(Default) {}
430 
431  bool hasValue() const { return CurrentValue != DefaultValue; }
432 
434  ValueType DefaultValue; // Value used for PSK_Reset action.
435  ValueType CurrentValue;
437  };
438  // FIXME: We should serialize / deserialize these if they occur in a PCH (but
439  // we shouldn't do so if they're in a module).
440 
441  /// \brief Whether to insert vtordisps prior to virtual bases in the Microsoft
442  /// C++ ABI. Possible values are 0, 1, and 2, which mean:
443  ///
444  /// 0: Suppress all vtordisps
445  /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
446  /// structors
447  /// 2: Always insert vtordisps to support RTTI on partially constructed
448  /// objects
450  // #pragma pack.
451  // Sentinel to represent when the stack is set to mac68k alignment.
452  static const unsigned kMac68kAlignmentSentinel = ~0U;
454  // The current #pragma pack values and locations at each #include.
456  unsigned CurrentValue;
458  bool HasNonDefaultValue, ShouldWarnOnInclude;
459  };
461  // Segment #pragmas.
466 
467  // RAII object to push / pop sentinel slots for all MS #pragma stacks.
468  // Actions should be performed only if we enter / exit a C++ method body.
470  public:
471  PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
473 
474  private:
475  Sema &S;
476  StringRef SlotLabel;
477  bool ShouldAct;
478  };
479 
480  /// A mapping that describes the nullability we've seen in each header file.
482 
483  /// Last section used with #pragma init_seg.
486 
487  /// VisContext - Manages the stack for \#pragma GCC visibility.
488  void *VisContext; // Really a "PragmaVisStack*"
489 
490  /// \brief This represents the stack of attributes that were pushed by
491  /// \#pragma clang attribute.
496  bool IsUsed;
497  };
499 
500  /// \brief The declaration that is currently receiving an attribute from the
501  /// #pragma attribute stack.
503 
504  /// \brief This represents the last location of a "#pragma clang optimize off"
505  /// directive if such a directive has not been closed by an "on" yet. If
506  /// optimizations are currently "on", this is set to an invalid location.
508 
509  /// \brief Flag indicating if Sema is building a recovery call expression.
510  ///
511  /// This flag is used to avoid building recovery call expressions
512  /// if Sema is already doing so, which would cause infinite recursions.
514 
515  /// Used to control the generation of ExprWithCleanups.
517 
518  /// ExprCleanupObjects - This is the stack of objects requiring
519  /// cleanup that are created by the current full expression. The
520  /// element type here is ExprWithCleanups::Object.
522 
523  /// \brief Store a list of either DeclRefExprs or MemberExprs
524  /// that contain a reference to a variable (constant) that may or may not
525  /// be odr-used in this Expr, and we won't know until all lvalue-to-rvalue
526  /// and discarded value conversions have been applied to all subexpressions
527  /// of the enclosing full expression. This is cleared at the end of each
528  /// full expression.
529  llvm::SmallPtrSet<Expr*, 2> MaybeODRUseExprs;
530 
531  /// \brief Stack containing information about each of the nested
532  /// function, block, and method scopes that are currently active.
533  ///
534  /// This array is never empty. Clients should ignore the first
535  /// element, which is used to cache a single FunctionScopeInfo
536  /// that's used to parse every top-level function.
538 
540  &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
542 
543  /// ExtVectorDecls - This is a list all the extended vector types. This allows
544  /// us to associate a raw vector type with one of the ext_vector type names.
545  /// This is only necessary for issuing pretty diagnostics.
547 
548  /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
549  std::unique_ptr<CXXFieldCollector> FieldCollector;
550 
552 
553  /// \brief Set containing all declared private fields that are not used.
554  NamedDeclSetType UnusedPrivateFields;
555 
556  /// \brief Set containing all typedefs that are likely unused.
559 
560  /// \brief Delete-expressions to be analyzed at the end of translation unit
561  ///
562  /// This list contains class members, and locations of delete-expressions
563  /// that could not be proven as to whether they mismatch with new-expression
564  /// used in initializer of the field.
565  typedef std::pair<SourceLocation, bool> DeleteExprLoc;
567  llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
568 
569  typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
570 
571  /// PureVirtualClassDiagSet - a set of class declarations which we have
572  /// emitted a list of pure virtual functions. Used to prevent emitting the
573  /// same list more than once.
574  std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
575 
576  /// ParsingInitForAutoVars - a set of declarations with auto types for which
577  /// we are currently parsing the initializer.
578  llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
579 
580  /// \brief Look for a locally scoped extern "C" declaration by the given name.
581  NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
582 
583  typedef LazyVector<VarDecl *, ExternalSemaSource,
584  &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
586 
587  /// \brief All the tentative definitions encountered in the TU.
589 
590  typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
591  &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
593 
594  /// \brief The set of file scoped decls seen so far that have not been used
595  /// and must warn if not used. Only contains the first declaration.
597 
598  typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
599  &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
601 
602  /// \brief All the delegating constructors seen so far in the file, used for
603  /// cycle detection at the end of the TU.
605 
606  /// \brief All the overriding functions seen during a class definition
607  /// that had their exception spec checks delayed, plus the overridden
608  /// function.
611 
612  /// \brief All the members seen during a class definition which were both
613  /// explicitly defaulted and had explicitly-specified exception
614  /// specifications, along with the function type containing their
615  /// user-specified exception specification. Those exception specifications
616  /// were overridden with the default specifications, but we still need to
617  /// check whether they are compatible with the default specification, and
618  /// we can't do that until the nesting set of class definitions is complete.
621 
622  typedef llvm::MapVector<const FunctionDecl *,
623  std::unique_ptr<LateParsedTemplate>>
626 
627  /// \brief Callback to the parser to parse templated functions when needed.
628  typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
629  typedef void LateTemplateParserCleanupCB(void *P);
630  LateTemplateParserCB *LateTemplateParser;
631  LateTemplateParserCleanupCB *LateTemplateParserCleanup;
633 
634  void SetLateTemplateParser(LateTemplateParserCB *LTP,
635  LateTemplateParserCleanupCB *LTPCleanup,
636  void *P) {
637  LateTemplateParser = LTP;
638  LateTemplateParserCleanup = LTPCleanup;
639  OpaqueParser = P;
640  }
641 
642  class DelayedDiagnostics;
643 
645  sema::DelayedDiagnosticPool *SavedPool;
647  };
650 
651  /// A class which encapsulates the logic for delaying diagnostics
652  /// during parsing and other processing.
654  /// \brief The current pool of diagnostics into which delayed
655  /// diagnostics should go.
657 
658  public:
659  DelayedDiagnostics() : CurPool(nullptr) {}
660 
661  /// Adds a delayed diagnostic.
662  void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
663 
664  /// Determines whether diagnostics should be delayed.
665  bool shouldDelayDiagnostics() { return CurPool != nullptr; }
666 
667  /// Returns the current delayed-diagnostics pool.
669  return CurPool;
670  }
671 
672  /// Enter a new scope. Access and deprecation diagnostics will be
673  /// collected in this pool.
676  state.SavedPool = CurPool;
677  CurPool = &pool;
678  return state;
679  }
680 
681  /// Leave a delayed-diagnostic state that was previously pushed.
682  /// Do not emit any of the diagnostics. This is performed as part
683  /// of the bookkeeping of popping a pool "properly".
685  CurPool = state.SavedPool;
686  }
687 
688  /// Enter a new scope where access and deprecation diagnostics are
689  /// not delayed.
692  state.SavedPool = CurPool;
693  CurPool = nullptr;
694  return state;
695  }
696 
697  /// Undo a previous pushUndelayed().
699  assert(CurPool == nullptr);
700  CurPool = state.SavedPool;
701  }
703 
704  /// A RAII object to temporarily push a declaration context.
705  class ContextRAII {
706  private:
707  Sema &S;
708  DeclContext *SavedContext;
709  ProcessingContextState SavedContextState;
710  QualType SavedCXXThisTypeOverride;
711 
712  public:
713  ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
714  : S(S), SavedContext(S.CurContext),
715  SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
716  SavedCXXThisTypeOverride(S.CXXThisTypeOverride)
717  {
718  assert(ContextToPush && "pushing null context");
719  S.CurContext = ContextToPush;
720  if (NewThisContext)
722  }
723 
724  void pop() {
725  if (!SavedContext) return;
726  S.CurContext = SavedContext;
727  S.DelayedDiagnostics.popUndelayed(SavedContextState);
728  S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
729  SavedContext = nullptr;
730  }
731 
733  pop();
734  }
735  };
736 
737  /// \brief RAII object to handle the state changes required to synthesize
738  /// a function body.
740  Sema &S;
741  Sema::ContextRAII SavedContext;
742  bool PushedCodeSynthesisContext = false;
743 
744  public:
746  : S(S), SavedContext(S, DC) {
747  S.PushFunctionScope();
749  Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
750  if (auto *FD = dyn_cast<FunctionDecl>(DC))
751  FD->setWillHaveBody(true);
752  else
753  assert(isa<ObjCMethodDecl>(DC));
754  }
755 
757  assert(!PushedCodeSynthesisContext);
758 
760  Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
761  Ctx.PointOfInstantiation = UseLoc;
762  Ctx.Entity = cast<Decl>(S.CurContext);
764 
765  PushedCodeSynthesisContext = true;
766  }
767 
769  if (PushedCodeSynthesisContext)
771  if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
772  FD->setWillHaveBody(false);
775  }
776  };
777 
778  /// WeakUndeclaredIdentifiers - Identifiers contained in
779  /// \#pragma weak before declared. rare. may alias another
780  /// identifier, declared or undeclared
781  llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
782 
783  /// ExtnameUndeclaredIdentifiers - Identifiers contained in
784  /// \#pragma redefine_extname before declared. Used in Solaris system headers
785  /// to define functions that occur in multiple standards to call the version
786  /// in the currently selected standard.
787  llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
788 
789 
790  /// \brief Load weak undeclared identifiers from the external source.
791  void LoadExternalWeakUndeclaredIdentifiers();
792 
793  /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
794  /// \#pragma weak during processing of other Decls.
795  /// I couldn't figure out a clean way to generate these in-line, so
796  /// we store them here and handle separately -- which is a hack.
797  /// It would be best to refactor this.
799 
801 
802  /// Translation Unit Scope - useful to Objective-C actions that need
803  /// to lookup file scope declarations in the "ordinary" C decl namespace.
804  /// For example, user-defined classes, built-in "id" type, etc.
806 
807  /// \brief The C++ "std" namespace, where the standard library resides.
809 
810  /// \brief The C++ "std::bad_alloc" class, which is defined by the C++
811  /// standard library.
813 
814  /// \brief The C++ "std::align_val_t" enum class, which is defined by the C++
815  /// standard library.
817 
818  /// \brief The C++ "std::experimental" namespace, where the experimental parts
819  /// of the standard library resides.
821 
822  /// \brief The C++ "std::initializer_list" template, which is defined in
823  /// <initializer_list>.
825 
826  /// \brief The C++ "type_info" declaration, which is defined in <typeinfo>.
828 
829  /// \brief The MSVC "_GUID" struct, which is defined in MSVC header files.
831 
832  /// \brief Caches identifiers/selectors for NSFoundation APIs.
833  std::unique_ptr<NSAPI> NSAPIObj;
834 
835  /// \brief The declaration of the Objective-C NSNumber class.
837 
838  /// \brief The declaration of the Objective-C NSValue class.
840 
841  /// \brief Pointer to NSNumber type (NSNumber *).
843 
844  /// \brief Pointer to NSValue type (NSValue *).
846 
847  /// \brief The Objective-C NSNumber methods used to create NSNumber literals.
848  ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
849 
850  /// \brief The declaration of the Objective-C NSString class.
852 
853  /// \brief Pointer to NSString type (NSString *).
855 
856  /// \brief The declaration of the stringWithUTF8String: method.
858 
859  /// \brief The declaration of the valueWithBytes:objCType: method.
861 
862  /// \brief The declaration of the Objective-C NSArray class.
864 
865  /// \brief The declaration of the arrayWithObjects:count: method.
867 
868  /// \brief The declaration of the Objective-C NSDictionary class.
870 
871  /// \brief The declaration of the dictionaryWithObjects:forKeys:count: method.
873 
874  /// \brief id<NSCopying> type.
876 
877  /// \brief will hold 'respondsToSelector:'
879 
880  /// A flag to remember whether the implicit forms of operator new and delete
881  /// have been declared.
883 
884  /// A flag to indicate that we're in a context that permits abstract
885  /// references to fields. This is really a
887 
888  /// \brief Describes how the expressions currently being parsed are
889  /// evaluated at run-time, if at all.
891  /// \brief The current expression and its subexpressions occur within an
892  /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
893  /// \c sizeof, where the type of the expression may be significant but
894  /// no code will be generated to evaluate the value of the expression at
895  /// run time.
896  Unevaluated,
897 
898  /// \brief The current expression occurs within a braced-init-list within
899  /// an unevaluated operand. This is mostly like a regular unevaluated
900  /// context, except that we still instantiate constexpr functions that are
901  /// referenced here so that we can perform narrowing checks correctly.
902  UnevaluatedList,
903 
904  /// \brief The current expression occurs within a discarded statement.
905  /// This behaves largely similarly to an unevaluated operand in preventing
906  /// definitions from being required, but not in other ways.
907  DiscardedStatement,
908 
909  /// \brief The current expression occurs within an unevaluated
910  /// operand that unconditionally permits abstract references to
911  /// fields, such as a SIZE operator in MS-style inline assembly.
912  UnevaluatedAbstract,
913 
914  /// \brief The current context is "potentially evaluated" in C++11 terms,
915  /// but the expression is evaluated at compile-time (like the values of
916  /// cases in a switch statement).
917  ConstantEvaluated,
918 
919  /// \brief The current expression is potentially evaluated at run time,
920  /// which means that code may be generated to evaluate the value of the
921  /// expression at run time.
922  PotentiallyEvaluated,
923 
924  /// \brief The current expression is potentially evaluated, but any
925  /// declarations referenced inside that expression are only used if
926  /// in fact the current expression is used.
927  ///
928  /// This value is used when parsing default function arguments, for which
929  /// we would like to provide diagnostics (e.g., passing non-POD arguments
930  /// through varargs) but do not want to mark declarations as "referenced"
931  /// until the default argument is used.
932  PotentiallyEvaluatedIfUsed
933  };
934 
935  /// \brief Data structure used to record current or nested
936  /// expression evaluation contexts.
938  /// \brief The expression evaluation context.
940 
941  /// \brief Whether the enclosing context needed a cleanup.
943 
944  /// \brief Whether we are in a decltype expression.
946 
947  /// \brief The number of active cleanup objects when we entered
948  /// this expression evaluation context.
950 
951  /// \brief The number of typos encountered during this expression evaluation
952  /// context (i.e. the number of TypoExprs created).
953  unsigned NumTypos;
954 
955  llvm::SmallPtrSet<Expr*, 2> SavedMaybeODRUseExprs;
956 
957  /// \brief The lambdas that are present within this context, if it
958  /// is indeed an unevaluated context.
960 
961  /// \brief The declaration that provides context for lambda expressions
962  /// and block literals if the normal declaration context does not
963  /// suffice, e.g., in a default function argument.
965 
966  /// \brief The context information used to mangle lambda expressions
967  /// and block literals within this context.
968  ///
969  /// This mangling information is allocated lazily, since most contexts
970  /// do not have lambda expressions or block literals.
971  std::unique_ptr<MangleNumberingContext> MangleNumbering;
972 
973  /// \brief If we are processing a decltype type, a set of call expressions
974  /// for which we have deferred checking the completeness of the return type.
976 
977  /// \brief If we are processing a decltype type, a set of temporary binding
978  /// expressions for which we have deferred checking the destructor.
980 
982  unsigned NumCleanupObjects,
983  CleanupInfo ParentCleanup,
984  Decl *ManglingContextDecl,
985  bool IsDecltype)
986  : Context(Context), ParentCleanup(ParentCleanup),
987  IsDecltype(IsDecltype), NumCleanupObjects(NumCleanupObjects),
988  NumTypos(0),
989  ManglingContextDecl(ManglingContextDecl), MangleNumbering() { }
990 
991  /// \brief Retrieve the mangling numbering context, used to consistently
992  /// number constructs like lambdas for mangling.
993  MangleNumberingContext &getMangleNumberingContext(ASTContext &Ctx);
994 
995  bool isUnevaluated() const {
996  return Context == ExpressionEvaluationContext::Unevaluated ||
997  Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
998  Context == ExpressionEvaluationContext::UnevaluatedList;
999  }
1000  bool isConstantEvaluated() const {
1001  return Context == ExpressionEvaluationContext::ConstantEvaluated;
1002  }
1003  };
1004 
1005  /// A stack of expression evaluation contexts.
1007 
1008  /// \brief Compute the mangling number context for a lambda expression or
1009  /// block literal.
1010  ///
1011  /// \param DC - The DeclContext containing the lambda expression or
1012  /// block literal.
1013  /// \param[out] ManglingContextDecl - Returns the ManglingContextDecl
1014  /// associated with the context, if relevant.
1015  MangleNumberingContext *getCurrentMangleNumberContext(
1016  const DeclContext *DC,
1017  Decl *&ManglingContextDecl);
1018 
1019 
1020  /// SpecialMemberOverloadResult - The overloading result for a special member
1021  /// function.
1022  ///
1023  /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1024  /// integer are used to determine whether overload resolution succeeded.
1026  public:
1027  enum Kind {
1030  Success
1031  };
1032 
1033  private:
1034  llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1035 
1036  public:
1039  : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1040 
1041  CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1042  void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1043 
1044  Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1045  void setKind(Kind K) { Pair.setInt(K); }
1046  };
1047 
1049  : public llvm::FastFoldingSetNode,
1051  public:
1052  SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1053  : FastFoldingSetNode(ID)
1054  {}
1055  };
1056 
1057  /// \brief A cache of special member function overload resolution results
1058  /// for C++ records.
1059  llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1060 
1061  /// \brief A cache of the flags available in enumerations with the flag_bits
1062  /// attribute.
1063  mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1064 
1065  /// \brief The kind of translation unit we are processing.
1066  ///
1067  /// When we're processing a complete translation unit, Sema will perform
1068  /// end-of-translation-unit semantic tasks (such as creating
1069  /// initializers for tentative definitions in C) once parsing has
1070  /// completed. Modules and precompiled headers perform different kinds of
1071  /// checks.
1073 
1074  llvm::BumpPtrAllocator BumpAlloc;
1075 
1076  /// \brief The number of SFINAE diagnostics that have been trapped.
1078 
1079  typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1081 
1082  /// \brief A mapping from parameters with unparsed default arguments to the
1083  /// set of instantiations of each parameter.
1084  ///
1085  /// This mapping is a temporary data structure used when parsing
1086  /// nested class templates or nested classes of class templates,
1087  /// where we might end up instantiating an inner class before the
1088  /// default arguments of its methods have been parsed.
1090 
1091  // Contains the locations of the beginning of unparsed default
1092  // argument locations.
1093  llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1094 
1095  /// UndefinedInternals - all the used, undefined objects which require a
1096  /// definition in this translation unit.
1097  llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1098 
1099  /// Determine if VD, which must be a variable or function, is an external
1100  /// symbol that nonetheless can't be referenced from outside this translation
1101  /// unit because its type has no linkage and it's not extern "C".
1102  bool isExternalWithNoLinkageType(ValueDecl *VD);
1103 
1104  /// Obtain a sorted list of functions that are undefined but ODR-used.
1105  void getUndefinedButUsed(
1106  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1107 
1108  /// Retrieves list of suspicious delete-expressions that will be checked at
1109  /// the end of translation unit.
1110  const llvm::MapVector<FieldDecl *, DeleteLocs> &
1111  getMismatchingDeleteExpressions() const;
1112 
1113  typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1114  typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1115 
1116  /// Method Pool - allows efficient lookup when typechecking messages to "id".
1117  /// We need to maintain a list, since selectors can have differing signatures
1118  /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1119  /// of selectors are "overloaded").
1120  /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1121  /// methods inside categories with a particular selector.
1122  GlobalMethodPool MethodPool;
1123 
1124  /// Method selectors used in a \@selector expression. Used for implementation
1125  /// of -Wselector.
1126  llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1127 
1128  /// Kinds of C++ special members.
1136  CXXInvalid
1137  };
1138 
1139  typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1141 
1142  /// The C++ special members which we are currently in the process of
1143  /// declaring. If this process recursively triggers the declaration of the
1144  /// same special member, we should act as if it is not yet declared.
1145  llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1146 
1147  /// The function definitions which were renamed as part of typo-correction
1148  /// to match their respective declarations. We want to keep track of them
1149  /// to ensure that we don't emit a "redefinition" error if we encounter a
1150  /// correctly named definition after the renamed definition.
1151  llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1152 
1153  /// Stack of types that correspond to the parameter entities that are
1154  /// currently being copy-initialized. Can be empty.
1156 
1157  void ReadMethodPool(Selector Sel);
1158  void updateOutOfDateSelector(Selector Sel);
1159 
1160  /// Private Helper predicate to check for 'self'.
1161  bool isSelfExpr(Expr *RExpr);
1162  bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1163 
1164  /// \brief Cause the active diagnostic on the DiagosticsEngine to be
1165  /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1166  /// should not be used elsewhere.
1167  void EmitCurrentDiagnostic(unsigned DiagID);
1168 
1169  /// Records and restores the FP_CONTRACT state on entry/exit of compound
1170  /// statements.
1172  public:
1173  FPContractStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.FPFeatures) {}
1174  ~FPContractStateRAII() { S.FPFeatures = OldFPFeaturesState; }
1175 
1176  private:
1177  Sema& S;
1178  FPOptions OldFPFeaturesState;
1179  };
1180 
1181  void addImplicitTypedef(StringRef Name, QualType T);
1182 
1183 public:
1184  Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1186  CodeCompleteConsumer *CompletionConsumer = nullptr);
1187  ~Sema();
1188 
1189  /// \brief Perform initialization that occurs after the parser has been
1190  /// initialized but before it parses anything.
1191  void Initialize();
1192 
1193  const LangOptions &getLangOpts() const { return LangOpts; }
1194  OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1195  FPOptions &getFPOptions() { return FPFeatures; }
1196 
1197  DiagnosticsEngine &getDiagnostics() const { return Diags; }
1198  SourceManager &getSourceManager() const { return SourceMgr; }
1199  Preprocessor &getPreprocessor() const { return PP; }
1200  ASTContext &getASTContext() const { return Context; }
1201  ASTConsumer &getASTConsumer() const { return Consumer; }
1202  ASTMutationListener *getASTMutationListener() const;
1203  ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1204 
1205  ///\brief Registers an external source. If an external source already exists,
1206  /// creates a multiplex external source and appends to it.
1207  ///
1208  ///\param[in] E - A non-null external sema source.
1209  ///
1210  void addExternalSource(ExternalSemaSource *E);
1211 
1212  void PrintStats() const;
1213 
1214  /// \brief Helper class that creates diagnostics with optional
1215  /// template instantiation stacks.
1216  ///
1217  /// This class provides a wrapper around the basic DiagnosticBuilder
1218  /// class that emits diagnostics. SemaDiagnosticBuilder is
1219  /// responsible for emitting the diagnostic (as DiagnosticBuilder
1220  /// does) and, if the diagnostic comes from inside a template
1221  /// instantiation, printing the template instantiation stack as
1222  /// well.
1224  Sema &SemaRef;
1225  unsigned DiagID;
1226 
1227  public:
1228  SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1229  : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
1230 
1231  // This is a cunning lie. DiagnosticBuilder actually performs move
1232  // construction in its copy constructor (but due to varied uses, it's not
1233  // possible to conveniently express this as actual move construction). So
1234  // the default copy ctor here is fine, because the base class disables the
1235  // source anyway, so the user-defined ~SemaDiagnosticBuilder is a safe no-op
1236  // in that case anwyay.
1237  SemaDiagnosticBuilder(const SemaDiagnosticBuilder&) = default;
1238 
1240  // If we aren't active, there is nothing to do.
1241  if (!isActive()) return;
1242 
1243  // Otherwise, we need to emit the diagnostic. First flush the underlying
1244  // DiagnosticBuilder data, and clear the diagnostic builder itself so it
1245  // won't emit the diagnostic in its own destructor.
1246  //
1247  // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1248  // do its own needless checks to see if the diagnostic needs to be
1249  // emitted. However, because we take care to ensure that the builder
1250  // objects never escape, a sufficiently smart compiler will be able to
1251  // eliminate that code.
1252  FlushCounts();
1253  Clear();
1254 
1255  // Dispatch to Sema to emit the diagnostic.
1256  SemaRef.EmitCurrentDiagnostic(DiagID);
1257  }
1258 
1259  /// Teach operator<< to produce an object of the correct type.
1260  template<typename T>
1262  const SemaDiagnosticBuilder &Diag, const T &Value) {
1263  const DiagnosticBuilder &BaseDiag = Diag;
1264  BaseDiag << Value;
1265  return Diag;
1266  }
1267  };
1268 
1269  /// \brief Emit a diagnostic.
1271  DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
1272  return SemaDiagnosticBuilder(DB, *this, DiagID);
1273  }
1274 
1275  /// \brief Emit a partial diagnostic.
1277 
1278  /// \brief Build a partial diagnostic.
1279  PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1280 
1281  bool findMacroSpelling(SourceLocation &loc, StringRef name);
1282 
1283  /// \brief Get a string to suggest for zero-initialization of a type.
1284  std::string
1285  getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1286  std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1287 
1288  /// \brief Calls \c Lexer::getLocForEndOfToken()
1289  SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1290 
1291  /// \brief Retrieve the module loader associated with the preprocessor.
1292  ModuleLoader &getModuleLoader() const;
1293 
1294  void emitAndClearUnusedLocalTypedefWarnings();
1295 
1296  void ActOnStartOfTranslationUnit();
1297  void ActOnEndOfTranslationUnit();
1298 
1299  void CheckDelegatingCtorCycles();
1300 
1301  Scope *getScopeForContext(DeclContext *Ctx);
1302 
1303  void PushFunctionScope();
1304  void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1305  sema::LambdaScopeInfo *PushLambdaScope();
1306 
1307  /// \brief This is used to inform Sema what the current TemplateParameterDepth
1308  /// is during Parsing. Currently it is used to pass on the depth
1309  /// when parsing generic lambda 'auto' parameters.
1310  void RecordParsingTemplateParameterDepth(unsigned Depth);
1311 
1312  void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1313  RecordDecl *RD,
1314  CapturedRegionKind K);
1315  void
1316  PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1317  const Decl *D = nullptr,
1318  const BlockExpr *blkExpr = nullptr);
1319 
1321  return FunctionScopes.back();
1322  }
1323 
1325  if (FunctionScopes.empty())
1326  return nullptr;
1327 
1328  for (int e = FunctionScopes.size()-1; e >= 0; --e) {
1329  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1330  continue;
1331  return FunctionScopes[e];
1332  }
1333  return nullptr;
1334  }
1335 
1336  template <typename ExprT>
1337  void recordUseOfEvaluatedWeak(const ExprT *E, bool IsRead=true) {
1338  if (!isUnevaluatedContext())
1339  getCurFunction()->recordUseOfWeak(E, IsRead);
1340  }
1341 
1342  void PushCompoundScope();
1343  void PopCompoundScope();
1344 
1345  sema::CompoundScopeInfo &getCurCompoundScope() const;
1346 
1347  bool hasAnyUnrecoverableErrorsInThisFunction() const;
1348 
1349  /// \brief Retrieve the current block, if any.
1350  sema::BlockScopeInfo *getCurBlock();
1351 
1352  /// Retrieve the current lambda scope info, if any.
1353  /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1354  /// lambda scope info ignoring all inner capturing scopes that are not
1355  /// lambda scopes.
1357  getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1358 
1359  /// \brief Retrieve the current generic lambda info, if any.
1360  sema::LambdaScopeInfo *getCurGenericLambda();
1361 
1362  /// \brief Retrieve the current captured region, if any.
1363  sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1364 
1365  /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1366  SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1367 
1368  void ActOnComment(SourceRange Comment);
1369 
1370  //===--------------------------------------------------------------------===//
1371  // Type Analysis / Processing: SemaType.cpp.
1372  //
1373 
1374  QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1375  const DeclSpec *DS = nullptr);
1376  QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1377  const DeclSpec *DS = nullptr);
1378  QualType BuildPointerType(QualType T,
1379  SourceLocation Loc, DeclarationName Entity);
1380  QualType BuildReferenceType(QualType T, bool LValueRef,
1381  SourceLocation Loc, DeclarationName Entity);
1382  QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1383  Expr *ArraySize, unsigned Quals,
1384  SourceRange Brackets, DeclarationName Entity);
1385  QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1386  SourceLocation AttrLoc);
1387  QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1388  SourceLocation AttrLoc);
1389 
1390  bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1391 
1392  /// \brief Build a function type.
1393  ///
1394  /// This routine checks the function type according to C++ rules and
1395  /// under the assumption that the result type and parameter types have
1396  /// just been instantiated from a template. It therefore duplicates
1397  /// some of the behavior of GetTypeForDeclarator, but in a much
1398  /// simpler form that is only suitable for this narrow use case.
1399  ///
1400  /// \param T The return type of the function.
1401  ///
1402  /// \param ParamTypes The parameter types of the function. This array
1403  /// will be modified to account for adjustments to the types of the
1404  /// function parameters.
1405  ///
1406  /// \param Loc The location of the entity whose type involves this
1407  /// function type or, if there is no such entity, the location of the
1408  /// type that will have function type.
1409  ///
1410  /// \param Entity The name of the entity that involves the function
1411  /// type, if known.
1412  ///
1413  /// \param EPI Extra information about the function type. Usually this will
1414  /// be taken from an existing function with the same prototype.
1415  ///
1416  /// \returns A suitable function type, if there are no errors. The
1417  /// unqualified type will always be a FunctionProtoType.
1418  /// Otherwise, returns a NULL type.
1419  QualType BuildFunctionType(QualType T,
1420  MutableArrayRef<QualType> ParamTypes,
1421  SourceLocation Loc, DeclarationName Entity,
1422  const FunctionProtoType::ExtProtoInfo &EPI);
1423 
1424  QualType BuildMemberPointerType(QualType T, QualType Class,
1425  SourceLocation Loc,
1426  DeclarationName Entity);
1427  QualType BuildBlockPointerType(QualType T,
1428  SourceLocation Loc, DeclarationName Entity);
1429  QualType BuildParenType(QualType T);
1430  QualType BuildAtomicType(QualType T, SourceLocation Loc);
1431  QualType BuildReadPipeType(QualType T,
1432  SourceLocation Loc);
1433  QualType BuildWritePipeType(QualType T,
1434  SourceLocation Loc);
1435 
1436  TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
1437  TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
1438  TypeSourceInfo *GetTypeSourceInfoForDeclarator(Declarator &D, QualType T,
1439  TypeSourceInfo *ReturnTypeInfo);
1440 
1441  /// \brief Package the given type and TSI into a ParsedType.
1442  ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
1443  DeclarationNameInfo GetNameForDeclarator(Declarator &D);
1444  DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
1445  static QualType GetTypeFromParser(ParsedType Ty,
1446  TypeSourceInfo **TInfo = nullptr);
1447  CanThrowResult canThrow(const Expr *E);
1448  const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
1449  const FunctionProtoType *FPT);
1450  void UpdateExceptionSpec(FunctionDecl *FD,
1452  bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
1453  bool CheckDistantExceptionSpec(QualType T);
1454  bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
1455  bool CheckEquivalentExceptionSpec(
1456  const FunctionProtoType *Old, SourceLocation OldLoc,
1457  const FunctionProtoType *New, SourceLocation NewLoc);
1458  bool CheckEquivalentExceptionSpec(
1459  const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
1460  const FunctionProtoType *Old, SourceLocation OldLoc,
1461  const FunctionProtoType *New, SourceLocation NewLoc);
1462  bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
1463  const PartialDiagnostic &NestedDiagID,
1464  const PartialDiagnostic &NoteID,
1465  const FunctionProtoType *Superset,
1466  SourceLocation SuperLoc,
1467  const FunctionProtoType *Subset,
1468  SourceLocation SubLoc);
1469  bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
1470  const PartialDiagnostic &NoteID,
1471  const FunctionProtoType *Target,
1472  SourceLocation TargetLoc,
1473  const FunctionProtoType *Source,
1474  SourceLocation SourceLoc);
1475 
1476  TypeResult ActOnTypeName(Scope *S, Declarator &D);
1477 
1478  /// \brief The parser has parsed the context-sensitive type 'instancetype'
1479  /// in an Objective-C message declaration. Return the appropriate type.
1480  ParsedType ActOnObjCInstanceType(SourceLocation Loc);
1481 
1482  /// \brief Abstract class used to diagnose incomplete types.
1483  struct TypeDiagnoser {
1485 
1486  virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
1487  virtual ~TypeDiagnoser() {}
1488  };
1489 
1490  static int getPrintable(int I) { return I; }
1491  static unsigned getPrintable(unsigned I) { return I; }
1492  static bool getPrintable(bool B) { return B; }
1493  static const char * getPrintable(const char *S) { return S; }
1494  static StringRef getPrintable(StringRef S) { return S; }
1495  static const std::string &getPrintable(const std::string &S) { return S; }
1496  static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
1497  return II;
1498  }
1500  static QualType getPrintable(QualType T) { return T; }
1501  static SourceRange getPrintable(SourceRange R) { return R; }
1502  static SourceRange getPrintable(SourceLocation L) { return L; }
1503  static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
1504  static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
1505 
1506  template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
1507  unsigned DiagID;
1508  std::tuple<const Ts &...> Args;
1509 
1510  template <std::size_t... Is>
1511  void emit(const SemaDiagnosticBuilder &DB,
1512  llvm::index_sequence<Is...>) const {
1513  // Apply all tuple elements to the builder in order.
1514  bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
1515  (void)Dummy;
1516  }
1517 
1518  public:
1519  BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
1520  : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
1521  assert(DiagID != 0 && "no diagnostic for type diagnoser");
1522  }
1523 
1524  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
1525  const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
1526  emit(DB, llvm::index_sequence_for<Ts...>());
1527  DB << T;
1528  }
1529  };
1530 
1531 private:
1532  bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
1533  TypeDiagnoser *Diagnoser);
1534 
1535  struct ModuleScope {
1536  clang::Module *Module = nullptr;
1537  bool ModuleInterface = false;
1538  VisibleModuleSet OuterVisibleModules;
1539  };
1540  /// The modules we're currently parsing.
1542 
1543  /// Get the module whose scope we are currently within.
1544  Module *getCurrentModule() const {
1545  return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
1546  }
1547 
1548  VisibleModuleSet VisibleModules;
1549 
1550 public:
1551  /// \brief Get the module owning an entity.
1552  Module *getOwningModule(Decl *Entity) { return Entity->getOwningModule(); }
1553 
1554  /// \brief Make a merged definition of an existing hidden definition \p ND
1555  /// visible at the specified location.
1556  void makeMergedDefinitionVisible(NamedDecl *ND);
1557 
1558  bool isModuleVisible(const Module *M) { return VisibleModules.isVisible(M); }
1559 
1560  /// Determine whether a declaration is visible to name lookup.
1561  bool isVisible(const NamedDecl *D) {
1562  return !D->isHidden() || isVisibleSlow(D);
1563  }
1564 
1565  /// Determine whether any declaration of an entity is visible.
1566  bool
1568  llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
1569  return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
1570  }
1571  bool hasVisibleDeclarationSlow(const NamedDecl *D,
1573 
1574  bool hasVisibleMergedDefinition(NamedDecl *Def);
1575  bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
1576 
1577  /// Determine if \p D and \p Suggested have a structurally compatible
1578  /// layout as described in C11 6.2.7/1.
1579  bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
1580 
1581  /// Determine if \p D has a visible definition. If not, suggest a declaration
1582  /// that should be made visible to expose the definition.
1583  bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
1584  bool OnlyNeedComplete = false);
1586  NamedDecl *Hidden;
1587  return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
1588  }
1589 
1590  /// Determine if the template parameter \p D has a visible default argument.
1591  bool
1593  llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1594 
1595  /// Determine if there is a visible declaration of \p D that is an explicit
1596  /// specialization declaration for a specialization of a template. (For a
1597  /// member specialization, use hasVisibleMemberSpecialization.)
1598  bool hasVisibleExplicitSpecialization(
1599  const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1600 
1601  /// Determine if there is a visible declaration of \p D that is a member
1602  /// specialization declaration (as opposed to an instantiated declaration).
1603  bool hasVisibleMemberSpecialization(
1604  const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
1605 
1606  /// Determine if \p A and \p B are equivalent internal linkage declarations
1607  /// from different modules, and thus an ambiguity error can be downgraded to
1608  /// an extension warning.
1609  bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
1610  const NamedDecl *B);
1611  void diagnoseEquivalentInternalLinkageDeclarations(
1612  SourceLocation Loc, const NamedDecl *D,
1614 
1616  return !RequireCompleteTypeImpl(Loc, T, nullptr);
1617  }
1618  bool RequireCompleteType(SourceLocation Loc, QualType T,
1619  TypeDiagnoser &Diagnoser);
1620  bool RequireCompleteType(SourceLocation Loc, QualType T,
1621  unsigned DiagID);
1622 
1623  template <typename... Ts>
1624  bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
1625  const Ts &...Args) {
1626  BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1627  return RequireCompleteType(Loc, T, Diagnoser);
1628  }
1629 
1630  void completeExprArrayBound(Expr *E);
1631  bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser);
1632  bool RequireCompleteExprType(Expr *E, unsigned DiagID);
1633 
1634  template <typename... Ts>
1635  bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
1636  BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1637  return RequireCompleteExprType(E, Diagnoser);
1638  }
1639 
1640  bool RequireLiteralType(SourceLocation Loc, QualType T,
1641  TypeDiagnoser &Diagnoser);
1642  bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
1643 
1644  template <typename... Ts>
1645  bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
1646  const Ts &...Args) {
1647  BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
1648  return RequireLiteralType(Loc, T, Diagnoser);
1649  }
1650 
1651  QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
1652  const CXXScopeSpec &SS, QualType T);
1653 
1654  QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
1655  /// If AsUnevaluated is false, E is treated as though it were an evaluated
1656  /// context, such as when building a type for decltype(auto).
1657  QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
1658  bool AsUnevaluated = true);
1659  QualType BuildUnaryTransformType(QualType BaseType,
1661  SourceLocation Loc);
1662 
1663  //===--------------------------------------------------------------------===//
1664  // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
1665  //
1666 
1667  struct SkipBodyInfo {
1669  : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
1670  New(nullptr) {}
1675  };
1676 
1677  DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
1678 
1679  void DiagnoseUseOfUnimplementedSelectors();
1680 
1681  bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
1682 
1684  Scope *S, CXXScopeSpec *SS = nullptr,
1685  bool isClassName = false, bool HasTrailingDot = false,
1686  ParsedType ObjectType = nullptr,
1687  bool IsCtorOrDtorName = false,
1688  bool WantNontrivialTypeSourceInfo = false,
1689  bool IsClassTemplateDeductionContext = true,
1690  IdentifierInfo **CorrectedII = nullptr);
1691  TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
1692  bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
1693  void DiagnoseUnknownTypeName(IdentifierInfo *&II,
1694  SourceLocation IILoc,
1695  Scope *S,
1696  CXXScopeSpec *SS,
1697  ParsedType &SuggestedType,
1698  bool IsTemplateName = false);
1699 
1700  /// Attempt to behave like MSVC in situations where lookup of an unqualified
1701  /// type name has failed in a dependent context. In these situations, we
1702  /// automatically form a DependentTypeName that will retry lookup in a related
1703  /// scope during instantiation.
1704  ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
1705  SourceLocation NameLoc,
1706  bool IsTemplateTypeArg);
1707 
1708  /// \brief Describes the result of the name lookup and resolution performed
1709  /// by \c ClassifyName().
1719  NC_FunctionTemplate
1720  };
1721 
1724  ExprResult Expr;
1725  TemplateName Template;
1726  ParsedType Type;
1727 
1728  explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
1729 
1730  public:
1731  NameClassification(ExprResult Expr) : Kind(NC_Expression), Expr(Expr) {}
1732 
1733  NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
1734 
1735  NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
1736 
1738  return NameClassification(NC_Error);
1739  }
1740 
1742  return NameClassification(NC_Unknown);
1743  }
1744 
1746  return NameClassification(NC_NestedNameSpecifier);
1747  }
1748 
1750  NameClassification Result(NC_TypeTemplate);
1751  Result.Template = Name;
1752  return Result;
1753  }
1754 
1756  NameClassification Result(NC_VarTemplate);
1757  Result.Template = Name;
1758  return Result;
1759  }
1760 
1762  NameClassification Result(NC_FunctionTemplate);
1763  Result.Template = Name;
1764  return Result;
1765  }
1766 
1768 
1770  assert(Kind == NC_Type);
1771  return Type;
1772  }
1773 
1775  assert(Kind == NC_Expression);
1776  return Expr;
1777  }
1778 
1780  assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||
1781  Kind == NC_VarTemplate);
1782  return Template;
1783  }
1784 
1786  switch (Kind) {
1787  case NC_TypeTemplate:
1788  return TNK_Type_template;
1789  case NC_FunctionTemplate:
1790  return TNK_Function_template;
1791  case NC_VarTemplate:
1792  return TNK_Var_template;
1793  default:
1794  llvm_unreachable("unsupported name classification.");
1795  }
1796  }
1797  };
1798 
1799  /// \brief Perform name lookup on the given name, classifying it based on
1800  /// the results of name lookup and the following token.
1801  ///
1802  /// This routine is used by the parser to resolve identifiers and help direct
1803  /// parsing. When the identifier cannot be found, this routine will attempt
1804  /// to correct the typo and classify based on the resulting name.
1805  ///
1806  /// \param S The scope in which we're performing name lookup.
1807  ///
1808  /// \param SS The nested-name-specifier that precedes the name.
1809  ///
1810  /// \param Name The identifier. If typo correction finds an alternative name,
1811  /// this pointer parameter will be updated accordingly.
1812  ///
1813  /// \param NameLoc The location of the identifier.
1814  ///
1815  /// \param NextToken The token following the identifier. Used to help
1816  /// disambiguate the name.
1817  ///
1818  /// \param IsAddressOfOperand True if this name is the operand of a unary
1819  /// address of ('&') expression, assuming it is classified as an
1820  /// expression.
1821  ///
1822  /// \param CCC The correction callback, if typo correction is desired.
1824  ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
1825  SourceLocation NameLoc, const Token &NextToken,
1826  bool IsAddressOfOperand,
1827  std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr);
1828 
1829  /// Describes the detailed kind of a template name. Used in diagnostics.
1831  ClassTemplate,
1832  FunctionTemplate,
1833  VarTemplate,
1834  AliasTemplate,
1835  TemplateTemplateParam,
1836  DependentTemplate
1837  };
1839  getTemplateNameKindForDiagnostics(TemplateName Name);
1840 
1841  /// Determine whether it's plausible that E was intended to be a
1842  /// template-name.
1844  if (!getLangOpts().CPlusPlus || E.isInvalid())
1845  return false;
1846  if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
1847  return !DRE->hasExplicitTemplateArgs();
1848  if (auto *ME = dyn_cast<MemberExpr>(E.get()))
1849  return !ME->hasExplicitTemplateArgs();
1850  // Any additional cases recognized here should also be handled by
1851  // diagnoseExprIntendedAsTemplateName.
1852  return false;
1853  }
1854  void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
1855  SourceLocation Less,
1856  SourceLocation Greater);
1857 
1858  Decl *ActOnDeclarator(Scope *S, Declarator &D);
1859 
1860  NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
1861  MultiTemplateParamsArg TemplateParameterLists);
1862  void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
1863  bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
1864  bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
1865  DeclarationName Name,
1866  SourceLocation Loc);
1867  void
1868  diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
1869  SourceLocation FallbackLoc,
1870  SourceLocation ConstQualLoc = SourceLocation(),
1871  SourceLocation VolatileQualLoc = SourceLocation(),
1872  SourceLocation RestrictQualLoc = SourceLocation(),
1873  SourceLocation AtomicQualLoc = SourceLocation(),
1874  SourceLocation UnalignedQualLoc = SourceLocation());
1875 
1876  static bool adjustContextForLocalExternDecl(DeclContext *&DC);
1877  void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
1878  NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
1879  const LookupResult &R);
1880  NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
1881  void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
1882  const LookupResult &R);
1883  void CheckShadow(Scope *S, VarDecl *D);
1884 
1885  /// Warn if 'E', which is an expression that is about to be modified, refers
1886  /// to a shadowing declaration.
1887  void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
1888 
1889  void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
1890 
1891 private:
1892  /// Map of current shadowing declarations to shadowed declarations. Warn if
1893  /// it looks like the user is trying to modify the shadowing declaration.
1894  llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
1895 
1896 public:
1897  void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
1898  void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
1899  void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
1900  TypedefNameDecl *NewTD);
1901  void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
1902  NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1903  TypeSourceInfo *TInfo,
1905  NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
1906  LookupResult &Previous, bool &Redeclaration);
1907  NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
1908  TypeSourceInfo *TInfo,
1909  LookupResult &Previous,
1910  MultiTemplateParamsArg TemplateParamLists,
1911  bool &AddToScope,
1912  ArrayRef<BindingDecl *> Bindings = None);
1913  NamedDecl *
1914  ActOnDecompositionDeclarator(Scope *S, Declarator &D,
1915  MultiTemplateParamsArg TemplateParamLists);
1916  // Returns true if the variable declaration is a redeclaration
1917  bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
1918  void CheckVariableDeclarationType(VarDecl *NewVD);
1919  bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
1920  Expr *Init);
1921  void CheckCompleteVariableDeclaration(VarDecl *VD);
1922  void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
1923  void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
1924 
1925  NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1926  TypeSourceInfo *TInfo,
1927  LookupResult &Previous,
1928  MultiTemplateParamsArg TemplateParamLists,
1929  bool &AddToScope);
1930  bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
1931 
1932  bool CheckConstexprFunctionDecl(const FunctionDecl *FD);
1933  bool CheckConstexprFunctionBody(const FunctionDecl *FD, Stmt *Body);
1934 
1935  void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
1936  void FindHiddenVirtualMethods(CXXMethodDecl *MD,
1937  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1938  void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
1939  SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
1940  // Returns true if the function declaration is a redeclaration
1941  bool CheckFunctionDeclaration(Scope *S,
1942  FunctionDecl *NewFD, LookupResult &Previous,
1943  bool IsMemberSpecialization);
1944  bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
1945  void CheckMain(FunctionDecl *FD, const DeclSpec &D);
1946  void CheckMSVCRTEntryPoint(FunctionDecl *FD);
1947  Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
1948  ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
1949  SourceLocation Loc,
1950  QualType T);
1951  ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
1952  SourceLocation NameLoc, IdentifierInfo *Name,
1953  QualType T, TypeSourceInfo *TSInfo,
1954  StorageClass SC);
1955  void ActOnParamDefaultArgument(Decl *param,
1956  SourceLocation EqualLoc,
1957  Expr *defarg);
1958  void ActOnParamUnparsedDefaultArgument(Decl *param,
1959  SourceLocation EqualLoc,
1960  SourceLocation ArgLoc);
1961  void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
1962  bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
1963  SourceLocation EqualLoc);
1964 
1965  void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
1966  void ActOnUninitializedDecl(Decl *dcl);
1967  void ActOnInitializerError(Decl *Dcl);
1968 
1969  void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
1970  void ActOnCXXForRangeDecl(Decl *D);
1971  StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
1972  IdentifierInfo *Ident,
1973  ParsedAttributes &Attrs,
1974  SourceLocation AttrEnd);
1975  void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
1976  void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
1977  void FinalizeDeclaration(Decl *D);
1978  DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
1979  ArrayRef<Decl *> Group);
1980  DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
1981 
1982  /// Should be called on all declarations that might have attached
1983  /// documentation comments.
1984  void ActOnDocumentableDecl(Decl *D);
1985  void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
1986 
1987  void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
1988  SourceLocation LocAfterDecls);
1989  void CheckForFunctionRedefinition(
1990  FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
1991  SkipBodyInfo *SkipBody = nullptr);
1992  Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
1993  MultiTemplateParamsArg TemplateParamLists,
1994  SkipBodyInfo *SkipBody = nullptr);
1995  Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
1996  SkipBodyInfo *SkipBody = nullptr);
1997  void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
1999  return D && isa<ObjCMethodDecl>(D);
2000  }
2001 
2002  /// \brief Determine whether we can delay parsing the body of a function or
2003  /// function template until it is used, assuming we don't care about emitting
2004  /// code for that function.
2005  ///
2006  /// This will be \c false if we may need the body of the function in the
2007  /// middle of parsing an expression (where it's impractical to switch to
2008  /// parsing a different function), for instance, if it's constexpr in C++11
2009  /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2010  bool canDelayFunctionBody(const Declarator &D);
2011 
2012  /// \brief Determine whether we can skip parsing the body of a function
2013  /// definition, assuming we don't care about analyzing its body or emitting
2014  /// code for that function.
2015  ///
2016  /// This will be \c false only if we may need the body of the function in
2017  /// order to parse the rest of the program (for instance, if it is
2018  /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2019  bool canSkipFunctionBody(Decl *D);
2020 
2021  void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2022  Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2023  Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2024  Decl *ActOnSkippedFunctionBody(Decl *Decl);
2025  void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2026 
2027  /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2028  /// attribute for which parsing is delayed.
2029  void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2030 
2031  /// \brief Diagnose any unused parameters in the given sequence of
2032  /// ParmVarDecl pointers.
2033  void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2034 
2035  /// \brief Diagnose whether the size of parameters or return value of a
2036  /// function or obj-c method definition is pass-by-value and larger than a
2037  /// specified threshold.
2038  void
2039  DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2040  QualType ReturnTy, NamedDecl *D);
2041 
2042  void DiagnoseInvalidJumps(Stmt *Body);
2043  Decl *ActOnFileScopeAsmDecl(Expr *expr,
2044  SourceLocation AsmLoc,
2045  SourceLocation RParenLoc);
2046 
2047  /// \brief Handle a C++11 empty-declaration and attribute-declaration.
2048  Decl *ActOnEmptyDeclaration(Scope *S,
2049  AttributeList *AttrList,
2050  SourceLocation SemiLoc);
2051 
2052  enum class ModuleDeclKind {
2053  Interface, ///< 'export module X;'
2054  Implementation, ///< 'module X;'
2055  Partition, ///< 'module partition X;'
2056  };
2057 
2058  /// The parser has processed a module-declaration that begins the definition
2059  /// of a module interface or implementation.
2060  DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2061  SourceLocation ModuleLoc, ModuleDeclKind MDK,
2062  ModuleIdPath Path);
2063 
2064  /// \brief The parser has processed a module import declaration.
2065  ///
2066  /// \param AtLoc The location of the '@' symbol, if any.
2067  ///
2068  /// \param ImportLoc The location of the 'import' keyword.
2069  ///
2070  /// \param Path The module access path.
2071  DeclResult ActOnModuleImport(SourceLocation AtLoc, SourceLocation ImportLoc,
2072  ModuleIdPath Path);
2073 
2074  /// \brief The parser has processed a module import translated from a
2075  /// #include or similar preprocessing directive.
2076  void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2077  void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2078 
2079  /// \brief The parsed has entered a submodule.
2080  void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2081  /// \brief The parser has left a submodule.
2082  void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2083 
2084  /// \brief Create an implicit import of the given module at the given
2085  /// source location, for error recovery, if possible.
2086  ///
2087  /// This routine is typically used when an entity found by name lookup
2088  /// is actually hidden within a module that we know about but the user
2089  /// has forgotten to import.
2090  void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2091  Module *Mod);
2092 
2093  /// Kinds of missing import. Note, the values of these enumerators correspond
2094  /// to %select values in diagnostics.
2095  enum class MissingImportKind {
2096  Declaration,
2097  Definition,
2098  DefaultArgument,
2099  ExplicitSpecialization,
2100  PartialSpecialization
2101  };
2102 
2103  /// \brief Diagnose that the specified declaration needs to be visible but
2104  /// isn't, and suggest a module import that would resolve the problem.
2105  void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2106  MissingImportKind MIK, bool Recover = true);
2107  void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2108  SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2109  MissingImportKind MIK, bool Recover);
2110 
2111  Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2112  SourceLocation LBraceLoc);
2113  Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2114  SourceLocation RBraceLoc);
2115 
2116  /// \brief We've found a use of a templated declaration that would trigger an
2117  /// implicit instantiation. Check that any relevant explicit specializations
2118  /// and partial specializations are visible, and diagnose if not.
2119  void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2120 
2121  /// \brief We've found a use of a template specialization that would select a
2122  /// partial specialization. Check that the partial specialization is visible,
2123  /// and diagnose if not.
2124  void checkPartialSpecializationVisibility(SourceLocation Loc,
2125  NamedDecl *Spec);
2126 
2127  /// \brief Retrieve a suitable printing policy.
2129  return getPrintingPolicy(Context, PP);
2130  }
2131 
2132  /// \brief Retrieve a suitable printing policy.
2133  static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2134  const Preprocessor &PP);
2135 
2136  /// Scope actions.
2137  void ActOnPopScope(SourceLocation Loc, Scope *S);
2138  void ActOnTranslationUnitScope(Scope *S);
2139 
2140  Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2141  RecordDecl *&AnonRecord);
2142  Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2143  MultiTemplateParamsArg TemplateParams,
2144  bool IsExplicitInstantiation,
2145  RecordDecl *&AnonRecord);
2146 
2147  Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2148  AccessSpecifier AS,
2149  RecordDecl *Record,
2150  const PrintingPolicy &Policy);
2151 
2152  Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
2153  RecordDecl *Record);
2154 
2155  /// Common ways to introduce type names without a tag for use in diagnostics.
2156  /// Keep in sync with err_tag_reference_non_tag.
2157  enum NonTagKind {
2167  };
2168 
2169  /// Given a non-tag type declaration, returns an enum useful for indicating
2170  /// what kind of non-tag type this is.
2171  NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
2172 
2173  bool isAcceptableTagRedeclaration(const TagDecl *Previous,
2174  TagTypeKind NewTag, bool isDefinition,
2175  SourceLocation NewTagLoc,
2176  const IdentifierInfo *Name);
2177 
2178  enum TagUseKind {
2179  TUK_Reference, // Reference to a tag: 'struct foo *X;'
2180  TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
2181  TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'
2182  TUK_Friend // Friend declaration: 'friend struct foo;'
2183  };
2184 
2185  Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
2186  SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
2187  SourceLocation NameLoc, AttributeList *Attr,
2188  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
2189  MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
2190  bool &IsDependent, SourceLocation ScopedEnumKWLoc,
2191  bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
2192  bool IsTypeSpecifier, bool IsTemplateParamOrArg,
2193  SkipBodyInfo *SkipBody = nullptr);
2194 
2195  Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
2196  unsigned TagSpec, SourceLocation TagLoc,
2197  CXXScopeSpec &SS,
2198  IdentifierInfo *Name, SourceLocation NameLoc,
2200  MultiTemplateParamsArg TempParamLists);
2201 
2202  TypeResult ActOnDependentTag(Scope *S,
2203  unsigned TagSpec,
2204  TagUseKind TUK,
2205  const CXXScopeSpec &SS,
2206  IdentifierInfo *Name,
2207  SourceLocation TagLoc,
2208  SourceLocation NameLoc);
2209 
2210  void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
2211  IdentifierInfo *ClassName,
2212  SmallVectorImpl<Decl *> &Decls);
2213  Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
2214  Declarator &D, Expr *BitfieldWidth);
2215 
2216  FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
2217  Declarator &D, Expr *BitfieldWidth,
2218  InClassInitStyle InitStyle,
2219  AccessSpecifier AS);
2220  MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,
2221  SourceLocation DeclStart,
2222  Declarator &D, Expr *BitfieldWidth,
2223  InClassInitStyle InitStyle,
2224  AccessSpecifier AS,
2225  AttributeList *MSPropertyAttr);
2226 
2227  FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
2228  TypeSourceInfo *TInfo,
2229  RecordDecl *Record, SourceLocation Loc,
2230  bool Mutable, Expr *BitfieldWidth,
2231  InClassInitStyle InitStyle,
2232  SourceLocation TSSL,
2233  AccessSpecifier AS, NamedDecl *PrevDecl,
2234  Declarator *D = nullptr);
2235 
2236  bool CheckNontrivialField(FieldDecl *FD);
2237  void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
2238  bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
2239  bool Diagnose = false);
2240  CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD);
2241  void ActOnLastBitfield(SourceLocation DeclStart,
2242  SmallVectorImpl<Decl *> &AllIvarDecls);
2243  Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
2244  Declarator &D, Expr *BitfieldWidth,
2245  tok::ObjCKeywordKind visibility);
2246 
2247  // This is used for both record definitions and ObjC interface declarations.
2248  void ActOnFields(Scope* S, SourceLocation RecLoc, Decl *TagDecl,
2249  ArrayRef<Decl *> Fields,
2250  SourceLocation LBrac, SourceLocation RBrac,
2251  AttributeList *AttrList);
2252 
2253  /// ActOnTagStartDefinition - Invoked when we have entered the
2254  /// scope of a tag's definition (e.g., for an enumeration, class,
2255  /// struct, or union).
2256  void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
2257 
2258  /// Perform ODR-like check for C/ObjC when merging tag types from modules.
2259  /// Differently from C++, actually parse the body and reject / error out
2260  /// in case of a structural mismatch.
2261  bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
2262  SkipBodyInfo &SkipBody);
2263 
2265 
2266  /// \brief Invoked when we enter a tag definition that we're skipping.
2267  SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);
2268 
2269  Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
2270 
2271  /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
2272  /// C++ record definition's base-specifiers clause and are starting its
2273  /// member declarations.
2274  void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
2275  SourceLocation FinalLoc,
2276  bool IsFinalSpelledSealed,
2277  SourceLocation LBraceLoc);
2278 
2279  /// ActOnTagFinishDefinition - Invoked once we have finished parsing
2280  /// the definition of a tag (enumeration, class, struct, or union).
2281  void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
2282  SourceRange BraceRange);
2283 
2284  void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
2285 
2286  void ActOnObjCContainerFinishDefinition();
2287 
2288  /// \brief Invoked when we must temporarily exit the objective-c container
2289  /// scope for parsing/looking-up C constructs.
2290  ///
2291  /// Must be followed by a call to \see ActOnObjCReenterContainerContext
2292  void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
2293  void ActOnObjCReenterContainerContext(DeclContext *DC);
2294 
2295  /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
2296  /// error parsing the definition of a tag.
2297  void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
2298 
2299  EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
2300  EnumConstantDecl *LastEnumConst,
2301  SourceLocation IdLoc,
2302  IdentifierInfo *Id,
2303  Expr *val);
2304  bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
2305  bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
2306  QualType EnumUnderlyingTy,
2307  bool EnumUnderlyingIsImplicit,
2308  const EnumDecl *Prev);
2309 
2310  /// Determine whether the body of an anonymous enumeration should be skipped.
2311  /// \param II The name of the first enumerator.
2312  SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
2313  SourceLocation IILoc);
2314 
2315  Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
2317  AttributeList *Attrs, SourceLocation EqualLoc,
2318  Expr *Val);
2319  void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
2320  Decl *EnumDecl,
2321  ArrayRef<Decl *> Elements,
2322  Scope *S, AttributeList *Attr);
2323 
2324  DeclContext *getContainingDC(DeclContext *DC);
2325 
2326  /// Set the current declaration context until it gets popped.
2327  void PushDeclContext(Scope *S, DeclContext *DC);
2328  void PopDeclContext();
2329 
2330  /// EnterDeclaratorContext - Used when we must lookup names in the context
2331  /// of a declarator's nested name specifier.
2332  void EnterDeclaratorContext(Scope *S, DeclContext *DC);
2333  void ExitDeclaratorContext(Scope *S);
2334 
2335  /// Push the parameters of D, which must be a function, into scope.
2336  void ActOnReenterFunctionContext(Scope* S, Decl* D);
2337  void ActOnExitFunctionContext();
2338 
2339  DeclContext *getFunctionLevelDeclContext();
2340 
2341  /// getCurFunctionDecl - If inside of a function body, this returns a pointer
2342  /// to the function decl for the function being parsed. If we're currently
2343  /// in a 'block', this returns the containing context.
2344  FunctionDecl *getCurFunctionDecl();
2345 
2346  /// getCurMethodDecl - If inside of a method body, this returns a pointer to
2347  /// the method decl for the method being parsed. If we're currently
2348  /// in a 'block', this returns the containing context.
2349  ObjCMethodDecl *getCurMethodDecl();
2350 
2351  /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
2352  /// or C function we're in, otherwise return null. If we're currently
2353  /// in a 'block', this returns the containing context.
2354  NamedDecl *getCurFunctionOrMethodDecl();
2355 
2356  /// Add this decl to the scope shadowed decl chains.
2357  void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
2358 
2359  /// \brief Make the given externally-produced declaration visible at the
2360  /// top level scope.
2361  ///
2362  /// \param D The externally-produced declaration to push.
2363  ///
2364  /// \param Name The name of the externally-produced declaration.
2365  void pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name);
2366 
2367  /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
2368  /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
2369  /// true if 'D' belongs to the given declaration context.
2370  ///
2371  /// \param AllowInlineNamespace If \c true, allow the declaration to be in the
2372  /// enclosing namespace set of the context, rather than contained
2373  /// directly within it.
2374  bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,
2375  bool AllowInlineNamespace = false);
2376 
2377  /// Finds the scope corresponding to the given decl context, if it
2378  /// happens to be an enclosing scope. Otherwise return NULL.
2379  static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
2380 
2381  /// Subroutines of ActOnDeclarator().
2382  TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
2383  TypeSourceInfo *TInfo);
2384  bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
2385 
2386  /// \brief Describes the kind of merge to perform for availability
2387  /// attributes (including "deprecated", "unavailable", and "availability").
2389  /// \brief Don't merge availability attributes at all.
2391  /// \brief Merge availability attributes for a redeclaration, which requires
2392  /// an exact match.
2394  /// \brief Merge availability attributes for an override, which requires
2395  /// an exact match or a weakening of constraints.
2397  /// \brief Merge availability attributes for an implementation of
2398  /// a protocol requirement.
2400  };
2401 
2402  /// Attribute merging methods. Return true if a new attribute was added.
2403  AvailabilityAttr *mergeAvailabilityAttr(NamedDecl *D, SourceRange Range,
2404  IdentifierInfo *Platform,
2405  bool Implicit,
2406  VersionTuple Introduced,
2407  VersionTuple Deprecated,
2408  VersionTuple Obsoleted,
2409  bool IsUnavailable,
2410  StringRef Message,
2411  bool IsStrict, StringRef Replacement,
2413  unsigned AttrSpellingListIndex);
2414  TypeVisibilityAttr *mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2415  TypeVisibilityAttr::VisibilityType Vis,
2416  unsigned AttrSpellingListIndex);
2417  VisibilityAttr *mergeVisibilityAttr(Decl *D, SourceRange Range,
2418  VisibilityAttr::VisibilityType Vis,
2419  unsigned AttrSpellingListIndex);
2420  UuidAttr *mergeUuidAttr(Decl *D, SourceRange Range,
2421  unsigned AttrSpellingListIndex, StringRef Uuid);
2422  DLLImportAttr *mergeDLLImportAttr(Decl *D, SourceRange Range,
2423  unsigned AttrSpellingListIndex);
2424  DLLExportAttr *mergeDLLExportAttr(Decl *D, SourceRange Range,
2425  unsigned AttrSpellingListIndex);
2426  MSInheritanceAttr *
2427  mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
2428  unsigned AttrSpellingListIndex,
2429  MSInheritanceAttr::Spelling SemanticSpelling);
2430  FormatAttr *mergeFormatAttr(Decl *D, SourceRange Range,
2431  IdentifierInfo *Format, int FormatIdx,
2432  int FirstArg, unsigned AttrSpellingListIndex);
2433  SectionAttr *mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name,
2434  unsigned AttrSpellingListIndex);
2435  AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
2436  IdentifierInfo *Ident,
2437  unsigned AttrSpellingListIndex);
2438  MinSizeAttr *mergeMinSizeAttr(Decl *D, SourceRange Range,
2439  unsigned AttrSpellingListIndex);
2440  OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
2441  unsigned AttrSpellingListIndex);
2442  InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, SourceRange Range,
2443  IdentifierInfo *Ident,
2444  unsigned AttrSpellingListIndex);
2445  CommonAttr *mergeCommonAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident,
2446  unsigned AttrSpellingListIndex);
2447 
2448  void mergeDeclAttributes(NamedDecl *New, Decl *Old,
2449  AvailabilityMergeKind AMK = AMK_Redeclaration);
2450  void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
2451  LookupResult &OldDecls);
2452  bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,
2453  bool MergeTypeWithOld);
2454  bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
2455  Scope *S, bool MergeTypeWithOld);
2456  void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
2457  void MergeVarDecl(VarDecl *New, LookupResult &Previous);
2458  void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);
2459  void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
2460  bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);
2461  void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
2462  bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
2463 
2464  // AssignmentAction - This is used by all the assignment diagnostic functions
2465  // to represent what is actually causing the operation
2474  AA_Passing_CFAudited
2475  };
2476 
2477  /// C++ Overloading.
2479  /// This is a legitimate overload: the existing declarations are
2480  /// functions or function templates with different signatures.
2482 
2483  /// This is not an overload because the signature exactly matches
2484  /// an existing declaration.
2486 
2487  /// This is not an overload because the lookup results contain a
2488  /// non-function.
2489  Ovl_NonFunction
2490  };
2491  OverloadKind CheckOverload(Scope *S,
2492  FunctionDecl *New,
2493  const LookupResult &OldDecls,
2494  NamedDecl *&OldDecl,
2495  bool IsForUsingDecl);
2496  bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
2497  bool ConsiderCudaAttrs = true);
2498 
2499  /// \brief Checks availability of the function depending on the current
2500  /// function context.Inside an unavailable function,unavailability is ignored.
2501  ///
2502  /// \returns true if \p FD is unavailable and current context is inside
2503  /// an available function, false otherwise.
2504  bool isFunctionConsideredUnavailable(FunctionDecl *FD);
2505 
2507  TryImplicitConversion(Expr *From, QualType ToType,
2508  bool SuppressUserConversions,
2509  bool AllowExplicit,
2510  bool InOverloadResolution,
2511  bool CStyle,
2512  bool AllowObjCWritebackConversion);
2513 
2514  bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
2515  bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
2516  bool IsComplexPromotion(QualType FromType, QualType ToType);
2517  bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2518  bool InOverloadResolution,
2519  QualType& ConvertedType, bool &IncompatibleObjC);
2520  bool isObjCPointerConversion(QualType FromType, QualType ToType,
2521  QualType& ConvertedType, bool &IncompatibleObjC);
2522  bool isObjCWritebackConversion(QualType FromType, QualType ToType,
2523  QualType &ConvertedType);
2524  bool IsBlockPointerConversion(QualType FromType, QualType ToType,
2525  QualType& ConvertedType);
2526  bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
2527  const FunctionProtoType *NewType,
2528  unsigned *ArgPos = nullptr);
2529  void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
2530  QualType FromType, QualType ToType);
2531 
2532  void maybeExtendBlockObject(ExprResult &E);
2533  CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
2534  bool CheckPointerConversion(Expr *From, QualType ToType,
2535  CastKind &Kind,
2536  CXXCastPath& BasePath,
2537  bool IgnoreBaseAccess,
2538  bool Diagnose = true);
2539  bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
2540  bool InOverloadResolution,
2541  QualType &ConvertedType);
2542  bool CheckMemberPointerConversion(Expr *From, QualType ToType,
2543  CastKind &Kind,
2544  CXXCastPath &BasePath,
2545  bool IgnoreBaseAccess);
2546  bool IsQualificationConversion(QualType FromType, QualType ToType,
2547  bool CStyle, bool &ObjCLifetimeConversion);
2548  bool IsFunctionConversion(QualType FromType, QualType ToType,
2549  QualType &ResultTy);
2550  bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
2551  bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
2552 
2553  ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
2554  const VarDecl *NRVOCandidate,
2555  QualType ResultType,
2556  Expr *Value,
2557  bool AllowNRVO = true);
2558 
2559  bool CanPerformCopyInitialization(const InitializedEntity &Entity,
2560  ExprResult Init);
2561  ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
2562  SourceLocation EqualLoc,
2563  ExprResult Init,
2564  bool TopLevelOfInitList = false,
2565  bool AllowExplicit = false);
2566  ExprResult PerformObjectArgumentInitialization(Expr *From,
2567  NestedNameSpecifier *Qualifier,
2568  NamedDecl *FoundDecl,
2569  CXXMethodDecl *Method);
2570 
2571  ExprResult PerformContextuallyConvertToBool(Expr *From);
2572  ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
2573 
2574  /// Contexts in which a converted constant expression is required.
2575  enum CCEKind {
2576  CCEK_CaseValue, ///< Expression in a case label.
2577  CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
2578  CCEK_TemplateArg, ///< Value of a non-type template parameter.
2579  CCEK_NewExpr, ///< Constant expression in a noptr-new-declarator.
2580  CCEK_ConstexprIf ///< Condition in a constexpr if statement.
2581  };
2583  llvm::APSInt &Value, CCEKind CCE);
2585  APValue &Value, CCEKind CCE);
2586 
2587  /// \brief Abstract base class used to perform a contextual implicit
2588  /// conversion from an expression to any type passing a filter.
2590  public:
2591  bool Suppress;
2593 
2594  ContextualImplicitConverter(bool Suppress = false,
2595  bool SuppressConversion = false)
2596  : Suppress(Suppress), SuppressConversion(SuppressConversion) {}
2597 
2598  /// \brief Determine whether the specified type is a valid destination type
2599  /// for this conversion.
2600  virtual bool match(QualType T) = 0;
2601 
2602  /// \brief Emits a diagnostic complaining that the expression does not have
2603  /// integral or enumeration type.
2604  virtual SemaDiagnosticBuilder
2605  diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;
2606 
2607  /// \brief Emits a diagnostic when the expression has incomplete class type.
2608  virtual SemaDiagnosticBuilder
2609  diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;
2610 
2611  /// \brief Emits a diagnostic when the only matching conversion function
2612  /// is explicit.
2613  virtual SemaDiagnosticBuilder diagnoseExplicitConv(
2614  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
2615 
2616  /// \brief Emits a note for the explicit conversion function.
2617  virtual SemaDiagnosticBuilder
2618  noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
2619 
2620  /// \brief Emits a diagnostic when there are multiple possible conversion
2621  /// functions.
2622  virtual SemaDiagnosticBuilder
2623  diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;
2624 
2625  /// \brief Emits a note for one of the candidate conversions.
2626  virtual SemaDiagnosticBuilder
2627  noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
2628 
2629  /// \brief Emits a diagnostic when we picked a conversion function
2630  /// (for cases when we are not allowed to pick a conversion function).
2631  virtual SemaDiagnosticBuilder diagnoseConversion(
2632  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
2633 
2635  };
2636 
2638  bool AllowScopedEnumerations;
2639 
2640  public:
2641  ICEConvertDiagnoser(bool AllowScopedEnumerations,
2642  bool Suppress, bool SuppressConversion)
2643  : ContextualImplicitConverter(Suppress, SuppressConversion),
2644  AllowScopedEnumerations(AllowScopedEnumerations) {}
2645 
2646  /// Match an integral or (possibly scoped) enumeration type.
2647  bool match(QualType T) override;
2648 
2651  return diagnoseNotInt(S, Loc, T);
2652  }
2653 
2654  /// \brief Emits a diagnostic complaining that the expression does not have
2655  /// integral or enumeration type.
2656  virtual SemaDiagnosticBuilder
2657  diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;
2658  };
2659 
2660  /// Perform a contextual implicit conversion.
2661  ExprResult PerformContextualImplicitConversion(
2662  SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
2663 
2664 
2668  OS_Error
2669  };
2670  ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
2671 
2672  // Note that LK_String is intentionally after the other literals, as
2673  // this is used for diagnostics logic.
2681  LK_None
2682  };
2683  ObjCLiteralKind CheckLiteralKind(Expr *FromE);
2684 
2685  ExprResult PerformObjectMemberConversion(Expr *From,
2686  NestedNameSpecifier *Qualifier,
2687  NamedDecl *FoundDecl,
2688  NamedDecl *Member);
2689 
2690  // Members have to be NamespaceDecl* or TranslationUnitDecl*.
2691  // TODO: make this is a typesafe union.
2694 
2695  void AddOverloadCandidate(FunctionDecl *Function,
2696  DeclAccessPair FoundDecl,
2697  ArrayRef<Expr *> Args,
2698  OverloadCandidateSet &CandidateSet,
2699  bool SuppressUserConversions = false,
2700  bool PartialOverloading = false,
2701  bool AllowExplicit = false,
2702  ConversionSequenceList EarlyConversions = None);
2703  void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
2704  ArrayRef<Expr *> Args,
2705  OverloadCandidateSet &CandidateSet,
2706  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
2707  bool SuppressUserConversions = false,
2708  bool PartialOverloading = false,
2709  bool FirstArgumentIsBase = false);
2710  void AddMethodCandidate(DeclAccessPair FoundDecl,
2711  QualType ObjectType,
2712  Expr::Classification ObjectClassification,
2713  ArrayRef<Expr *> Args,
2714  OverloadCandidateSet& CandidateSet,
2715  bool SuppressUserConversion = false);
2716  void AddMethodCandidate(CXXMethodDecl *Method,
2717  DeclAccessPair FoundDecl,
2718  CXXRecordDecl *ActingContext, QualType ObjectType,
2719  Expr::Classification ObjectClassification,
2720  ArrayRef<Expr *> Args,
2721  OverloadCandidateSet& CandidateSet,
2722  bool SuppressUserConversions = false,
2723  bool PartialOverloading = false,
2724  ConversionSequenceList EarlyConversions = None);
2725  void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
2726  DeclAccessPair FoundDecl,
2727  CXXRecordDecl *ActingContext,
2728  TemplateArgumentListInfo *ExplicitTemplateArgs,
2729  QualType ObjectType,
2730  Expr::Classification ObjectClassification,
2731  ArrayRef<Expr *> Args,
2732  OverloadCandidateSet& CandidateSet,
2733  bool SuppressUserConversions = false,
2734  bool PartialOverloading = false);
2735  void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
2736  DeclAccessPair FoundDecl,
2737  TemplateArgumentListInfo *ExplicitTemplateArgs,
2738  ArrayRef<Expr *> Args,
2739  OverloadCandidateSet& CandidateSet,
2740  bool SuppressUserConversions = false,
2741  bool PartialOverloading = false);
2742  bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate,
2743  ArrayRef<QualType> ParamTypes,
2744  ArrayRef<Expr *> Args,
2745  OverloadCandidateSet &CandidateSet,
2746  ConversionSequenceList &Conversions,
2747  bool SuppressUserConversions,
2748  CXXRecordDecl *ActingContext = nullptr,
2749  QualType ObjectType = QualType(),
2751  ObjectClassification = {});
2752  void AddConversionCandidate(CXXConversionDecl *Conversion,
2753  DeclAccessPair FoundDecl,
2754  CXXRecordDecl *ActingContext,
2755  Expr *From, QualType ToType,
2756  OverloadCandidateSet& CandidateSet,
2757  bool AllowObjCConversionOnExplicit,
2758  bool AllowResultConversion = true);
2759  void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
2760  DeclAccessPair FoundDecl,
2761  CXXRecordDecl *ActingContext,
2762  Expr *From, QualType ToType,
2763  OverloadCandidateSet &CandidateSet,
2764  bool AllowObjCConversionOnExplicit,
2765  bool AllowResultConversion = true);
2766  void AddSurrogateCandidate(CXXConversionDecl *Conversion,
2767  DeclAccessPair FoundDecl,
2768  CXXRecordDecl *ActingContext,
2769  const FunctionProtoType *Proto,
2770  Expr *Object, ArrayRef<Expr *> Args,
2771  OverloadCandidateSet& CandidateSet);
2772  void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
2773  SourceLocation OpLoc, ArrayRef<Expr *> Args,
2774  OverloadCandidateSet& CandidateSet,
2775  SourceRange OpRange = SourceRange());
2776  void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
2777  OverloadCandidateSet& CandidateSet,
2778  bool IsAssignmentOperator = false,
2779  unsigned NumContextualBoolArguments = 0);
2780  void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
2781  SourceLocation OpLoc, ArrayRef<Expr *> Args,
2782  OverloadCandidateSet& CandidateSet);
2783  void AddArgumentDependentLookupCandidates(DeclarationName Name,
2784  SourceLocation Loc,
2785  ArrayRef<Expr *> Args,
2786  TemplateArgumentListInfo *ExplicitTemplateArgs,
2787  OverloadCandidateSet& CandidateSet,
2788  bool PartialOverloading = false);
2789 
2790  // Emit as a 'note' the specific overload candidate
2791  void NoteOverloadCandidate(NamedDecl *Found, FunctionDecl *Fn,
2792  QualType DestType = QualType(),
2793  bool TakingAddress = false);
2794 
2795  // Emit as a series of 'note's all template and non-templates identified by
2796  // the expression Expr
2797  void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
2798  bool TakingAddress = false);
2799 
2800  /// Check the enable_if expressions on the given function. Returns the first
2801  /// failing attribute, or NULL if they were all successful.
2802  EnableIfAttr *CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
2803  bool MissingImplicitThis = false);
2804 
2805  /// Find the failed Boolean condition within a given Boolean
2806  /// constant expression, and describe it with a string.
2807  ///
2808  /// \param AllowTopLevelCond Whether to allow the result to be the
2809  /// complete top-level condition.
2810  std::pair<Expr *, std::string>
2811  findFailedBooleanCondition(Expr *Cond, bool AllowTopLevelCond);
2812 
2813  /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
2814  /// non-ArgDependent DiagnoseIfAttrs.
2815  ///
2816  /// Argument-dependent diagnose_if attributes should be checked each time a
2817  /// function is used as a direct callee of a function call.
2818  ///
2819  /// Returns true if any errors were emitted.
2820  bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
2821  const Expr *ThisArg,
2823  SourceLocation Loc);
2824 
2825  /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
2826  /// ArgDependent DiagnoseIfAttrs.
2827  ///
2828  /// Argument-independent diagnose_if attributes should be checked on every use
2829  /// of a function.
2830  ///
2831  /// Returns true if any errors were emitted.
2832  bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
2833  SourceLocation Loc);
2834 
2835  /// Returns whether the given function's address can be taken or not,
2836  /// optionally emitting a diagnostic if the address can't be taken.
2837  ///
2838  /// Returns false if taking the address of the function is illegal.
2839  bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
2840  bool Complain = false,
2841  SourceLocation Loc = SourceLocation());
2842 
2843  // [PossiblyAFunctionType] --> [Return]
2844  // NonFunctionType --> NonFunctionType
2845  // R (A) --> R(A)
2846  // R (*)(A) --> R (A)
2847  // R (&)(A) --> R (A)
2848  // R (S::*)(A) --> R (A)
2849  QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
2850 
2851  FunctionDecl *
2852  ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
2853  QualType TargetType,
2854  bool Complain,
2855  DeclAccessPair &Found,
2856  bool *pHadMultipleCandidates = nullptr);
2857 
2858  FunctionDecl *
2859  resolveAddressOfOnlyViableOverloadCandidate(Expr *E,
2860  DeclAccessPair &FoundResult);
2861 
2862  bool resolveAndFixAddressOfOnlyViableOverloadCandidate(
2863  ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
2864 
2865  FunctionDecl *
2866  ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
2867  bool Complain = false,
2868  DeclAccessPair *Found = nullptr);
2869 
2870  bool ResolveAndFixSingleFunctionTemplateSpecialization(
2871  ExprResult &SrcExpr,
2872  bool DoFunctionPointerConverion = false,
2873  bool Complain = false,
2874  SourceRange OpRangeForComplaining = SourceRange(),
2875  QualType DestTypeForComplaining = QualType(),
2876  unsigned DiagIDForComplaining = 0);
2877 
2878 
2879  Expr *FixOverloadedFunctionReference(Expr *E,
2880  DeclAccessPair FoundDecl,
2881  FunctionDecl *Fn);
2882  ExprResult FixOverloadedFunctionReference(ExprResult,
2883  DeclAccessPair FoundDecl,
2884  FunctionDecl *Fn);
2885 
2886  void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
2887  ArrayRef<Expr *> Args,
2888  OverloadCandidateSet &CandidateSet,
2889  bool PartialOverloading = false);
2890 
2891  // An enum used to represent the different possible results of building a
2892  // range-based for loop.
2896  FRS_DiagnosticIssued
2897  };
2898 
2899  ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
2900  SourceLocation RangeLoc,
2901  const DeclarationNameInfo &NameInfo,
2902  LookupResult &MemberLookup,
2903  OverloadCandidateSet *CandidateSet,
2904  Expr *Range, ExprResult *CallExpr);
2905 
2906  ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
2907  UnresolvedLookupExpr *ULE,
2908  SourceLocation LParenLoc,
2909  MultiExprArg Args,
2910  SourceLocation RParenLoc,
2911  Expr *ExecConfig,
2912  bool AllowTypoCorrection=true,
2913  bool CalleesAddressIsTaken=false);
2914 
2915  bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
2916  MultiExprArg Args, SourceLocation RParenLoc,
2917  OverloadCandidateSet *CandidateSet,
2918  ExprResult *Result);
2919 
2920  ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
2921  UnaryOperatorKind Opc,
2922  const UnresolvedSetImpl &Fns,
2923  Expr *input, bool RequiresADL = true);
2924 
2925  ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
2926  BinaryOperatorKind Opc,
2927  const UnresolvedSetImpl &Fns,
2928  Expr *LHS, Expr *RHS,
2929  bool RequiresADL = true);
2930 
2931  ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
2932  SourceLocation RLoc,
2933  Expr *Base,Expr *Idx);
2934 
2935  ExprResult
2936  BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
2937  SourceLocation LParenLoc,
2938  MultiExprArg Args,
2939  SourceLocation RParenLoc);
2940  ExprResult
2941  BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
2942  MultiExprArg Args,
2943  SourceLocation RParenLoc);
2944 
2945  ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
2946  SourceLocation OpLoc,
2947  bool *NoArrowOperatorFound = nullptr);
2948 
2949  /// CheckCallReturnType - Checks that a call expression's return type is
2950  /// complete. Returns true on failure. The location passed in is the location
2951  /// that best represents the call.
2952  bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
2953  CallExpr *CE, FunctionDecl *FD);
2954 
2955  /// Helpers for dealing with blocks and functions.
2956  bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
2957  bool CheckParameterNames);
2958  void CheckCXXDefaultArguments(FunctionDecl *FD);
2959  void CheckExtraCXXDefaultArguments(Declarator &D);
2960  Scope *getNonFieldDeclScope(Scope *S);
2961 
2962  /// \name Name lookup
2963  ///
2964  /// These routines provide name lookup that is used during semantic
2965  /// analysis to resolve the various kinds of names (identifiers,
2966  /// overloaded operator names, constructor names, etc.) into zero or
2967  /// more declarations within a particular scope. The major entry
2968  /// points are LookupName, which performs unqualified name lookup,
2969  /// and LookupQualifiedName, which performs qualified name lookup.
2970  ///
2971  /// All name lookup is performed based on some specific criteria,
2972  /// which specify what names will be visible to name lookup and how
2973  /// far name lookup should work. These criteria are important both
2974  /// for capturing language semantics (certain lookups will ignore
2975  /// certain names, for example) and for performance, since name
2976  /// lookup is often a bottleneck in the compilation of C++. Name
2977  /// lookup criteria is specified via the LookupCriteria enumeration.
2978  ///
2979  /// The results of name lookup can vary based on the kind of name
2980  /// lookup performed, the current language, and the translation
2981  /// unit. In C, for example, name lookup will either return nothing
2982  /// (no entity found) or a single declaration. In C++, name lookup
2983  /// can additionally refer to a set of overloaded functions or
2984  /// result in an ambiguity. All of the possible results of name
2985  /// lookup are captured by the LookupResult class, which provides
2986  /// the ability to distinguish among them.
2987  //@{
2988 
2989  /// @brief Describes the kind of name lookup to perform.
2991  /// Ordinary name lookup, which finds ordinary names (functions,
2992  /// variables, typedefs, etc.) in C and most kinds of names
2993  /// (functions, variables, members, types, etc.) in C++.
2994  LookupOrdinaryName = 0,
2995  /// Tag name lookup, which finds the names of enums, classes,
2996  /// structs, and unions.
2998  /// Label name lookup.
3000  /// Member name lookup, which finds the names of
3001  /// class/struct/union members.
3003  /// Look up of an operator name (e.g., operator+) for use with
3004  /// operator overloading. This lookup is similar to ordinary name
3005  /// lookup, but will ignore any declarations that are class members.
3007  /// Look up of a name that precedes the '::' scope resolution
3008  /// operator in C++. This lookup completely ignores operator, object,
3009  /// function, and enumerator names (C++ [basic.lookup.qual]p1).
3011  /// Look up a namespace name within a C++ using directive or
3012  /// namespace alias definition, ignoring non-namespace names (C++
3013  /// [basic.lookup.udir]p1).
3015  /// Look up all declarations in a scope with the given name,
3016  /// including resolved using declarations. This is appropriate
3017  /// for checking redeclarations for a using declaration.
3019  /// Look up an ordinary name that is going to be redeclared as a
3020  /// name with linkage. This lookup ignores any declarations that
3021  /// are outside of the current scope unless they have linkage. See
3022  /// C99 6.2.2p4-5 and C++ [basic.link]p6.
3024  /// Look up a friend of a local class. This lookup does not look
3025  /// outside the innermost non-class scope. See C++11 [class.friend]p11.
3027  /// Look up the name of an Objective-C protocol.
3029  /// Look up implicit 'self' parameter of an objective-c method.
3031  /// \brief Look up the name of an OpenMP user-defined reduction operation.
3033  /// \brief Look up any declaration with any name.
3034  LookupAnyName
3035  };
3036 
3037  /// \brief Specifies whether (or how) name lookup is being performed for a
3038  /// redeclaration (vs. a reference).
3040  /// \brief The lookup is a reference to this name that is not for the
3041  /// purpose of redeclaring the name.
3042  NotForRedeclaration = 0,
3043  /// \brief The lookup results will be used for redeclaration of a name,
3044  /// if an entity by that name already exists and is visible.
3046  /// \brief The lookup results will be used for redeclaration of a name
3047  /// with external linkage; non-visible lookup results with external linkage
3048  /// may also be found.
3049  ForExternalRedeclaration
3050  };
3051 
3053  // A declaration with an owning module for linkage can never link against
3054  // anything that is not visible. We don't need to check linkage here; if
3055  // the context has internal linkage, redeclaration lookup won't find things
3056  // from other TUs, and we can't safely compute linkage yet in general.
3057  if (cast<Decl>(CurContext)
3058  ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
3059  return ForVisibleRedeclaration;
3060  return ForExternalRedeclaration;
3061  }
3062 
3063  /// \brief The possible outcomes of name lookup for a literal operator.
3065  /// \brief The lookup resulted in an error.
3067  /// \brief The lookup found no match but no diagnostic was issued.
3069  /// \brief The lookup found a single 'cooked' literal operator, which
3070  /// expects a normal literal to be built and passed to it.
3072  /// \brief The lookup found a single 'raw' literal operator, which expects
3073  /// a string literal containing the spelling of the literal token.
3075  /// \brief The lookup found an overload set of literal operator templates,
3076  /// which expect the characters of the spelling of the literal token to be
3077  /// passed as a non-type template argument pack.
3079  /// \brief The lookup found an overload set of literal operator templates,
3080  /// which expect the character type and characters of the spelling of the
3081  /// string literal token to be passed as template arguments.
3082  LOLR_StringTemplate
3083  };
3084 
3085  SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
3087  bool ConstArg,
3088  bool VolatileArg,
3089  bool RValueThis,
3090  bool ConstThis,
3091  bool VolatileThis);
3092 
3093  typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
3094  typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
3096 
3097 private:
3098  bool CppLookupName(LookupResult &R, Scope *S);
3099 
3100  struct TypoExprState {
3101  std::unique_ptr<TypoCorrectionConsumer> Consumer;
3102  TypoDiagnosticGenerator DiagHandler;
3103  TypoRecoveryCallback RecoveryHandler;
3104  TypoExprState();
3105  TypoExprState(TypoExprState &&other) noexcept;
3106  TypoExprState &operator=(TypoExprState &&other) noexcept;
3107  };
3108 
3109  /// \brief The set of unhandled TypoExprs and their associated state.
3110  llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
3111 
3112  /// \brief Creates a new TypoExpr AST node.
3113  TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
3114  TypoDiagnosticGenerator TDG,
3115  TypoRecoveryCallback TRC);
3116 
3117  // \brief The set of known/encountered (unique, canonicalized) NamespaceDecls.
3118  //
3119  // The boolean value will be true to indicate that the namespace was loaded
3120  // from an AST/PCH file, or false otherwise.
3121  llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
3122 
3123  /// \brief Whether we have already loaded known namespaces from an extenal
3124  /// source.
3125  bool LoadedExternalKnownNamespaces;
3126 
3127  /// \brief Helper for CorrectTypo and CorrectTypoDelayed used to create and
3128  /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
3129  /// should be skipped entirely.
3130  std::unique_ptr<TypoCorrectionConsumer>
3131  makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
3132  Sema::LookupNameKind LookupKind, Scope *S,
3133  CXXScopeSpec *SS,
3134  std::unique_ptr<CorrectionCandidateCallback> CCC,
3135  DeclContext *MemberContext, bool EnteringContext,
3136  const ObjCObjectPointerType *OPT,
3137  bool ErrorRecovery);
3138 
3139 public:
3140  const TypoExprState &getTypoExprState(TypoExpr *TE) const;
3141 
3142  /// \brief Clears the state of the given TypoExpr.
3143  void clearDelayedTypo(TypoExpr *TE);
3144 
3145  /// \brief Look up a name, looking for a single declaration. Return
3146  /// null if the results were absent, ambiguous, or overloaded.
3147  ///
3148  /// It is preferable to use the elaborated form and explicitly handle
3149  /// ambiguity and overloaded.
3150  NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
3151  SourceLocation Loc,
3152  LookupNameKind NameKind,
3153  RedeclarationKind Redecl
3154  = NotForRedeclaration);
3155  bool LookupName(LookupResult &R, Scope *S,
3156  bool AllowBuiltinCreation = false);
3157  bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
3158  bool InUnqualifiedLookup = false);
3159  bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
3160  CXXScopeSpec &SS);
3161  bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
3162  bool AllowBuiltinCreation = false,
3163  bool EnteringContext = false);
3164  ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
3165  RedeclarationKind Redecl
3166  = NotForRedeclaration);
3167  bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
3168 
3169  void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
3170  QualType T1, QualType T2,
3171  UnresolvedSetImpl &Functions);
3172 
3173  LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
3174  SourceLocation GnuLabelLoc = SourceLocation());
3175 
3176  DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
3177  CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
3178  CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
3179  unsigned Quals);
3180  CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
3181  bool RValueThis, unsigned ThisQuals);
3182  CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
3183  unsigned Quals);
3184  CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
3185  bool RValueThis, unsigned ThisQuals);
3186  CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
3187 
3188  bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);
3189  LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R,
3190  ArrayRef<QualType> ArgTys,
3191  bool AllowRaw,
3192  bool AllowTemplate,
3193  bool AllowStringTemplate,
3194  bool DiagnoseMissing);
3195  bool isKnownName(StringRef name);
3196 
3197  void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
3198  ArrayRef<Expr *> Args, ADLResult &Functions);
3199 
3200  void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
3201  VisibleDeclConsumer &Consumer,
3202  bool IncludeGlobalScope = true);
3204  VisibleDeclConsumer &Consumer,
3205  bool IncludeGlobalScope = true,
3206  bool IncludeDependentBases = false);
3207 
3209  CTK_NonError, // CorrectTypo used in a non error recovery situation.
3210  CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
3211  };
3212 
3213  TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
3214  Sema::LookupNameKind LookupKind,
3215  Scope *S, CXXScopeSpec *SS,
3216  std::unique_ptr<CorrectionCandidateCallback> CCC,
3217  CorrectTypoKind Mode,
3218  DeclContext *MemberContext = nullptr,
3219  bool EnteringContext = false,
3220  const ObjCObjectPointerType *OPT = nullptr,
3221  bool RecordFailure = true);
3222 
3223  TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,
3224  Sema::LookupNameKind LookupKind, Scope *S,
3225  CXXScopeSpec *SS,
3226  std::unique_ptr<CorrectionCandidateCallback> CCC,
3227  TypoDiagnosticGenerator TDG,
3229  DeclContext *MemberContext = nullptr,
3230  bool EnteringContext = false,
3231  const ObjCObjectPointerType *OPT = nullptr);
3232 
3233  /// \brief Process any TypoExprs in the given Expr and its children,
3234  /// generating diagnostics as appropriate and returning a new Expr if there
3235  /// were typos that were all successfully corrected and ExprError if one or
3236  /// more typos could not be corrected.
3237  ///
3238  /// \param E The Expr to check for TypoExprs.
3239  ///
3240  /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
3241  /// initializer.
3242  ///
3243  /// \param Filter A function applied to a newly rebuilt Expr to determine if
3244  /// it is an acceptable/usable result from a single combination of typo
3245  /// corrections. As long as the filter returns ExprError, different
3246  /// combinations of corrections will be tried until all are exhausted.
3247  ExprResult
3248  CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl = nullptr,
3249  llvm::function_ref<ExprResult(Expr *)> Filter =
3250  [](Expr *E) -> ExprResult { return E; });
3251 
3252  ExprResult
3254  llvm::function_ref<ExprResult(Expr *)> Filter) {
3255  return CorrectDelayedTyposInExpr(E, nullptr, Filter);
3256  }
3257 
3258  ExprResult
3259  CorrectDelayedTyposInExpr(ExprResult ER, VarDecl *InitDecl = nullptr,
3260  llvm::function_ref<ExprResult(Expr *)> Filter =
3261  [](Expr *E) -> ExprResult { return E; }) {
3262  return ER.isInvalid() ? ER : CorrectDelayedTyposInExpr(ER.get(), Filter);
3263  }
3264 
3265  ExprResult
3267  llvm::function_ref<ExprResult(Expr *)> Filter) {
3268  return CorrectDelayedTyposInExpr(ER, nullptr, Filter);
3269  }
3270 
3271  void diagnoseTypo(const TypoCorrection &Correction,
3272  const PartialDiagnostic &TypoDiag,
3273  bool ErrorRecovery = true);
3274 
3275  void diagnoseTypo(const TypoCorrection &Correction,
3276  const PartialDiagnostic &TypoDiag,
3277  const PartialDiagnostic &PrevNote,
3278  bool ErrorRecovery = true);
3279 
3280  void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
3281 
3282  void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
3283  ArrayRef<Expr *> Args,
3284  AssociatedNamespaceSet &AssociatedNamespaces,
3285  AssociatedClassSet &AssociatedClasses);
3286 
3287  void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
3288  bool ConsiderLinkage, bool AllowInlineNamespace);
3289 
3290  bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);
3291 
3292  void DiagnoseAmbiguousLookup(LookupResult &Result);
3293  //@}
3294 
3295  ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
3296  SourceLocation IdLoc,
3297  bool TypoCorrection = false);
3298  NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
3299  Scope *S, bool ForRedeclaration,
3300  SourceLocation Loc);
3301  NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
3302  Scope *S);
3303  void AddKnownFunctionAttributes(FunctionDecl *FD);
3304 
3305  // More parsing and symbol table subroutines.
3306 
3307  void ProcessPragmaWeak(Scope *S, Decl *D);
3308  // Decl attributes - this routine is the top level dispatcher.
3309  void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
3310  // Helper for delayed processing of attributes.
3311  void ProcessDeclAttributeDelayed(Decl *D, const AttributeList *AttrList);
3312  void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL,
3313  bool IncludeCXX11Attributes = true);
3314  bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
3315  const AttributeList *AttrList);
3316 
3318 
3319  /// Determine if type T is a valid subject for a nonnull and similar
3320  /// attributes. By default, we look through references (the behavior used by
3321  /// nonnull), but if the second parameter is true, then we treat a reference
3322  /// type as valid.
3323  bool isValidPointerAttrType(QualType T, bool RefOkay = false);
3324 
3325  bool CheckRegparmAttr(const AttributeList &attr, unsigned &value);
3326  bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
3327  const FunctionDecl *FD = nullptr);
3328  bool CheckNoReturnAttr(const AttributeList &attr);
3329  bool CheckNoCallerSavedRegsAttr(const AttributeList &attr);
3330  bool checkStringLiteralArgumentAttr(const AttributeList &Attr,
3331  unsigned ArgNum, StringRef &Str,
3332  SourceLocation *ArgLocation = nullptr);
3333  bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
3334  bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
3335  bool checkMSInheritanceAttrOnDefinition(
3336  CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3337  MSInheritanceAttr::Spelling SemanticSpelling);
3338 
3339  void CheckAlignasUnderalignment(Decl *D);
3340 
3341  /// Adjust the calling convention of a method to be the ABI default if it
3342  /// wasn't specified explicitly. This handles method types formed from
3343  /// function type typedefs and typename template arguments.
3344  void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
3345  SourceLocation Loc);
3346 
3347  // Check if there is an explicit attribute, but only look through parens.
3348  // The intent is to look for an attribute on the current declarator, but not
3349  // one that came from a typedef.
3350  bool hasExplicitCallingConv(QualType &T);
3351 
3352  /// Get the outermost AttributedType node that sets a calling convention.
3353  /// Valid types should not have multiple attributes with different CCs.
3354  const AttributedType *getCallingConvAttributedType(QualType T) const;
3355 
3356  /// Check whether a nullability type specifier can be added to the given
3357  /// type.
3358  ///
3359  /// \param type The type to which the nullability specifier will be
3360  /// added. On success, this type will be updated appropriately.
3361  ///
3362  /// \param nullability The nullability specifier to add.
3363  ///
3364  /// \param nullabilityLoc The location of the nullability specifier.
3365  ///
3366  /// \param isContextSensitive Whether this nullability specifier was
3367  /// written as a context-sensitive keyword (in an Objective-C
3368  /// method) or an Objective-C property attribute, rather than as an
3369  /// underscored type specifier.
3370  ///
3371  /// \param allowArrayTypes Whether to accept nullability specifiers on an
3372  /// array type (e.g., because it will decay to a pointer).
3373  ///
3374  /// \returns true if nullability cannot be applied, false otherwise.
3375  bool checkNullabilityTypeSpecifier(QualType &type, NullabilityKind nullability,
3376  SourceLocation nullabilityLoc,
3377  bool isContextSensitive,
3378  bool allowArrayTypes);
3379 
3380  /// \brief Stmt attributes - this routine is the top level dispatcher.
3381  StmtResult ProcessStmtAttributes(Stmt *Stmt, AttributeList *Attrs,
3382  SourceRange Range);
3383 
3384  void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
3385  ObjCMethodDecl *MethodDecl,
3386  bool IsProtocolMethodDecl);
3387 
3388  void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
3389  ObjCMethodDecl *Overridden,
3390  bool IsProtocolMethodDecl);
3391 
3392  /// WarnExactTypedMethods - This routine issues a warning if method
3393  /// implementation declaration matches exactly that of its declaration.
3394  void WarnExactTypedMethods(ObjCMethodDecl *Method,
3395  ObjCMethodDecl *MethodDecl,
3396  bool IsProtocolMethodDecl);
3397 
3398  typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;
3399 
3400  /// CheckImplementationIvars - This routine checks if the instance variables
3401  /// listed in the implelementation match those listed in the interface.
3402  void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
3403  ObjCIvarDecl **Fields, unsigned nIvars,
3404  SourceLocation Loc);
3405 
3406  /// ImplMethodsVsClassMethods - This is main routine to warn if any method
3407  /// remains unimplemented in the class or category \@implementation.
3408  void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
3409  ObjCContainerDecl* IDecl,
3410  bool IncompleteImpl = false);
3411 
3412  /// DiagnoseUnimplementedProperties - This routine warns on those properties
3413  /// which must be implemented by this implementation.
3414  void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
3415  ObjCContainerDecl *CDecl,
3416  bool SynthesizeProperties);
3417 
3418  /// Diagnose any null-resettable synthesized setters.
3419  void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);
3420 
3421  /// DefaultSynthesizeProperties - This routine default synthesizes all
3422  /// properties which must be synthesized in the class's \@implementation.
3423  void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,
3424  ObjCInterfaceDecl *IDecl,
3425  SourceLocation AtEnd);
3426  void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);
3427 
3428  /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
3429  /// an ivar synthesized for 'Method' and 'Method' is a property accessor
3430  /// declared in class 'IFace'.
3431  bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
3432  ObjCMethodDecl *Method, ObjCIvarDecl *IV);
3433 
3434  /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which
3435  /// backs the property is not used in the property's accessor.
3436  void DiagnoseUnusedBackingIvarInAccessor(Scope *S,
3437  const ObjCImplementationDecl *ImplD);
3438 
3439  /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and
3440  /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
3441  /// It also returns ivar's property on success.
3442  ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
3443  const ObjCPropertyDecl *&PDecl) const;
3444 
3445  /// Called by ActOnProperty to handle \@property declarations in
3446  /// class extensions.
3447  ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,
3448  SourceLocation AtLoc,
3449  SourceLocation LParenLoc,
3450  FieldDeclarator &FD,
3451  Selector GetterSel,
3452  SourceLocation GetterNameLoc,
3453  Selector SetterSel,
3454  SourceLocation SetterNameLoc,
3455  const bool isReadWrite,
3456  unsigned &Attributes,
3457  const unsigned AttributesAsWritten,
3458  QualType T,
3459  TypeSourceInfo *TSI,
3460  tok::ObjCKeywordKind MethodImplKind);
3461 
3462  /// Called by ActOnProperty and HandlePropertyInClassExtension to
3463  /// handle creating the ObjcPropertyDecl for a category or \@interface.
3464  ObjCPropertyDecl *CreatePropertyDecl(Scope *S,
3465  ObjCContainerDecl *CDecl,
3466  SourceLocation AtLoc,
3467  SourceLocation LParenLoc,
3468  FieldDeclarator &FD,
3469  Selector GetterSel,
3470  SourceLocation GetterNameLoc,
3471  Selector SetterSel,
3472  SourceLocation SetterNameLoc,
3473  const bool isReadWrite,
3474  const unsigned Attributes,
3475  const unsigned AttributesAsWritten,
3476  QualType T,
3477  TypeSourceInfo *TSI,
3478  tok::ObjCKeywordKind MethodImplKind,
3479  DeclContext *lexicalDC = nullptr);
3480 
3481  /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
3482  /// warning) when atomic property has one but not the other user-declared
3483  /// setter or getter.
3484  void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
3485  ObjCInterfaceDecl* IDecl);
3486 
3487  void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
3488 
3489  void DiagnoseMissingDesignatedInitOverrides(
3490  const ObjCImplementationDecl *ImplD,
3491  const ObjCInterfaceDecl *IFD);
3492 
3493  void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);
3494 
3497  MMS_strict
3498  };
3499 
3500  /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
3501  /// true, or false, accordingly.
3502  bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
3503  const ObjCMethodDecl *PrevMethod,
3504  MethodMatchStrategy strategy = MMS_strict);
3505 
3506  /// MatchAllMethodDeclarations - Check methods declaraed in interface or
3507  /// or protocol against those declared in their implementations.
3508  void MatchAllMethodDeclarations(const SelectorSet &InsMap,
3509  const SelectorSet &ClsMap,
3510  SelectorSet &InsMapSeen,
3511  SelectorSet &ClsMapSeen,
3512  ObjCImplDecl* IMPDecl,
3513  ObjCContainerDecl* IDecl,
3514  bool &IncompleteImpl,
3515  bool ImmediateClass,
3516  bool WarnCategoryMethodImpl=false);
3517 
3518  /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
3519  /// category matches with those implemented in its primary class and
3520  /// warns each time an exact match is found.
3521  void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
3522 
3523  /// \brief Add the given method to the list of globally-known methods.
3524  void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);
3525 
3526 private:
3527  /// AddMethodToGlobalPool - Add an instance or factory method to the global
3528  /// pool. See descriptoin of AddInstanceMethodToGlobalPool.
3529  void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);
3530 
3531  /// LookupMethodInGlobalPool - Returns the instance or factory method and
3532  /// optionally warns if there are multiple signatures.
3533  ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
3534  bool receiverIdOrClass,
3535  bool instance);
3536 
3537 public:
3538  /// \brief - Returns instance or factory methods in global method pool for
3539  /// given selector. It checks the desired kind first, if none is found, and
3540  /// parameter checkTheOther is set, it then checks the other kind. If no such
3541  /// method or only one method is found, function returns false; otherwise, it
3542  /// returns true.
3543  bool
3544  CollectMultipleMethodsInGlobalPool(Selector Sel,
3546  bool InstanceFirst, bool CheckTheOther,
3547  const ObjCObjectType *TypeBound = nullptr);
3548 
3549  bool
3550  AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,
3551  SourceRange R, bool receiverIdOrClass,
3553 
3554  void
3555  DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
3556  Selector Sel, SourceRange R,
3557  bool receiverIdOrClass);
3558 
3559 private:
3560  /// \brief - Returns a selector which best matches given argument list or
3561  /// nullptr if none could be found
3562  ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,
3563  bool IsInstance,
3565 
3566 
3567  /// \brief Record the typo correction failure and return an empty correction.
3568  TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,
3569  bool RecordFailure = true) {
3570  if (RecordFailure)
3571  TypoCorrectionFailures[Typo].insert(TypoLoc);
3572  return TypoCorrection();
3573  }
3574 
3575 public:
3576  /// AddInstanceMethodToGlobalPool - All instance methods in a translation
3577  /// unit are added to a global pool. This allows us to efficiently associate
3578  /// a selector with a method declaraation for purposes of typechecking
3579  /// messages sent to "id" (where the class of the object is unknown).
3580  void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
3581  AddMethodToGlobalPool(Method, impl, /*instance*/true);
3582  }
3583 
3584  /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
3585  void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
3586  AddMethodToGlobalPool(Method, impl, /*instance*/false);
3587  }
3588 
3589  /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
3590  /// pool.
3591  void AddAnyMethodToGlobalPool(Decl *D);
3592 
3593  /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
3594  /// there are multiple signatures.
3596  bool receiverIdOrClass=false) {
3597  return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
3598  /*instance*/true);
3599  }
3600 
3601  /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
3602  /// there are multiple signatures.
3604  bool receiverIdOrClass=false) {
3605  return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
3606  /*instance*/false);
3607  }
3608 
3609  const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,
3610  QualType ObjectType=QualType());
3611  /// LookupImplementedMethodInGlobalPool - Returns the method which has an
3612  /// implementation.
3613  ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
3614 
3615  /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
3616  /// initialization.
3617  void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
3619 
3620  //===--------------------------------------------------------------------===//
3621  // Statement Parsing Callbacks: SemaStmt.cpp.
3622 public:
3623  class FullExprArg {
3624  public:
3625  FullExprArg() : E(nullptr) { }
3626  FullExprArg(Sema &actions) : E(nullptr) { }
3627 
3629  return E;
3630  }
3631 
3632  Expr *get() const { return E; }
3633 
3635  return E;
3636  }
3637 
3638  private:
3639  // FIXME: No need to make the entire Sema class a friend when it's just
3640  // Sema::MakeFullExpr that needs access to the constructor below.
3641  friend class Sema;
3642 
3643  explicit FullExprArg(Expr *expr) : E(expr) {}
3644 
3645  Expr *E;
3646  };
3647 
3649  return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());
3650  }
3652  return FullExprArg(ActOnFinishFullExpr(Arg, CC).get());
3653  }
3655  ExprResult FE =
3656  ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),
3657  /*DiscardedValue*/ true);
3658  return FullExprArg(FE.get());
3659  }
3660 
3661  StmtResult ActOnExprStmt(ExprResult Arg);
3662  StmtResult ActOnExprStmtError();
3663 
3664  StmtResult ActOnNullStmt(SourceLocation SemiLoc,
3665  bool HasLeadingEmptyMacro = false);
3666 
3667  void ActOnStartOfCompoundStmt();
3668  void ActOnFinishOfCompoundStmt();
3669  StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
3670  ArrayRef<Stmt *> Elts, bool isStmtExpr);
3671 
3672  /// \brief A RAII object to enter scope of a compound statement.
3674  public:
3677  }
3678 
3680  S.ActOnFinishOfCompoundStmt();
3681  }
3682 
3683  private:
3684  Sema &S;
3685  };
3686 
3687  /// An RAII helper that pops function a function scope on exit.
3690  bool Active;
3691  FunctionScopeRAII(Sema &S) : S(S), Active(true) {}
3693  if (Active)
3695  }
3696  void disable() { Active = false; }
3697  };
3698 
3699  StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
3700  SourceLocation StartLoc,
3701  SourceLocation EndLoc);
3702  void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
3703  StmtResult ActOnForEachLValueExpr(Expr *E);
3704  StmtResult ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
3705  SourceLocation DotDotDotLoc, Expr *RHSVal,
3707  void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
3708 
3709  StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
3710  SourceLocation ColonLoc,
3711  Stmt *SubStmt, Scope *CurScope);
3712  StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
3713  SourceLocation ColonLoc, Stmt *SubStmt);
3714 
3715  StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,
3716  ArrayRef<const Attr*> Attrs,
3717  Stmt *SubStmt);
3718 
3719  class ConditionResult;
3720  StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
3721  Stmt *InitStmt,
3722  ConditionResult Cond, Stmt *ThenVal,
3723  SourceLocation ElseLoc, Stmt *ElseVal);
3724  StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
3725  Stmt *InitStmt,
3726  ConditionResult Cond, Stmt *ThenVal,
3727  SourceLocation ElseLoc, Stmt *ElseVal);
3728  StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
3729  Stmt *InitStmt,
3730  ConditionResult Cond);
3731  StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
3732  Stmt *Switch, Stmt *Body);
3733  StmtResult ActOnWhileStmt(SourceLocation WhileLoc, ConditionResult Cond,
3734  Stmt *Body);
3735  StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
3736  SourceLocation WhileLoc, SourceLocation CondLParen,
3737  Expr *Cond, SourceLocation CondRParen);
3738 
3739  StmtResult ActOnForStmt(SourceLocation ForLoc,
3740  SourceLocation LParenLoc,
3741  Stmt *First,
3742  ConditionResult Second,
3743  FullExprArg Third,
3744  SourceLocation RParenLoc,
3745  Stmt *Body);
3746  ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
3747  Expr *collection);
3748  StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
3749  Stmt *First, Expr *collection,
3750  SourceLocation RParenLoc);
3751  StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
3752 
3754  /// Initial building of a for-range statement.
3756  /// Instantiation or recovery rebuild of a for-range statement. Don't
3757  /// attempt any typo-correction.
3759  /// Determining whether a for-range statement could be built. Avoid any
3760  /// unnecessary or irreversible actions.
3761  BFRK_Check
3762  };
3763 
3764  StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
3765  SourceLocation CoawaitLoc,
3766  Stmt *LoopVar,
3767  SourceLocation ColonLoc, Expr *Collection,
3768  SourceLocation RParenLoc,
3770  StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
3771  SourceLocation CoawaitLoc,
3772  SourceLocation ColonLoc,
3773  Stmt *RangeDecl, Stmt *Begin, Stmt *End,
3774  Expr *Cond, Expr *Inc,
3775  Stmt *LoopVarDecl,
3776  SourceLocation RParenLoc,
3778  StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
3779 
3780  StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
3781  SourceLocation LabelLoc,
3782  LabelDecl *TheDecl);
3783  StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
3784  SourceLocation StarLoc,
3785  Expr *DestExp);
3786  StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
3787  StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
3788 
3789  void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
3790  CapturedRegionKind Kind, unsigned NumParams);
3791  typedef std::pair<StringRef, QualType> CapturedParamNameType;
3792  void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
3795  StmtResult ActOnCapturedRegionEnd(Stmt *S);
3796  void ActOnCapturedRegionError();
3797  RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
3798  SourceLocation Loc,
3799  unsigned NumParams);
3800  VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,
3801  bool AllowParamOrMoveConstructible);
3802  bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,
3803  bool AllowParamOrMoveConstructible);
3804 
3805  StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
3806  Scope *CurScope);
3807  StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
3808  StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
3809 
3810  StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
3811  bool IsVolatile, unsigned NumOutputs,
3812  unsigned NumInputs, IdentifierInfo **Names,
3813  MultiExprArg Constraints, MultiExprArg Exprs,
3814  Expr *AsmString, MultiExprArg Clobbers,
3815  SourceLocation RParenLoc);
3816 
3817  void FillInlineAsmIdentifierInfo(Expr *Res,
3818  llvm::InlineAsmIdentifierInfo &Info);
3819  ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
3820  SourceLocation TemplateKWLoc,
3821  UnqualifiedId &Id,
3822  bool IsUnevaluatedContext);
3823  bool LookupInlineAsmField(StringRef Base, StringRef Member,
3824  unsigned &Offset, SourceLocation AsmLoc);
3825  ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
3826  SourceLocation AsmLoc);
3827  StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
3828  ArrayRef<Token> AsmToks,
3829  StringRef AsmString,
3830  unsigned NumOutputs, unsigned NumInputs,
3831  ArrayRef<StringRef> Constraints,
3832  ArrayRef<StringRef> Clobbers,
3833  ArrayRef<Expr*> Exprs,
3834  SourceLocation EndLoc);
3835  LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
3836  SourceLocation Location,
3837  bool AlwaysCreate);
3838 
3839  VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
3840  SourceLocation StartLoc,
3841  SourceLocation IdLoc, IdentifierInfo *Id,
3842  bool Invalid = false);
3843 
3844  Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
3845 
3846  StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
3847  Decl *Parm, Stmt *Body);
3848 
3849  StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
3850 
3851  StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
3852  MultiStmtArg Catch, Stmt *Finally);
3853 
3854  StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
3855  StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
3856  Scope *CurScope);
3857  ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
3858  Expr *operand);
3859  StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
3860  Expr *SynchExpr,
3861  Stmt *SynchBody);
3862 
3863  StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
3864 
3865  VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
3866  SourceLocation StartLoc,
3867  SourceLocation IdLoc,
3868  IdentifierInfo *Id);
3869 
3870  Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
3871 
3872  StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
3873  Decl *ExDecl, Stmt *HandlerBlock);
3874  StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
3875  ArrayRef<Stmt *> Handlers);
3876 
3877  StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
3878  SourceLocation TryLoc, Stmt *TryBlock,
3879  Stmt *Handler);
3880  StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
3881  Expr *FilterExpr,
3882  Stmt *Block);
3883  void ActOnStartSEHFinallyBlock();
3884  void ActOnAbortSEHFinallyBlock();
3885  StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
3886  StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
3887 
3888  void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
3889 
3890  bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
3891 
3892  /// \brief If it's a file scoped decl that must warn if not used, keep track
3893  /// of it.
3894  void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
3895 
3896  /// DiagnoseUnusedExprResult - If the statement passed in is an expression
3897  /// whose result is unused, warn.
3898  void DiagnoseUnusedExprResult(const Stmt *S);
3899  void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
3900  void DiagnoseUnusedDecl(const NamedDecl *ND);
3901 
3902  /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
3903  /// statement as a \p Body, and it is located on the same line.
3904  ///
3905  /// This helps prevent bugs due to typos, such as:
3906  /// if (condition);
3907  /// do_stuff();
3908  void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
3909  const Stmt *Body,
3910  unsigned DiagID);
3911 
3912  /// Warn if a for/while loop statement \p S, which is followed by
3913  /// \p PossibleBody, has a suspicious null statement as a body.
3914  void DiagnoseEmptyLoopBody(const Stmt *S,
3915  const Stmt *PossibleBody);
3916 
3917  /// Warn if a value is moved to itself.
3918  void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
3919  SourceLocation OpLoc);
3920 
3921  /// \brief Warn if we're implicitly casting from a _Nullable pointer type to a
3922  /// _Nonnull one.
3923  void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
3924  SourceLocation Loc);
3925 
3926  /// Warn when implicitly casting 0 to nullptr.
3927  void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
3928 
3930  return DelayedDiagnostics.push(pool);
3931  }
3932  void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
3933 
3934  typedef ProcessingContextState ParsingClassState;
3935  ParsingClassState PushParsingClass() {
3937  }
3938  void PopParsingClass(ParsingClassState state) {
3940  }
3941 
3942  void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
3943 
3944  void DiagnoseAvailabilityOfDecl(NamedDecl *D, SourceLocation Loc,
3945  const ObjCInterfaceDecl *UnknownObjCClass,
3946  bool ObjCPropertyAccess,
3947  bool AvoidPartialAvailabilityChecks = false);
3948 
3949  bool makeUnavailableInSystemHeader(SourceLocation loc,
3950  UnavailableAttr::ImplicitReason reason);
3951 
3952  /// \brief Issue any -Wunguarded-availability warnings in \c FD
3953  void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
3954 
3955  //===--------------------------------------------------------------------===//
3956  // Expression Parsing Callbacks: SemaExpr.cpp.
3957 
3958  bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
3959  bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
3960  const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
3961  bool ObjCPropertyAccess = false,
3962  bool AvoidPartialAvailabilityChecks = false);
3963  void NoteDeletedFunction(FunctionDecl *FD);
3964  void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
3965  std::string getDeletedOrUnavailableSuffix(const FunctionDecl *FD);
3966  bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
3967  ObjCMethodDecl *Getter,
3968  SourceLocation Loc);
3969  void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
3970  ArrayRef<Expr *> Args);
3971 
3972  void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
3973  Decl *LambdaContextDecl = nullptr,
3974  bool IsDecltype = false);
3975  enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
3976  void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
3978  bool IsDecltype = false);
3979  void PopExpressionEvaluationContext();
3980 
3981  void DiscardCleanupsInEvaluationContext();
3982 
3983  ExprResult TransformToPotentiallyEvaluated(Expr *E);
3984  ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
3985 
3986  ExprResult ActOnConstantExpression(ExprResult Res);
3987 
3988  // Functions for marking a declaration referenced. These functions also
3989  // contain the relevant logic for marking if a reference to a function or
3990  // variable is an odr-use (in the C++11 sense). There are separate variants
3991  // for expressions referring to a decl; these exist because odr-use marking
3992  // needs to be delayed for some constant variables when we build one of the
3993  // named expressions.
3994  //
3995  // MightBeOdrUse indicates whether the use could possibly be an odr-use, and
3996  // should usually be true. This only needs to be set to false if the lack of
3997  // odr-use cannot be determined from the current context (for instance,
3998  // because the name denotes a virtual function and was written without an
3999  // explicit nested-name-specifier).
4000  void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
4001  void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
4002  bool MightBeOdrUse = true);
4003  void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
4004  void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
4005  void MarkMemberReferenced(MemberExpr *E);
4006 
4007  void UpdateMarkingForLValueToRValue(Expr *E);
4008  void CleanupVarDeclMarking();
4009 
4011  TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
4012  };
4013 
4014  /// \brief Try to capture the given variable.
4015  ///
4016  /// \param Var The variable to capture.
4017  ///
4018  /// \param Loc The location at which the capture occurs.
4019  ///
4020  /// \param Kind The kind of capture, which may be implicit (for either a
4021  /// block or a lambda), or explicit by-value or by-reference (for a lambda).
4022  ///
4023  /// \param EllipsisLoc The location of the ellipsis, if one is provided in
4024  /// an explicit lambda capture.
4025  ///
4026  /// \param BuildAndDiagnose Whether we are actually supposed to add the
4027  /// captures or diagnose errors. If false, this routine merely check whether
4028  /// the capture can occur without performing the capture itself or complaining
4029  /// if the variable cannot be captured.
4030  ///
4031  /// \param CaptureType Will be set to the type of the field used to capture
4032  /// this variable in the innermost block or lambda. Only valid when the
4033  /// variable can be captured.
4034  ///
4035  /// \param DeclRefType Will be set to the type of a reference to the capture
4036  /// from within the current scope. Only valid when the variable can be
4037  /// captured.
4038  ///
4039  /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
4040  /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
4041  /// This is useful when enclosing lambdas must speculatively capture
4042  /// variables that may or may not be used in certain specializations of
4043  /// a nested generic lambda.
4044  ///
4045  /// \returns true if an error occurred (i.e., the variable cannot be
4046  /// captured) and false if the capture succeeded.
4047  bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
4048  SourceLocation EllipsisLoc, bool BuildAndDiagnose,
4049  QualType &CaptureType,
4050  QualType &DeclRefType,
4051  const unsigned *const FunctionScopeIndexToStopAt);
4052 
4053  /// \brief Try to capture the given variable.
4054  bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
4055  TryCaptureKind Kind = TryCapture_Implicit,
4056  SourceLocation EllipsisLoc = SourceLocation());
4057 
4058  /// \brief Checks if the variable must be captured.
4059  bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
4060 
4061  /// \brief Given a variable, determine the type that a reference to that
4062  /// variable will have in the given scope.
4063  QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
4064 
4065  /// Mark all of the declarations referenced within a particular AST node as
4066  /// referenced. Used when template instantiation instantiates a non-dependent
4067  /// type -- entities referenced by the type are now referenced.
4068  void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
4069  void MarkDeclarationsReferencedInExpr(Expr *E,
4070  bool SkipLocalVariables = false);
4071 
4072  /// \brief Try to recover by turning the given expression into a
4073  /// call. Returns true if recovery was attempted or an error was
4074  /// emitted; this may also leave the ExprResult invalid.
4075  bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
4076  bool ForceComplain = false,
4077  bool (*IsPlausibleResult)(QualType) = nullptr);
4078 
4079  /// \brief Figure out if an expression could be turned into a call.
4080  bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
4081  UnresolvedSetImpl &NonTemplateOverloads);
4082 
4083  /// \brief Conditionally issue a diagnostic based on the current
4084  /// evaluation context.
4085  ///
4086  /// \param Statement If Statement is non-null, delay reporting the
4087  /// diagnostic until the function body is parsed, and then do a basic
4088  /// reachability analysis to determine if the statement is reachable.
4089  /// If it is unreachable, the diagnostic will not be emitted.
4090  bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
4091  const PartialDiagnostic &PD);
4092 
4093  // Primary Expressions.
4094  SourceRange getExprRange(Expr *E) const;
4095 
4096  ExprResult ActOnIdExpression(
4097  Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
4098  UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
4099  std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr,
4100  bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);
4101 
4102  void DecomposeUnqualifiedId(const UnqualifiedId &Id,
4103  TemplateArgumentListInfo &Buffer,
4104  DeclarationNameInfo &NameInfo,
4105  const TemplateArgumentListInfo *&TemplateArgs);
4106 
4107  bool
4108  DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
4109  std::unique_ptr<CorrectionCandidateCallback> CCC,
4110  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
4111  ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
4112 
4113  ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
4114  IdentifierInfo *II,
4115  bool AllowBuiltinCreation=false);
4116 
4117  ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
4118  SourceLocation TemplateKWLoc,
4119  const DeclarationNameInfo &NameInfo,
4120  bool isAddressOfOperand,
4121  const TemplateArgumentListInfo *TemplateArgs);
4122 
4123  ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty,
4124  ExprValueKind VK,
4125  SourceLocation Loc,
4126  const CXXScopeSpec *SS = nullptr);
4127  ExprResult
4128  BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
4129  const DeclarationNameInfo &NameInfo,
4130  const CXXScopeSpec *SS = nullptr,
4131  NamedDecl *FoundD = nullptr,
4132  const TemplateArgumentListInfo *TemplateArgs = nullptr);
4133  ExprResult
4134  BuildAnonymousStructUnionMemberReference(
4135  const CXXScopeSpec &SS,
4136  SourceLocation nameLoc,
4137  IndirectFieldDecl *indirectField,
4138  DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
4139  Expr *baseObjectExpr = nullptr,
4140  SourceLocation opLoc = SourceLocation());
4141 
4142  ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
4143  SourceLocation TemplateKWLoc,
4144  LookupResult &R,
4145  const TemplateArgumentListInfo *TemplateArgs,
4146  const Scope *S);
4147  ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
4148  SourceLocation TemplateKWLoc,
4149  LookupResult &R,
4150  const TemplateArgumentListInfo *TemplateArgs,
4151  bool IsDefiniteInstance,
4152  const Scope *S);
4153  bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
4154  const LookupResult &R,
4155  bool HasTrailingLParen);
4156 
4157  ExprResult
4158  BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
4159  const DeclarationNameInfo &NameInfo,
4160  bool IsAddressOfOperand, const Scope *S,
4161  TypeSourceInfo **RecoveryTSI = nullptr);
4162 
4163  ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
4164  SourceLocation TemplateKWLoc,
4165  const DeclarationNameInfo &NameInfo,
4166  const TemplateArgumentListInfo *TemplateArgs);
4167 
4168  ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
4169  LookupResult &R,
4170  bool NeedsADL,
4171  bool AcceptInvalidDecl = false);
4172  ExprResult BuildDeclarationNameExpr(
4173  const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
4174  NamedDecl *FoundD = nullptr,
4175  const TemplateArgumentListInfo *TemplateArgs = nullptr,
4176  bool AcceptInvalidDecl = false);
4177 
4178  ExprResult BuildLiteralOperatorCall(LookupResult &R,
4179  DeclarationNameInfo &SuffixInfo,
4180  ArrayRef<Expr *> Args,
4181  SourceLocation LitEndLoc,
4182  TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
4183 
4184  ExprResult BuildPredefinedExpr(SourceLocation Loc,
4186  ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
4187  ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
4188 
4189  bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
4190 
4191  ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);
4192  ExprResult ActOnCharacterConstant(const Token &Tok,
4193  Scope *UDLScope = nullptr);
4194  ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
4195  ExprResult ActOnParenListExpr(SourceLocation L,
4196  SourceLocation R,
4197  MultiExprArg Val);
4198 
4199  /// ActOnStringLiteral - The specified tokens were lexed as pasted string
4200  /// fragments (e.g. "foo" "bar" L"baz").
4201  ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
4202  Scope *UDLScope = nullptr);
4203 
4204  ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
4205  SourceLocation DefaultLoc,
4206  SourceLocation RParenLoc,
4207  Expr *ControllingExpr,
4208  ArrayRef<ParsedType> ArgTypes,
4209  ArrayRef<Expr *> ArgExprs);
4210  ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
4211  SourceLocation DefaultLoc,
4212  SourceLocation RParenLoc,
4213  Expr *ControllingExpr,
4215  ArrayRef<Expr *> Exprs);
4216 
4217  // Binary/Unary Operators. 'Tok' is the token for the operator.
4218  ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
4219  Expr *InputExpr);
4220  ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
4221  UnaryOperatorKind Opc, Expr *Input);
4222  ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
4223  tok::TokenKind Op, Expr *Input);
4224 
4225  QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
4226 
4227  ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
4228  SourceLocation OpLoc,
4229  UnaryExprOrTypeTrait ExprKind,
4230  SourceRange R);
4231  ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
4232  UnaryExprOrTypeTrait ExprKind);
4233  ExprResult
4234  ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
4235  UnaryExprOrTypeTrait ExprKind,
4236  bool IsType, void *TyOrEx,
4237  SourceRange ArgRange);
4238 
4239  ExprResult CheckPlaceholderExpr(Expr *E);
4240  bool CheckVecStepExpr(Expr *E);
4241 
4242  bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
4243  bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
4244  SourceRange ExprRange,
4245  UnaryExprOrTypeTrait ExprKind);
4246  ExprResult ActOnSizeofParameterPackExpr(Scope *S,
4247  SourceLocation OpLoc,
4248  IdentifierInfo &Name,
4249  SourceLocation NameLoc,
4250  SourceLocation RParenLoc);
4251  ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
4252  tok::TokenKind Kind, Expr *Input);
4253 
4254  ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
4255  Expr *Idx, SourceLocation RLoc);
4256  ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
4257  Expr *Idx, SourceLocation RLoc);
4258  ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
4259  Expr *LowerBound, SourceLocation ColonLoc,
4260  Expr *Length, SourceLocation RBLoc);
4261 
4262  // This struct is for use by ActOnMemberAccess to allow
4263  // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
4264  // changing the access operator from a '.' to a '->' (to see if that is the
4265  // change needed to fix an error about an unknown member, e.g. when the class
4266  // defines a custom operator->).
4268  Scope *S;
4271  };
4272 
4273  ExprResult BuildMemberReferenceExpr(
4274  Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,
4275  CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
4276  NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,
4277  const TemplateArgumentListInfo *TemplateArgs,
4278  const Scope *S,
4279  ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
4280 
4281  ExprResult
4282  BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
4283  bool IsArrow, const CXXScopeSpec &SS,
4284  SourceLocation TemplateKWLoc,
4285  NamedDecl *FirstQualifierInScope, LookupResult &R,
4286  const TemplateArgumentListInfo *TemplateArgs,
4287  const Scope *S,
4288  bool SuppressQualifierCheck = false,
4289  ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
4290 
4291  ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
4292  SourceLocation OpLoc,
4293  const CXXScopeSpec &SS, FieldDecl *Field,
4294  DeclAccessPair FoundDecl,
4295  const DeclarationNameInfo &MemberNameInfo);
4296 
4297  ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
4298 
4299  bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
4300  const CXXScopeSpec &SS,
4301  const LookupResult &R);
4302 
4303  ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
4304  bool IsArrow, SourceLocation OpLoc,
4305  const CXXScopeSpec &SS,
4306  SourceLocation TemplateKWLoc,
4307  NamedDecl *FirstQualifierInScope,
4308  const DeclarationNameInfo &NameInfo,
4309  const TemplateArgumentListInfo *TemplateArgs);
4310 
4311  ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
4312  SourceLocation OpLoc,
4313  tok::TokenKind OpKind,
4314  CXXScopeSpec &SS,
4315  SourceLocation TemplateKWLoc,
4316  UnqualifiedId &Member,
4317  Decl *ObjCImpDecl);
4318 
4319  void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
4320  bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
4321  FunctionDecl *FDecl,
4322  const FunctionProtoType *Proto,
4323  ArrayRef<Expr *> Args,
4324  SourceLocation RParenLoc,
4325  bool ExecConfig = false);
4326  void CheckStaticArrayArgument(SourceLocation CallLoc,
4327  ParmVarDecl *Param,
4328  const Expr *ArgExpr);
4329 
4330  /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
4331  /// This provides the location of the left/right parens and a list of comma
4332  /// locations.
4333  ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
4334  MultiExprArg ArgExprs, SourceLocation RParenLoc,
4335  Expr *ExecConfig = nullptr,
4336  bool IsExecConfig = false);
4337  ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
4338  SourceLocation LParenLoc,
4339  ArrayRef<Expr *> Arg,
4340  SourceLocation RParenLoc,
4341  Expr *Config = nullptr,
4342  bool IsExecConfig = false);
4343 
4344  ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
4345  MultiExprArg ExecConfig,
4346  SourceLocation GGGLoc);
4347 
4348  ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
4349  Declarator &D, ParsedType &Ty,
4350  SourceLocation RParenLoc, Expr *CastExpr);
4351  ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
4352  TypeSourceInfo *Ty,
4353  SourceLocation RParenLoc,
4354  Expr *Op);
4355  CastKind PrepareScalarCast(ExprResult &src, QualType destType);
4356 
4357  /// \brief Build an altivec or OpenCL literal.
4358  ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
4359  SourceLocation RParenLoc, Expr *E,
4360  TypeSourceInfo *TInfo);
4361 
4362  ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
4363 
4364  ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
4365  ParsedType Ty,
4366  SourceLocation RParenLoc,
4367  Expr *InitExpr);
4368 
4369  ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
4370  TypeSourceInfo *TInfo,
4371  SourceLocation RParenLoc,
4372  Expr *LiteralExpr);
4373 
4374  ExprResult ActOnInitList(SourceLocation LBraceLoc,
4375  MultiExprArg InitArgList,
4376  SourceLocation RBraceLoc);
4377 
4378  ExprResult ActOnDesignatedInitializer(Designation &Desig,
4379  SourceLocation Loc,
4380  bool GNUSyntax,
4381  ExprResult Init);
4382 
4383 private:
4384  static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
4385 
4386 public:
4387  ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
4388  tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
4389  ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
4390  BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
4391  ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
4392  Expr *LHSExpr, Expr *RHSExpr);
4393 
4394  void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
4395 
4396  /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
4397  /// in the case of a the GNU conditional expr extension.
4398  ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
4399  SourceLocation ColonLoc,
4400  Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
4401 
4402  /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
4403  ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
4404  LabelDecl *TheDecl);
4405 
4406  void ActOnStartStmtExpr();
4407  ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
4408  SourceLocation RPLoc); // "({..})"
4409  void ActOnStmtExprError();
4410 
4411  // __builtin_offsetof(type, identifier(.identifier|[expr])*)
4414  bool isBrackets; // true if [expr], false if .ident
4415  union {
4418  } U;
4419  };
4420 
4421  /// __builtin_offsetof(type, a.b[123][456].c)
4422  ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
4423  TypeSourceInfo *TInfo,
4424  ArrayRef<OffsetOfComponent> Components,
4425  SourceLocation RParenLoc);
4426  ExprResult ActOnBuiltinOffsetOf(Scope *S,
4427  SourceLocation BuiltinLoc,
4429  ParsedType ParsedArgTy,
4430  ArrayRef<OffsetOfComponent> Components,
4431  SourceLocation RParenLoc);
4432 
4433  // __builtin_choose_expr(constExpr, expr1, expr2)
4434  ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
4435  Expr *CondExpr, Expr *LHSExpr,
4436  Expr *RHSExpr, SourceLocation RPLoc);
4437 
4438  // __builtin_va_arg(expr, type)
4439  ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
4440  SourceLocation RPLoc);
4441  ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
4442  TypeSourceInfo *TInfo, SourceLocation RPLoc);
4443 
4444  // __null
4445  ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
4446 
4447  bool CheckCaseExpression(Expr *E);
4448 
4449  /// \brief Describes the result of an "if-exists" condition check.
4451  /// \brief The symbol exists.
4453 
4454  /// \brief The symbol does not exist.
4456 
4457  /// \brief The name is a dependent name, so the results will differ
4458  /// from one instantiation to the next.
4460 
4461  /// \brief An error occurred.
4462  IER_Error
4463  };
4464 
4466  CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
4467  const DeclarationNameInfo &TargetNameInfo);
4468 
4470  CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
4471  bool IsIfExists, CXXScopeSpec &SS,
4472  UnqualifiedId &Name);
4473 
4474  StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
4475  bool IsIfExists,
4476  NestedNameSpecifierLoc QualifierLoc,
4477  DeclarationNameInfo NameInfo,
4478  Stmt *Nested);
4479  StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
4480  bool IsIfExists,
4481  CXXScopeSpec &SS, UnqualifiedId &Name,
4482  Stmt *Nested);
4483 
4484  //===------------------------- "Block" Extension ------------------------===//
4485 
4486  /// ActOnBlockStart - This callback is invoked when a block literal is
4487  /// started.
4488  void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
4489 
4490  /// ActOnBlockArguments - This callback allows processing of block arguments.
4491  /// If there are no arguments, this is still invoked.
4492  void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
4493  Scope *CurScope);
4494 
4495  /// ActOnBlockError - If there is an error parsing a block, this callback
4496  /// is invoked to pop the information about the block from the action impl.
4497  void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
4498 
4499  /// ActOnBlockStmtExpr - This is called when the body of a block statement
4500  /// literal was successfully completed. ^(int x){...}
4501  ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
4502  Scope *CurScope);
4503 
4504  //===---------------------------- Clang Extensions ----------------------===//
4505 
4506  /// __builtin_convertvector(...)
4507  ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
4508  SourceLocation BuiltinLoc,
4509  SourceLocation RParenLoc);
4510 
4511  //===---------------------------- OpenCL Features -----------------------===//
4512 
4513  /// __builtin_astype(...)
4514  ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
4515  SourceLocation BuiltinLoc,
4516  SourceLocation RParenLoc);
4517 
4518  //===---------------------------- C++ Features --------------------------===//
4519 
4520  // Act on C++ namespaces
4521  Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
4522  SourceLocation NamespaceLoc,
4523  SourceLocation IdentLoc,
4524  IdentifierInfo *Ident,
4525  SourceLocation LBrace,
4526  AttributeList *AttrList,
4528  void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
4529 
4530  NamespaceDecl *getStdNamespace() const;
4531  NamespaceDecl *getOrCreateStdNamespace();
4532 
4533  NamespaceDecl *lookupStdExperimentalNamespace();
4534 
4535  CXXRecordDecl *getStdBadAlloc() const;
4536  EnumDecl *getStdAlignValT() const;
4537 
4538  /// \brief Tests whether Ty is an instance of std::initializer_list and, if
4539  /// it is and Element is not NULL, assigns the element type to Element.
4540  bool isStdInitializerList(QualType Ty, QualType *Element);
4541 
4542  /// \brief Looks for the std::initializer_list template and instantiates it
4543  /// with Element, or emits an error if it's not found.
4544  ///
4545  /// \returns The instantiated template, or null on error.
4546  QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
4547 
4548  /// \brief Determine whether Ctor is an initializer-list constructor, as
4549  /// defined in [dcl.init.list]p2.
4550  bool isInitListConstructor(const FunctionDecl *Ctor);
4551 
4552  Decl *ActOnUsingDirective(Scope *CurScope,
4553  SourceLocation UsingLoc,
4554  SourceLocation NamespcLoc,
4555  CXXScopeSpec &SS,
4556  SourceLocation IdentLoc,
4557  IdentifierInfo *NamespcName,
4558  AttributeList *AttrList);
4559 
4560  void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
4561 
4562  Decl *ActOnNamespaceAliasDef(Scope *CurScope,
4563  SourceLocation NamespaceLoc,
4564  SourceLocation AliasLoc,
4565  IdentifierInfo *Alias,
4566  CXXScopeSpec &SS,
4567  SourceLocation IdentLoc,
4568  IdentifierInfo *Ident);
4569 
4570  void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
4571  bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target,
4572  const LookupResult &PreviousDecls,
4573  UsingShadowDecl *&PrevShadow);
4574  UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,
4575  NamedDecl *Target,
4576  UsingShadowDecl *PrevDecl);
4577 
4578  bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
4579  bool HasTypenameKeyword,
4580  const CXXScopeSpec &SS,
4581  SourceLocation NameLoc,
4582  const LookupResult &Previous);
4583  bool CheckUsingDeclQualifier(SourceLocation UsingLoc,
4584  bool HasTypename,
4585  const CXXScopeSpec &SS,
4586  const DeclarationNameInfo &NameInfo,
4587  SourceLocation NameLoc);
4588 
4589  NamedDecl *BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
4590  SourceLocation UsingLoc,
4591  bool HasTypenameKeyword,
4592  SourceLocation TypenameLoc,
4593  CXXScopeSpec &SS,
4594  DeclarationNameInfo NameInfo,
4595  SourceLocation EllipsisLoc,
4596  AttributeList *AttrList,
4597  bool IsInstantiation);
4598  NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
4599  ArrayRef<NamedDecl *> Expansions);
4600 
4601  bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
4602 
4603  /// Given a derived-class using shadow declaration for a constructor and the
4604  /// correspnding base class constructor, find or create the implicit
4605  /// synthesized derived class constructor to use for this initialization.
4606  CXXConstructorDecl *
4607  findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
4608  ConstructorUsingShadowDecl *DerivedShadow);
4609 
4610  Decl *ActOnUsingDeclaration(Scope *CurScope,
4611  AccessSpecifier AS,
4612  SourceLocation UsingLoc,
4613  SourceLocation TypenameLoc,
4614  CXXScopeSpec &SS,
4615  UnqualifiedId &Name,
4616  SourceLocation EllipsisLoc,
4617  AttributeList *AttrList);
4618  Decl *ActOnAliasDeclaration(Scope *CurScope,
4619  AccessSpecifier AS,
4620  MultiTemplateParamsArg TemplateParams,
4621  SourceLocation UsingLoc,
4622  UnqualifiedId &Name,
4623  AttributeList *AttrList,
4624  TypeResult Type,
4625  Decl *DeclFromDeclSpec);
4626 
4627  /// BuildCXXConstructExpr - Creates a complete call to a constructor,
4628  /// including handling of its default argument expressions.
4629  ///
4630  /// \param ConstructKind - a CXXConstructExpr::ConstructionKind
4631  ExprResult
4632  BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4633  NamedDecl *FoundDecl,
4634  CXXConstructorDecl *Constructor, MultiExprArg Exprs,
4635  bool HadMultipleCandidates, bool IsListInitialization,
4636  bool IsStdInitListInitialization,
4637  bool RequiresZeroInit, unsigned ConstructKind,
4638  SourceRange ParenRange);
4639 
4640  /// Build a CXXConstructExpr whose constructor has already been resolved if
4641  /// it denotes an inherited constructor.
4642  ExprResult
4643  BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4644  CXXConstructorDecl *Constructor, bool Elidable,
4645  MultiExprArg Exprs,
4646  bool HadMultipleCandidates, bool IsListInitialization,
4647  bool IsStdInitListInitialization,
4648  bool RequiresZeroInit, unsigned ConstructKind,
4649  SourceRange ParenRange);
4650 
4651  // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if
4652  // the constructor can be elidable?
4653  ExprResult
4654  BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
4655  NamedDecl *FoundDecl,
4656  CXXConstructorDecl *Constructor, bool Elidable,
4657  MultiExprArg Exprs, bool HadMultipleCandidates,
4658  bool IsListInitialization,
4659  bool IsStdInitListInitialization, bool RequiresZeroInit,
4660  unsigned ConstructKind, SourceRange ParenRange);
4661 
4662  ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
4663 
4664 
4665  /// Instantiate or parse a C++ default argument expression as necessary.
4666  /// Return true on error.
4667  bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
4668  ParmVarDecl *Param);
4669 
4670  /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
4671  /// the default expr if needed.
4672  ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
4673  FunctionDecl *FD,
4674  ParmVarDecl *Param);
4675 
4676  /// FinalizeVarWithDestructor - Prepare for calling destructor on the
4677  /// constructed variable.
4678  void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);
4679 
4680  /// \brief Helper class that collects exception specifications for
4681  /// implicitly-declared special member functions.
4683  // Pointer to allow copying
4684  Sema *Self;
4685  // We order exception specifications thus:
4686  // noexcept is the most restrictive, but is only used in C++11.
4687  // throw() comes next.
4688  // Then a throw(collected exceptions)
4689  // Finally no specification, which is expressed as noexcept(false).
4690  // throw(...) is used instead if any called function uses it.
4691  ExceptionSpecificationType ComputedEST;
4692  llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen;
4693  SmallVector<QualType, 4> Exceptions;
4694 
4695  void ClearExceptions() {
4696  ExceptionsSeen.clear();
4697  Exceptions.clear();
4698  }
4699 
4700  public:
4702  : Self(&Self), ComputedEST(EST_BasicNoexcept) {
4703  if (!Self.getLangOpts().CPlusPlus11)
4704  ComputedEST = EST_DynamicNone;
4705  }
4706 
4707  /// \brief Get the computed exception specification type.
4709  assert(ComputedEST != EST_ComputedNoexcept &&
4710  "noexcept(expr) should not be a possible result");
4711  return ComputedEST;
4712  }
4713 
4714  /// \brief The number of exceptions in the exception specification.
4715  unsigned size() const { return Exceptions.size(); }
4716 
4717  /// \brief The set of exceptions in the exception specification.
4718  const QualType *data() const { return Exceptions.data(); }
4719 
4720  /// \brief Integrate another called method into the collected data.
4721  void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);
4722 
4723  /// \brief Integrate an invoked expression into the collected data.
4724  void CalledExpr(Expr *E);
4725 
4726  /// \brief Overwrite an EPI's exception specification with this
4727  /// computed exception specification.
4730  ESI.Type = getExceptionSpecType();
4731  if (ESI.Type == EST_Dynamic) {
4732  ESI.Exceptions = Exceptions;
4733  } else if (ESI.Type == EST_None) {
4734  /// C++11 [except.spec]p14:
4735  /// The exception-specification is noexcept(false) if the set of
4736  /// potential exceptions of the special member function contains "any"
4737  ESI.Type = EST_ComputedNoexcept;
4739  tok::kw_false).get();
4740  }
4741  return ESI;
4742  }
4743  };
4744 
4745  /// \brief Determine what sort of exception specification a defaulted
4746  /// copy constructor of a class will have.
4748  ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,
4749  CXXMethodDecl *MD);
4750 
4751  /// \brief Determine what sort of exception specification a defaulted
4752  /// default constructor of a class will have, and whether the parameter
4753  /// will be const.
4755  ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD);
4756 
4757  /// \brief Determine what sort of exception specification a defautled
4758  /// copy assignment operator of a class will have, and whether the
4759  /// parameter will be const.
4761  ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD);
4762 
4763  /// \brief Determine what sort of exception specification a defaulted move
4764  /// constructor of a class will have.
4766  ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD);
4767 
4768  /// \brief Determine what sort of exception specification a defaulted move
4769  /// assignment operator of a class will have.
4771  ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD);
4772 
4773  /// \brief Determine what sort of exception specification a defaulted
4774  /// destructor of a class will have.
4776  ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD);
4777 
4778  /// \brief Determine what sort of exception specification an inheriting
4779  /// constructor of a class will have.
4781  ComputeInheritingCtorExceptionSpec(SourceLocation Loc,
4782  CXXConstructorDecl *CD);
4783 
4784  /// \brief Evaluate the implicit exception specification for a defaulted
4785  /// special member function.
4786  void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD);
4787 
4788  /// \brief Check the given exception-specification and update the
4789  /// exception specification information with the results.
4790  void checkExceptionSpecification(bool IsTopLevel,
4792  ArrayRef<ParsedType> DynamicExceptions,
4793  ArrayRef<SourceRange> DynamicExceptionRanges,
4794  Expr *NoexceptExpr,
4795  SmallVectorImpl<QualType> &Exceptions,
4797 
4798  /// \brief Determine if we're in a case where we need to (incorrectly) eagerly
4799  /// parse an exception specification to work around a libstdc++ bug.
4800  bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);
4801 
4802  /// \brief Add an exception-specification to the given member function
4803  /// (or member function template). The exception-specification was parsed
4804  /// after the method itself was declared.
4805  void actOnDelayedExceptionSpecification(Decl *Method,
4807  SourceRange SpecificationRange,
4808  ArrayRef<ParsedType> DynamicExceptions,
4809  ArrayRef<SourceRange> DynamicExceptionRanges,
4810  Expr *NoexceptExpr);
4811 
4813 
4814  /// \brief Determine if a special member function should have a deleted
4815  /// definition when it is defaulted.
4816  bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
4817  InheritedConstructorInfo *ICI = nullptr,
4818  bool Diagnose = false);
4819 
4820  /// \brief Declare the implicit default constructor for the given class.
4821  ///
4822  /// \param ClassDecl The class declaration into which the implicit
4823  /// default constructor will be added.
4824  ///
4825  /// \returns The implicitly-declared default constructor.
4826  CXXConstructorDecl *DeclareImplicitDefaultConstructor(
4827  CXXRecordDecl *ClassDecl);
4828 
4829  /// DefineImplicitDefaultConstructor - Checks for feasibility of
4830  /// defining this constructor as the default constructor.
4831  void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
4832  CXXConstructorDecl *Constructor);
4833 
4834  /// \brief Declare the implicit destructor for the given class.
4835  ///
4836  /// \param ClassDecl The class declaration into which the implicit
4837  /// destructor will be added.
4838  ///
4839  /// \returns The implicitly-declared destructor.
4840  CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);
4841 
4842  /// DefineImplicitDestructor - Checks for feasibility of
4843  /// defining this destructor as the default destructor.
4844  void DefineImplicitDestructor(SourceLocation CurrentLocation,
4845  CXXDestructorDecl *Destructor);
4846 
4847  /// \brief Build an exception spec for destructors that don't have one.
4848  ///
4849  /// C++11 says that user-defined destructors with no exception spec get one
4850  /// that looks as if the destructor was implicitly declared.
4851  void AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
4852  CXXDestructorDecl *Destructor);
4853 
4854  /// \brief Define the specified inheriting constructor.
4855  void DefineInheritingConstructor(SourceLocation UseLoc,
4856  CXXConstructorDecl *Constructor);
4857 
4858  /// \brief Declare the implicit copy constructor for the given class.
4859  ///
4860  /// \param ClassDecl The class declaration into which the implicit
4861  /// copy constructor will be added.
4862  ///
4863  /// \returns The implicitly-declared copy constructor.
4864  CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);
4865 
4866  /// DefineImplicitCopyConstructor - Checks for feasibility of
4867  /// defining this constructor as the copy constructor.
4868  void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
4869  CXXConstructorDecl *Constructor);
4870 
4871  /// \brief Declare the implicit move constructor for the given class.
4872  ///
4873  /// \param ClassDecl The Class declaration into which the implicit
4874  /// move constructor will be added.
4875  ///
4876  /// \returns The implicitly-declared move constructor, or NULL if it wasn't
4877  /// declared.
4878  CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);
4879 
4880  /// DefineImplicitMoveConstructor - Checks for feasibility of
4881  /// defining this constructor as the move constructor.
4882  void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
4883  CXXConstructorDecl *Constructor);
4884 
4885  /// \brief Declare the implicit copy assignment operator for the given class.
4886  ///
4887  /// \param ClassDecl The class declaration into which the implicit
4888  /// copy assignment operator will be added.
4889  ///
4890  /// \returns The implicitly-declared copy assignment operator.
4891  CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);
4892 
4893  /// \brief Defines an implicitly-declared copy assignment operator.
4894  void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
4895  CXXMethodDecl *MethodDecl);
4896 
4897  /// \brief Declare the implicit move assignment operator for the given class.
4898  ///
4899  /// \param ClassDecl The Class declaration into which the implicit
4900  /// move assignment operator will be added.
4901  ///
4902  /// \returns The implicitly-declared move assignment operator, or NULL if it
4903  /// wasn't declared.
4904  CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);
4905 
4906  /// \brief Defines an implicitly-declared move assignment operator.
4907  void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
4908  CXXMethodDecl *MethodDecl);
4909 
4910  /// \brief Force the declaration of any implicitly-declared members of this
4911  /// class.
4912  void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);
4913 
4914  /// \brief Check a completed declaration of an implicit special member.
4915  void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);
4916 
4917  /// \brief Determine whether the given function is an implicitly-deleted
4918  /// special member function.
4919  bool isImplicitlyDeleted(FunctionDecl *FD);
4920 
4921  /// \brief Check whether 'this' shows up in the type of a static member
4922  /// function after the (naturally empty) cv-qualifier-seq would be.
4923  ///
4924  /// \returns true if an error occurred.
4925  bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);
4926 
4927  /// \brief Whether this' shows up in the exception specification of a static
4928  /// member function.
4929  bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);
4930 
4931  /// \brief Check whether 'this' shows up in the attributes of the given
4932  /// static member function.
4933  ///
4934  /// \returns true if an error occurred.
4935  bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
4936 
4937  /// MaybeBindToTemporary - If the passed in expression has a record type with
4938  /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
4939  /// it simply returns the passed in expression.
4940  ExprResult MaybeBindToTemporary(Expr *E);
4941 
4942  bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
4943  MultiExprArg ArgsPtr,
4944  SourceLocation Loc,
4945  SmallVectorImpl<Expr*> &ConvertedArgs,
4946  bool AllowExplicit = false,
4947  bool IsListInitialization = false);
4948 
4949  ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
4950  SourceLocation NameLoc,
4951  IdentifierInfo &Name);
4952 
4953  ParsedType getDestructorName(SourceLocation TildeLoc,
4954  IdentifierInfo &II, SourceLocation NameLoc,
4955  Scope *S, CXXScopeSpec &SS,
4956  ParsedType ObjectType,
4957  bool EnteringContext);
4958 
4959  ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
4960  ParsedType ObjectType);
4961 
4962  // Checks that reinterpret casts don't have undefined behavior.
4963  void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
4964  bool IsDereference, SourceRange Range);
4965 
4966  /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
4967  ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
4969  SourceLocation LAngleBracketLoc,
4970  Declarator &D,
4971  SourceLocation RAngleBracketLoc,
4972  SourceLocation LParenLoc,
4973  Expr *E,
4974  SourceLocation RParenLoc);
4975 
4976  ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
4977  tok::TokenKind Kind,
4978  TypeSourceInfo *Ty,
4979  Expr *E,
4980  SourceRange AngleBrackets,
4981  SourceRange Parens);
4982 
4983  ExprResult BuildCXXTypeId(QualType TypeInfoType,
4984  SourceLocation TypeidLoc,
4985  TypeSourceInfo *Operand,
4986  SourceLocation RParenLoc);
4987  ExprResult BuildCXXTypeId(QualType TypeInfoType,
4988  SourceLocation TypeidLoc,
4989  Expr *Operand,
4990  SourceLocation RParenLoc);
4991 
4992  /// ActOnCXXTypeid - Parse typeid( something ).
4993  ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
4994  SourceLocation LParenLoc, bool isType,
4995  void *TyOrExpr,
4996  SourceLocation RParenLoc);
4997 
4998  ExprResult BuildCXXUuidof(QualType TypeInfoType,
4999  SourceLocation TypeidLoc,
5000  TypeSourceInfo *Operand,
5001  SourceLocation RParenLoc);
5002  ExprResult BuildCXXUuidof(QualType TypeInfoType,
5003  SourceLocation TypeidLoc,
5004  Expr *Operand,
5005  SourceLocation RParenLoc);
5006 
5007  /// ActOnCXXUuidof - Parse __uuidof( something ).
5008  ExprResult ActOnCXXUuidof(SourceLocation OpLoc,
5009  SourceLocation LParenLoc, bool isType,
5010  void *TyOrExpr,
5011  SourceLocation RParenLoc);
5012 
5013  /// \brief Handle a C++1z fold-expression: ( expr op ... op expr ).
5014  ExprResult ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
5015  tok::TokenKind Operator,
5016  SourceLocation EllipsisLoc, Expr *RHS,
5017  SourceLocation RParenLoc);
5018  ExprResult BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
5019  BinaryOperatorKind Operator,
5020  SourceLocation EllipsisLoc, Expr *RHS,
5021  SourceLocation RParenLoc);
5022  ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
5023  BinaryOperatorKind Operator);
5024 
5025  //// ActOnCXXThis - Parse 'this' pointer.
5026  ExprResult ActOnCXXThis(SourceLocation loc);
5027 
5028  /// \brief Try to retrieve the type of the 'this' pointer.
5029  ///
5030  /// \returns The type of 'this', if possible. Otherwise, returns a NULL type.
5031  QualType getCurrentThisType();
5032 
5033  /// \brief When non-NULL, the C++ 'this' expression is allowed despite the
5034  /// current context not being a non-static member function. In such cases,
5035  /// this provides the type used for 'this'.
5037 
5038  /// \brief RAII object used to temporarily allow the C++ 'this' expression
5039  /// to be used, with the given qualifiers on the current class type.
5041  Sema &S;
5042  QualType OldCXXThisTypeOverride;
5043  bool Enabled;
5044 
5045  public:
5046  /// \brief Introduce a new scope where 'this' may be allowed (when enabled),
5047  /// using the given declaration (which is either a class template or a
5048  /// class) along with the given qualifiers.
5049  /// along with the qualifiers placed on '*this'.
5050  CXXThisScopeRAII(Sema &S, Decl *ContextDecl, unsigned CXXThisTypeQuals,
5051  bool Enabled = true);
5052 
5053  ~CXXThisScopeRAII();
5054  };
5055 
5056  /// \brief Make sure the value of 'this' is actually available in the current
5057  /// context, if it is a potentially evaluated context.
5058  ///
5059  /// \param Loc The location at which the capture of 'this' occurs.
5060  ///
5061  /// \param Explicit Whether 'this' is explicitly captured in a lambda
5062  /// capture list.
5063  ///
5064  /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
5065  /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
5066  /// This is useful when enclosing lambdas must speculatively capture
5067  /// 'this' that may or may not be used in certain specializations of
5068  /// a nested generic lambda (depending on whether the name resolves to
5069  /// a non-static member function or a static function).
5070  /// \return returns 'true' if failed, 'false' if success.
5071  bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,
5072  bool BuildAndDiagnose = true,
5073  const unsigned *const FunctionScopeIndexToStopAt = nullptr,
5074  bool ByCopy = false);
5075 
5076  /// \brief Determine whether the given type is the type of *this that is used
5077  /// outside of the body of a member function for a type that is currently
5078  /// being defined.
5079  bool isThisOutsideMemberFunctionBody(QualType BaseType);
5080 
5081  /// ActOnCXXBoolLiteral - Parse {true,false} literals.
5082  ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
5083 
5084 
5085  /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
5086  ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
5087 
5088  ExprResult
5089  ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,
5090  SourceLocation AtLoc, SourceLocation RParen);
5091 
5092  /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
5093  ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
5094 
5095  //// ActOnCXXThrow - Parse throw expressions.
5096  ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
5097  ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
5098  bool IsThrownVarInScope);
5099  bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
5100 
5101  /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
5102  /// Can be interpreted either as function-style casting ("int(x)")
5103  /// or class type construction ("ClassType(x,y,z)")
5104  /// or creation of a value-initialized type ("int()").
5105  ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,
5106  SourceLocation LParenLoc,
5107  MultiExprArg Exprs,
5108  SourceLocation RParenLoc);
5109 
5110  ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,
5111  SourceLocation LParenLoc,
5112  MultiExprArg Exprs,
5113  SourceLocation RParenLoc);
5114 
5115  /// ActOnCXXNew - Parsed a C++ 'new' expression.
5116  ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
5117  SourceLocation PlacementLParen,
5118  MultiExprArg PlacementArgs,
5119  SourceLocation PlacementRParen,
5120  SourceRange TypeIdParens, Declarator &D,
5121  Expr *Initializer);
5122  ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,
5123  SourceLocation PlacementLParen,
5124  MultiExprArg PlacementArgs,
5125  SourceLocation PlacementRParen,
5126  SourceRange TypeIdParens,
5127  QualType AllocType,
5128  TypeSourceInfo *AllocTypeInfo,
5129  Expr *ArraySize,
5130  SourceRange DirectInitRange,
5131  Expr *Initializer);
5132 
5133  bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
5134  SourceRange R);
5135  bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
5136  bool UseGlobal, QualType AllocType, bool IsArray,
5137  bool &PassAlignment, MultiExprArg PlaceArgs,
5138  FunctionDecl *&OperatorNew,
5139  FunctionDecl *&OperatorDelete);
5140  void DeclareGlobalNewDelete();
5141  void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
5142  ArrayRef<QualType> Params);
5143 
5144  bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
5145  DeclarationName Name, FunctionDecl* &Operator,
5146  bool Diagnose = true);
5147  FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
5148  bool CanProvideSize,
5149  bool Overaligned,
5150  DeclarationName Name);
5151  FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
5152  CXXRecordDecl *RD);
5153 
5154  /// ActOnCXXDelete - Parsed a C++ 'delete' expression
5155  ExprResult ActOnCXXDelete(SourceLocation StartLoc,
5156  bool UseGlobal, bool ArrayForm,
5157  Expr *Operand);
5158  void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
5159  bool IsDelete, bool CallCanBeVirtual,
5160  bool WarnOnNonAbstractTypes,
5161  SourceLocation DtorLoc);
5162 
5163  ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,
5164  Expr *Operand, SourceLocation RParen);
5165  ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
5166  SourceLocation RParen);
5167 
5168  /// \brief Parsed one of the type trait support pseudo-functions.
5169  ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
5170  ArrayRef<ParsedType> Args,
5171  SourceLocation RParenLoc);
5172  ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
5174  SourceLocation RParenLoc);
5175 
5176  /// ActOnArrayTypeTrait - Parsed one of the binary type trait support
5177  /// pseudo-functions.
5178  ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,
5179  SourceLocation KWLoc,
5180  ParsedType LhsTy,
5181  Expr *DimExpr,
5182  SourceLocation RParen);
5183 
5184  ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,
5185  SourceLocation KWLoc,
5186  TypeSourceInfo *TSInfo,
5187  Expr *DimExpr,
5188  SourceLocation RParen);
5189 
5190  /// ActOnExpressionTrait - Parsed one of the unary type trait support
5191  /// pseudo-functions.
5192  ExprResult ActOnExpressionTrait(ExpressionTrait OET,
5193  SourceLocation KWLoc,
5194  Expr *Queried,
5195  SourceLocation RParen);
5196 
5197  ExprResult BuildExpressionTrait(ExpressionTrait OET,
5198  SourceLocation KWLoc,
5199  Expr *Queried,
5200  SourceLocation RParen);
5201 
5202  ExprResult ActOnStartCXXMemberReference(Scope *S,
5203  Expr *Base,
5204  SourceLocation OpLoc,
5205  tok::TokenKind OpKind,
5206  ParsedType &ObjectType,
5207  bool &MayBePseudoDestructor);
5208 
5209  ExprResult BuildPseudoDestructorExpr(Expr *Base,
5210  SourceLocation OpLoc,
5211  tok::TokenKind OpKind,
5212  const CXXScopeSpec &SS,
5213  TypeSourceInfo *ScopeType,
5214  SourceLocation CCLoc,
5215  SourceLocation TildeLoc,
5216  PseudoDestructorTypeStorage DestroyedType);
5217 
5218  ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5219  SourceLocation OpLoc,
5220  tok::TokenKind OpKind,
5221  CXXScopeSpec &SS,
5222  UnqualifiedId &FirstTypeName,
5223  SourceLocation CCLoc,
5224  SourceLocation TildeLoc,
5225  UnqualifiedId &SecondTypeName);
5226 
5227  ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
5228  SourceLocation OpLoc,
5229  tok::TokenKind OpKind,
5230  SourceLocation TildeLoc,
5231  const DeclSpec& DS);
5232 
5233  /// MaybeCreateExprWithCleanups - If the current full-expression
5234  /// requires any cleanups, surround it with a ExprWithCleanups node.
5235  /// Otherwise, just returns the passed-in expression.
5236  Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
5237  Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
5238  ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
5239 
5241  CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
5242  bool BoundToLvalueReference);
5243 
5245  return ActOnFinishFullExpr(Expr, Expr ? Expr->getExprLoc()
5246  : SourceLocation());
5247  }
5248  ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
5249  bool DiscardedValue = false,
5250  bool IsConstexpr = false,
5251  bool IsLambdaInitCaptureInitializer = false);
5252  StmtResult ActOnFinishFullStmt(Stmt *Stmt);
5253 
5254  // Marks SS invalid if it represents an incomplete type.
5255  bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
5256 
5257  DeclContext *computeDeclContext(QualType T);
5258  DeclContext *computeDeclContext(const CXXScopeSpec &SS,
5259  bool EnteringContext = false);
5260  bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
5262 
5263  /// \brief The parser has parsed a global nested-name-specifier '::'.
5264  ///
5265  /// \param CCLoc The location of the '::'.
5266  ///
5267  /// \param SS The nested-name-specifier, which will be updated in-place
5268  /// to reflect the parsed nested-name-specifier.
5269  ///
5270  /// \returns true if an error occurred, false otherwise.
5271  bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);
5272 
5273  /// \brief The parser has parsed a '__super' nested-name-specifier.
5274  ///
5275  /// \param SuperLoc The location of the '__super' keyword.
5276  ///
5277  /// \param ColonColonLoc The location of the '::'.
5278  ///
5279  /// \param SS The nested-name-specifier, which will be updated in-place
5280  /// to reflect the parsed nested-name-specifier.
5281  ///
5282  /// \returns true if an error occurred, false otherwise.
5283  bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
5284  SourceLocation ColonColonLoc, CXXScopeSpec &SS);
5285 
5286  bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,
5287  bool *CanCorrect = nullptr);
5288  NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
5289 
5290  /// \brief Keeps information about an identifier in a nested-name-spec.
5291  ///
5293  /// \brief The type of the object, if we're parsing nested-name-specifier in
5294  /// a member access expression.
5296 
5297  /// \brief The identifier preceding the '::'.
5299 
5300  /// \brief The location of the identifier.
5302 
5303  /// \brief The location of the '::'.
5305 
5306  /// \brief Creates info object for the most typical case.
5308  SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())
5309  : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),
5310  CCLoc(ColonColonLoc) {
5311  }
5312 
5314  SourceLocation ColonColonLoc, QualType ObjectType)
5315  : ObjectType(ParsedType::make(ObjectType)), Identifier(II),
5316  IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {
5317  }
5318  };
5319 
5320  bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
5321  NestedNameSpecInfo &IdInfo);
5322 
5323  bool BuildCXXNestedNameSpecifier(Scope *S,
5324  NestedNameSpecInfo &IdInfo,
5325  bool EnteringContext,
5326  CXXScopeSpec &SS,
5327  NamedDecl *ScopeLookupResult,
5328  bool ErrorRecoveryLookup,
5329  bool *IsCorrectedToColon = nullptr,
5330  bool OnlyNamespace = false);
5331 
5332  /// \brief The parser has parsed a nested-name-specifier 'identifier::'.
5333  ///
5334  /// \param S The scope in which this nested-name-specifier occurs.
5335  ///
5336  /// \param IdInfo Parser information about an identifier in the
5337  /// nested-name-spec.
5338  ///
5339  /// \param EnteringContext Whether we're entering the context nominated by
5340  /// this nested-name-specifier.
5341  ///
5342  /// \param SS The nested-name-specifier, which is both an input
5343  /// parameter (the nested-name-specifier before this type) and an
5344  /// output parameter (containing the full nested-name-specifier,
5345  /// including this new type).
5346  ///
5347  /// \param ErrorRecoveryLookup If true, then this method is called to improve
5348  /// error recovery. In this case do not emit error message.
5349  ///
5350  /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
5351  /// are allowed. The bool value pointed by this parameter is set to 'true'
5352  /// if the identifier is treated as if it was followed by ':', not '::'.
5353  ///
5354  /// \param OnlyNamespace If true, only considers namespaces in lookup.
5355  ///
5356  /// \returns true if an error occurred, false otherwise.
5357  bool ActOnCXXNestedNameSpecifier(Scope *S,
5358  NestedNameSpecInfo &IdInfo,
5359  bool EnteringContext,
5360  CXXScopeSpec &SS,
5361  bool ErrorRecoveryLookup = false,
5362  bool *IsCorrectedToColon = nullptr,
5363  bool OnlyNamespace = false);
5364 
5365  ExprResult ActOnDecltypeExpression(Expr *E);
5366 
5367  bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
5368  const DeclSpec &DS,
5369  SourceLocation ColonColonLoc);
5370 
5371  bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
5372  NestedNameSpecInfo &IdInfo,
5373  bool EnteringContext);
5374 
5375  /// \brief The parser has parsed a nested-name-specifier
5376  /// 'template[opt] template-name < template-args >::'.
5377  ///
5378  /// \param S The scope in which this nested-name-specifier occurs.
5379  ///
5380  /// \param SS The nested-name-specifier, which is both an input
5381  /// parameter (the nested-name-specifier before this type) and an
5382  /// output parameter (containing the full nested-name-specifier,
5383  /// including this new type).
5384  ///
5385  /// \param TemplateKWLoc the location of the 'template' keyword, if any.
5386  /// \param TemplateName the template name.
5387  /// \param TemplateNameLoc The location of the template name.
5388  /// \param LAngleLoc The location of the opening angle bracket ('<').
5389  /// \param TemplateArgs The template arguments.
5390  /// \param RAngleLoc The location of the closing angle bracket ('>').
5391  /// \param CCLoc The location of the '::'.
5392  ///
5393  /// \param EnteringContext Whether we're entering the context of the
5394  /// nested-name-specifier.
5395  ///
5396  ///
5397  /// \returns true if an error occurred, false otherwise.
5398  bool ActOnCXXNestedNameSpecifier(Scope *S,
5399  CXXScopeSpec &SS,
5400  SourceLocation TemplateKWLoc,
5401  TemplateTy TemplateName,
5402  SourceLocation TemplateNameLoc,
5403  SourceLocation LAngleLoc,
5404  ASTTemplateArgsPtr TemplateArgs,
5405  SourceLocation RAngleLoc,
5406  SourceLocation CCLoc,
5407  bool EnteringContext);
5408 
5409  /// \brief Given a C++ nested-name-specifier, produce an annotation value
5410  /// that the parser can use later to reconstruct the given
5411  /// nested-name-specifier.
5412  ///
5413  /// \param SS A nested-name-specifier.
5414  ///
5415  /// \returns A pointer containing all of the information in the
5416  /// nested-name-specifier \p SS.
5417  void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);
5418 
5419  /// \brief Given an annotation pointer for a nested-name-specifier, restore
5420  /// the nested-name-specifier structure.
5421  ///
5422  /// \param Annotation The annotation pointer, produced by
5423  /// \c SaveNestedNameSpecifierAnnotation().
5424  ///
5425  /// \param AnnotationRange The source range corresponding to the annotation.
5426  ///
5427  /// \param SS The nested-name-specifier that will be updated with the contents
5428  /// of the annotation pointer.
5429  void RestoreNestedNameSpecifierAnnotation(void *Annotation,
5430  SourceRange AnnotationRange,
5431  CXXScopeSpec &SS);
5432 
5433  bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
5434 
5435  /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
5436  /// scope or nested-name-specifier) is parsed, part of a declarator-id.
5437  /// After this method is called, according to [C++ 3.4.3p3], names should be
5438  /// looked up in the declarator-id's scope, until the declarator is parsed and
5439  /// ActOnCXXExitDeclaratorScope is called.
5440  /// The 'SS' should be a non-empty valid CXXScopeSpec.
5441  bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);
5442 
5443  /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
5444  /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
5445  /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
5446  /// Used to indicate that names should revert to being looked up in the
5447  /// defining scope.
5448  void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
5449 
5450  /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
5451  /// initializer for the declaration 'Dcl'.
5452  /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
5453  /// static data member of class X, names should be looked up in the scope of
5454  /// class X.
5455  void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);
5456 
5457  /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
5458  /// initializer for the declaration 'Dcl'.
5459  void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
5460 
5461  /// \brief Create a new lambda closure type.
5462  CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
5463  TypeSourceInfo *Info,
5464  bool KnownDependent,
5465  LambdaCaptureDefault CaptureDefault);
5466 
5467  /// \brief Start the definition of a lambda expression.
5468  CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
5469  SourceRange IntroducerRange,
5470  TypeSourceInfo *MethodType,
5471  SourceLocation EndLoc,
5472  ArrayRef<ParmVarDecl *> Params,
5473  bool IsConstexprSpecified);
5474 
5475  /// \brief Endow the lambda scope info with the relevant properties.
5476  void buildLambdaScope(sema::LambdaScopeInfo *LSI,
5477  CXXMethodDecl *CallOperator,
5478  SourceRange IntroducerRange,
5479  LambdaCaptureDefault CaptureDefault,
5480  SourceLocation CaptureDefaultLoc,
5481  bool ExplicitParams,
5482  bool ExplicitResultType,
5483  bool Mutable);
5484 
5485  /// \brief Perform initialization analysis of the init-capture and perform
5486  /// any implicit conversions such as an lvalue-to-rvalue conversion if
5487  /// not being used to initialize a reference.
5489  SourceLocation Loc, bool ByRef, IdentifierInfo *Id,
5490  LambdaCaptureInitKind InitKind, Expr *&Init) {
5491  return ParsedType::make(buildLambdaInitCaptureInitialization(
5492  Loc, ByRef, Id, InitKind != LambdaCaptureInitKind::CopyInit, Init));
5493  }
5494  QualType buildLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef,
5495  IdentifierInfo *Id,
5496  bool DirectInit, Expr *&Init);
5497 
5498  /// \brief Create a dummy variable within the declcontext of the lambda's
5499  /// call operator, for name lookup purposes for a lambda init capture.
5500  ///
5501  /// CodeGen handles emission of lambda captures, ignoring these dummy
5502  /// variables appropriately.
5503  VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
5504  QualType InitCaptureType,
5505  IdentifierInfo *Id,
5506  unsigned InitStyle, Expr *Init);
5507 
5508  /// \brief Build the implicit field for an init-capture.
5509  FieldDecl *buildInitCaptureField(sema::LambdaScopeInfo *LSI, VarDecl *Var);
5510 
5511  /// \brief Note that we have finished the explicit captures for the
5512  /// given lambda.
5513  void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
5514 
5515  /// \brief Introduce the lambda parameters into scope.
5516  void addLambdaParameters(CXXMethodDecl *CallOperator, Scope *CurScope);
5517 
5518  /// \brief Deduce a block or lambda's return type based on the return
5519  /// statements present in the body.
5520  void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
5521 
5522  /// ActOnStartOfLambdaDefinition - This is called just before we start
5523  /// parsing the body of a lambda; it analyzes the explicit captures and
5524  /// arguments, and sets up various data-structures for the body of the
5525  /// lambda.
5526  void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
5527  Declarator &ParamInfo, Scope *CurScope);
5528 
5529  /// ActOnLambdaError - If there is an error parsing a lambda, this callback
5530  /// is invoked to pop the information about the lambda.
5531  void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
5532  bool IsInstantiation = false);
5533 
5534  /// ActOnLambdaExpr - This is called when the body of a lambda expression
5535  /// was successfully completed.
5536  ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
5537  Scope *CurScope);
5538 
5539  /// \brief Does copying/destroying the captured variable have side effects?
5540  bool CaptureHasSideEffects(const sema::LambdaScopeInfo::Capture &From);
5541 
5542  /// \brief Diagnose if an explicit lambda capture is unused.
5543  void DiagnoseUnusedLambdaCapture(const sema::LambdaScopeInfo::Capture &From);
5544 
5545  /// \brief Complete a lambda-expression having processed and attached the
5546  /// lambda body.
5547  ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
5548  sema::LambdaScopeInfo *LSI);
5549 
5550  /// Get the return type to use for a lambda's conversion function(s) to
5551  /// function pointer type, given the type of the call operator.
5552  QualType
5553  getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType);
5554 
5555  /// \brief Define the "body" of the conversion from a lambda object to a
5556  /// function pointer.
5557  ///
5558  /// This routine doesn't actually define a sensible body; rather, it fills
5559  /// in the initialization expression needed to copy the lambda object into
5560  /// the block, and IR generation actually generates the real body of the
5561  /// block pointer conversion.
5562  void DefineImplicitLambdaToFunctionPointerConversion(
5563  SourceLocation CurrentLoc, CXXConversionDecl *Conv);
5564 
5565  /// \brief Define the "body" of the conversion from a lambda object to a
5566  /// block pointer.
5567  ///
5568  /// This routine doesn't actually define a sensible body; rather, it fills
5569  /// in the initialization expression needed to copy the lambda object into
5570  /// the block, and IR generation actually generates the real body of the
5571  /// block pointer conversion.
5572  void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,
5573  CXXConversionDecl *Conv);
5574 
5575  ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
5576  SourceLocation ConvLocation,
5577  CXXConversionDecl *Conv,
5578  Expr *Src);
5579 
5580  // ParseObjCStringLiteral - Parse Objective-C string literals.
5581  ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
5582  ArrayRef<Expr *> Strings);
5583 
5584  ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
5585 
5586  /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
5587  /// numeric literal expression. Type of the expression will be "NSNumber *"
5588  /// or "id" if NSNumber is unavailable.
5589  ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
5590  ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,
5591  bool Value);
5592  ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);
5593 
5594  /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the
5595  /// '@' prefixed parenthesized expression. The type of the expression will
5596  /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type
5597  /// of ValueType, which is allowed to be a built-in numeric type, "char *",
5598  /// "const char *" or C structure with attribute 'objc_boxable'.
5599  ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
5600 
5601  ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
5602  Expr *IndexExpr,
5603  ObjCMethodDecl *getterMethod,
5604  ObjCMethodDecl *setterMethod);
5605 
5606  ExprResult BuildObjCDictionaryLiteral(SourceRange SR,
5608 
5609  ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,
5610  TypeSourceInfo *EncodedTypeInfo,
5611  SourceLocation RParenLoc);
5612  ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
5613  CXXConversionDecl *Method,
5614  bool HadMultipleCandidates);
5615 
5616  ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
5617  SourceLocation EncodeLoc,
5618  SourceLocation LParenLoc,
5619  ParsedType Ty,
5620  SourceLocation RParenLoc);
5621 
5622  /// ParseObjCSelectorExpression - Build selector expression for \@selector
5623  ExprResult ParseObjCSelectorExpression(Selector Sel,
5624  SourceLocation AtLoc,
5625  SourceLocation SelLoc,
5626  SourceLocation LParenLoc,
5627  SourceLocation RParenLoc,
5628  bool WarnMultipleSelectors);
5629 
5630  /// ParseObjCProtocolExpression - Build protocol expression for \@protocol
5631  ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
5632  SourceLocation AtLoc,
5633  SourceLocation ProtoLoc,
5634  SourceLocation LParenLoc,
5635  SourceLocation ProtoIdLoc,
5636  SourceLocation RParenLoc);
5637 
5638  //===--------------------------------------------------------------------===//
5639  // C++ Declarations
5640  //
5641  Decl *ActOnStartLinkageSpecification(Scope *S,
5642  SourceLocation ExternLoc,
5643  Expr *LangStr,
5644  SourceLocation LBraceLoc);
5645  Decl *ActOnFinishLinkageSpecification(Scope *S,
5646  Decl *LinkageSpec,
5647  SourceLocation RBraceLoc);
5648 
5649 
5650  //===--------------------------------------------------------------------===//
5651  // C++ Classes
5652  //
5653  bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
5654  const CXXScopeSpec *SS = nullptr);
5655  bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);
5656 
5657  bool ActOnAccessSpecifier(AccessSpecifier Access,
5658  SourceLocation ASLoc,
5659  SourceLocation ColonLoc,
5660  AttributeList *Attrs = nullptr);
5661 
5662  NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
5663  Declarator &D,
5664  MultiTemplateParamsArg TemplateParameterLists,
5665  Expr *BitfieldWidth, const VirtSpecifiers &VS,
5666  InClassInitStyle InitStyle);
5667 
5668  void ActOnStartCXXInClassMemberInitializer();
5669  void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,
5670  SourceLocation EqualLoc,
5671  Expr *Init);
5672 
5673  MemInitResult ActOnMemInitializer(Decl *ConstructorD,
5674  Scope *S,
5675  CXXScopeSpec &SS,
5676  IdentifierInfo *MemberOrBase,
5677  ParsedType TemplateTypeTy,
5678  const DeclSpec &DS,
5679  SourceLocation IdLoc,
5680  SourceLocation LParenLoc,
5681  ArrayRef<Expr *> Args,
5682  SourceLocation RParenLoc,
5683  SourceLocation EllipsisLoc);
5684 
5685  MemInitResult ActOnMemInitializer(Decl *ConstructorD,
5686  Scope *S,
5687  CXXScopeSpec &SS,
5688  IdentifierInfo *MemberOrBase,
5689  ParsedType TemplateTypeTy,
5690  const DeclSpec &DS,
5691  SourceLocation IdLoc,
5692  Expr *InitList,
5693  SourceLocation EllipsisLoc);
5694 
5695  MemInitResult BuildMemInitializer(Decl *ConstructorD,
5696  Scope *S,
5697  CXXScopeSpec &SS,
5698  IdentifierInfo *MemberOrBase,
5699  ParsedType TemplateTypeTy,
5700  const DeclSpec &DS,
5701  SourceLocation IdLoc,
5702  Expr *Init,
5703  SourceLocation EllipsisLoc);
5704 
5705  MemInitResult BuildMemberInitializer(ValueDecl *Member,
5706  Expr *Init,
5707  SourceLocation IdLoc);
5708 
5709  MemInitResult BuildBaseInitializer(QualType BaseType,
5710  TypeSourceInfo *BaseTInfo,
5711  Expr *Init,
5712  CXXRecordDecl *ClassDecl,
5713  SourceLocation EllipsisLoc);
5714 
5715  MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,
5716  Expr *Init,
5717  CXXRecordDecl *ClassDecl);
5718 
5719  bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,
5720  CXXCtorInitializer *Initializer);
5721 
5722  bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
5723  ArrayRef<CXXCtorInitializer *> Initializers = None);
5724 
5725  void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);
5726 
5727 
5728  /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,
5729  /// mark all the non-trivial destructors of its members and bases as
5730  /// referenced.
5731  void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,
5732  CXXRecordDecl *Record);
5733 
5734  /// \brief The list of classes whose vtables have been used within
5735  /// this translation unit, and the source locations at which the
5736  /// first use occurred.
5737  typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;
5738 
5739  /// \brief The list of vtables that are required but have not yet been
5740  /// materialized.
5742 
5743  /// \brief The set of classes whose vtables have been used within
5744  /// this translation unit, and a bit that will be true if the vtable is
5745  /// required to be emitted (otherwise, it should be emitted only if needed
5746  /// by code generation).
5747  llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;
5748 
5749  /// \brief Load any externally-stored vtable uses.
5750  void LoadExternalVTableUses();
5751 
5752  /// \brief Note that the vtable for the given class was used at the
5753  /// given location.
5754  void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
5755  bool DefinitionRequired = false);
5756 
5757  /// \brief Mark the exception specifications of all virtual member functions
5758  /// in the given class as needed.
5759  void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
5760  const CXXRecordDecl *RD);
5761 
5762  /// MarkVirtualMembersReferenced - Will mark all members of the given
5763  /// CXXRecordDecl referenced.
5764  void MarkVirtualMembersReferenced(SourceLocation Loc,
5765  const CXXRecordDecl *RD);
5766 
5767  /// \brief Define all of the vtables that have been used in this
5768  /// translation unit and reference any virtual members used by those
5769  /// vtables.
5770  ///
5771  /// \returns true if any work was done, false otherwise.
5772  bool DefineUsedVTables();
5773 
5774  void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
5775 
5776  void ActOnMemInitializers(Decl *ConstructorDecl,
5777  SourceLocation ColonLoc,
5779  bool AnyErrors);
5780 
5781  /// \brief Check class-level dllimport/dllexport attribute. The caller must
5782  /// ensure that referenceDLLExportedClassMethods is called some point later
5783  /// when all outer classes of Class are complete.
5784  void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
5785 
5786  void referenceDLLExportedClassMethods();
5787 
5788  void propagateDLLAttrToBaseClassTemplate(
5789  CXXRecordDecl *Class, Attr *ClassAttr,
5790  ClassTemplateSpecializationDecl *BaseTemplateSpec,
5791  SourceLocation BaseLoc);
5792 
5793  void CheckCompletedCXXClass(CXXRecordDecl *Record);
5794  void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
5795  Decl *TagDecl,
5796  SourceLocation LBrac,
5797  SourceLocation RBrac,
5798  AttributeList *AttrList);
5799  void ActOnFinishCXXMemberDecls();
5800  void ActOnFinishCXXNonNestedClass(Decl *D);
5801 
5802  void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);
5803  unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template);
5804  void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);
5805  void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
5806  void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);
5807  void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);
5808  void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
5809  void ActOnFinishDelayedMemberInitializers(Decl *Record);
5810  void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
5811  CachedTokens &Toks);
5812  void UnmarkAsLateParsedTemplate(FunctionDecl *FD);
5813  bool IsInsideALocalClassWithinATemplateFunction();
5814 
5815  Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
5816  Expr *AssertExpr,
5817  Expr *AssertMessageExpr,
5818  SourceLocation RParenLoc);
5819  Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
5820  Expr *AssertExpr,
5821  StringLiteral *AssertMessageExpr,
5822  SourceLocation RParenLoc,
5823  bool Failed);
5824 
5825  FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,
5826  SourceLocation FriendLoc,
5827  TypeSourceInfo *TSInfo);
5828  Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
5829  MultiTemplateParamsArg TemplateParams);
5830  NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,
5831  MultiTemplateParamsArg TemplateParams);
5832 
5833  QualType CheckConstructorDeclarator(Declarator &D, QualType R,
5834  StorageClass& SC);
5835  void CheckConstructor(CXXConstructorDecl *Constructor);
5836  QualType CheckDestructorDeclarator(Declarator &D, QualType R,
5837  StorageClass& SC);
5838  bool CheckDestructor(CXXDestructorDecl *Destructor);
5839  void CheckConversionDeclarator(Declarator &D, QualType &R,
5840  StorageClass& SC);
5841  Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
5842  void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
5843  StorageClass &SC);
5844  void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
5845 
5846  void CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD);
5847  void CheckExplicitlyDefaultedMemberExceptionSpec(CXXMethodDecl *MD,
5848  const FunctionProtoType *T);
5849  void CheckDelayedMemberExceptionSpecs();
5850 
5851  //===--------------------------------------------------------------------===//
5852  // C++ Derived Classes
5853  //
5854 
5855  /// ActOnBaseSpecifier - Parsed a base specifier
5856  CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
5857  SourceRange SpecifierRange,
5858  bool Virtual, AccessSpecifier Access,
5859  TypeSourceInfo *TInfo,
5860  SourceLocation EllipsisLoc);
5861 
5862  BaseResult ActOnBaseSpecifier(Decl *classdecl,
5863  SourceRange SpecifierRange,
5864  ParsedAttributes &Attrs,
5865  bool Virtual, AccessSpecifier Access,
5866  ParsedType basetype,
5867  SourceLocation BaseLoc,
5868  SourceLocation EllipsisLoc);
5869 
5870  bool AttachBaseSpecifiers(CXXRecordDecl *Class,
5872  void ActOnBaseSpecifiers(Decl *ClassDecl,
5874 
5875  bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
5876  bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
5877  CXXBasePaths &Paths);
5878 
5879  // FIXME: I don't like this name.
5880  void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);
5881 
5882  bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
5883  SourceLocation Loc, SourceRange Range,
5884  CXXCastPath *BasePath = nullptr,
5885  bool IgnoreAccess = false);
5886  bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
5887  unsigned InaccessibleBaseID,
5888  unsigned AmbigiousBaseConvID,
5889  SourceLocation Loc, SourceRange Range,
5890  DeclarationName Name,
5891  CXXCastPath *BasePath,
5892  bool IgnoreAccess = false);
5893 
5894  std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
5895 
5896  bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
5897  const CXXMethodDecl *Old);
5898 
5899  /// CheckOverridingFunctionReturnType - Checks whether the return types are
5900  /// covariant, according to C++ [class.virtual]p5.
5901  bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
5902  const CXXMethodDecl *Old);
5903 
5904  /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
5905  /// spec is a subset of base spec.
5906  bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
5907  const CXXMethodDecl *Old);
5908 
5909  bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
5910 
5911  /// CheckOverrideControl - Check C++11 override control semantics.
5912  void CheckOverrideControl(NamedDecl *D);
5913 
5914  /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was
5915  /// not used in the declaration of an overriding method.
5916  void DiagnoseAbsenceOfOverrideControl(NamedDecl *D);
5917 
5918  /// CheckForFunctionMarkedFinal - Checks whether a virtual member function
5919  /// overrides a virtual member function marked 'final', according to
5920  /// C++11 [class.virtual]p4.
5921  bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
5922  const CXXMethodDecl *Old);
5923 
5924 
5925  //===--------------------------------------------------------------------===//
5926  // C++ Access Control
5927  //
5928 
5933  AR_delayed
5934  };
5935 
5936  bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
5937  NamedDecl *PrevMemberDecl,
5938  AccessSpecifier LexicalAS);
5939 
5940  AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
5941  DeclAccessPair FoundDecl);
5942  AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
5943  DeclAccessPair FoundDecl);
5944  AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,
5945  SourceRange PlacementRange,
5946  CXXRecordDecl *NamingClass,
5947  DeclAccessPair FoundDecl,
5948  bool Diagnose = true);
5949  AccessResult CheckConstructorAccess(SourceLocation Loc,
5950  CXXConstructorDecl *D,
5951  DeclAccessPair FoundDecl,
5952  const InitializedEntity &Entity,
5953  bool IsCopyBindingRefToTemp = false);
5954  AccessResult CheckConstructorAccess(SourceLocation Loc,
5955  CXXConstructorDecl *D,
5956  DeclAccessPair FoundDecl,
5957  const InitializedEntity &Entity,
5958  const PartialDiagnostic &PDiag);
5959  AccessResult CheckDestructorAccess(SourceLocation Loc,
5960  CXXDestructorDecl *Dtor,
5961  const PartialDiagnostic &PDiag,
5962  QualType objectType = QualType());
5963  AccessResult CheckFriendAccess(NamedDecl *D);
5964  AccessResult CheckMemberAccess(SourceLocation UseLoc,
5965  CXXRecordDecl *NamingClass,
5966  DeclAccessPair Found);
5967  AccessResult CheckMemberOperatorAccess(SourceLocation Loc,
5968  Expr *ObjectExpr,
5969  Expr *ArgExpr,
5970  DeclAccessPair FoundDecl);
5971  AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
5972  DeclAccessPair FoundDecl);
5973  AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,
5974  QualType Base, QualType Derived,
5975  const CXXBasePath &Path,
5976  unsigned DiagID,
5977  bool ForceCheck = false,
5978  bool ForceUnprivileged = false);
5979  void CheckLookupAccess(const LookupResult &R);
5980  bool IsSimplyAccessible(NamedDecl *decl, DeclContext *Ctx);
5981  bool isSpecialMemberAccessibleForDeletion(CXXMethodDecl *decl,
5982  AccessSpecifier access,
5983  QualType objectType);
5984 
5985  void HandleDependentAccessCheck(const DependentDiagnostic &DD,
5986  const MultiLevelTemplateArgumentList &TemplateArgs);
5987  void PerformDependentDiagnostics(const DeclContext *Pattern,
5988  const MultiLevelTemplateArgumentList &TemplateArgs);
5989 
5990  void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
5991 
5992  /// \brief When true, access checking violations are treated as SFINAE
5993  /// failures rather than hard errors.
5995 
5997  AbstractNone = -1,
6004  AbstractArrayType
6005  };
6006 
6007  bool isAbstractType(SourceLocation Loc, QualType T);
6008  bool RequireNonAbstractType(SourceLocation Loc, QualType T,
6009  TypeDiagnoser &Diagnoser);
6010  template <typename... Ts>
6011  bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
6012  const Ts &...Args) {
6013  BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
6014  return RequireNonAbstractType(Loc, T, Diagnoser);
6015  }
6016 
6017  void DiagnoseAbstractType(const CXXRecordDecl *RD);
6018 
6019  //===--------------------------------------------------------------------===//
6020  // C++ Overloaded Operators [C++ 13.5]
6021  //
6022 
6023  bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
6024 
6025  bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);
6026 
6027  //===--------------------------------------------------------------------===//
6028  // C++ Templates [C++ 14]
6029  //
6030  void FilterAcceptableTemplateNames(LookupResult &R,
6031  bool AllowFunctionTemplates = true);
6032  bool hasAnyAcceptableTemplateNames(LookupResult &R,
6033  bool AllowFunctionTemplates = true);
6034 
6035  void LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS,
6036  QualType ObjectType, bool EnteringContext,
6037  bool &MemberOfUnknownSpecialization);
6038 
6039  TemplateNameKind isTemplateName(Scope *S,
6040  CXXScopeSpec &SS,
6041  bool hasTemplateKeyword,
6042  UnqualifiedId &Name,
6043  ParsedType ObjectType,
6044  bool EnteringContext,
6045  TemplateTy &Template,
6046  bool &MemberOfUnknownSpecialization);
6047 
6048  /// Determine whether a particular identifier might be the name in a C++1z
6049  /// deduction-guide declaration.
6050  bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
6051  SourceLocation NameLoc,
6052  ParsedTemplateTy *Template = nullptr);
6053 
6054  bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
6055  SourceLocation IILoc,
6056  Scope *S,
6057  const CXXScopeSpec *SS,
6058  TemplateTy &SuggestedTemplate,
6059  TemplateNameKind &SuggestedKind);
6060 
6061  bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
6062  NamedDecl *Instantiation,
6063  bool InstantiatedFromMember,
6064  const NamedDecl *Pattern,
6065  const NamedDecl *PatternDef,
6067  bool Complain = true);
6068 
6069  void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
6070  TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);
6071 
6072  NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,
6073  SourceLocation EllipsisLoc,
6074  SourceLocation KeyLoc,
6075  IdentifierInfo *ParamName,
6076  SourceLocation ParamNameLoc,
6077  unsigned Depth, unsigned Position,
6078  SourceLocation EqualLoc,
6079  ParsedType DefaultArg);
6080 
6081  QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
6082  SourceLocation Loc);
6083  QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
6084 
6085  NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
6086  unsigned Depth,
6087  unsigned Position,
6088  SourceLocation EqualLoc,
6089  Expr *DefaultArg);
6090  NamedDecl *ActOnTemplateTemplateParameter(Scope *S,
6091  SourceLocation TmpLoc,
6092  TemplateParameterList *Params,
6093  SourceLocation EllipsisLoc,
6094  IdentifierInfo *ParamName,
6095  SourceLocation ParamNameLoc,
6096  unsigned Depth,
6097  unsigned Position,
6098  SourceLocation EqualLoc,
6099  ParsedTemplateArgument DefaultArg);
6100 
6102  ActOnTemplateParameterList(unsigned Depth,
6103  SourceLocation ExportLoc,
6104  SourceLocation TemplateLoc,
6105  SourceLocation LAngleLoc,
6106  ArrayRef<NamedDecl *> Params,
6107  SourceLocation RAngleLoc,
6108  Expr *RequiresClause);
6109 
6110  /// \brief The context in which we are checking a template parameter list.
6119  TPC_TypeAliasTemplate
6120  };
6121 
6122  bool CheckTemplateParameterList(TemplateParameterList *NewParams,
6123  TemplateParameterList *OldParams,
6125  TemplateParameterList *MatchTemplateParametersToScopeSpecifier(
6126  SourceLocation DeclStartLoc, SourceLocation DeclLoc,
6127  const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,
6129  bool IsFriend, bool &IsMemberSpecialization, bool &Invalid);
6130 
6131  DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
6132  SourceLocation KWLoc, CXXScopeSpec &SS,
6133  IdentifierInfo *Name, SourceLocation NameLoc,
6134  AttributeList *Attr,
6135  TemplateParameterList *TemplateParams,
6136  AccessSpecifier AS,
6137  SourceLocation ModulePrivateLoc,
6138  SourceLocation FriendLoc,
6139  unsigned NumOuterTemplateParamLists,
6140  TemplateParameterList **OuterTemplateParamLists,
6141  SkipBodyInfo *SkipBody = nullptr);
6142 
6143  TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
6144  QualType NTTPType,
6145  SourceLocation Loc);
6146 
6147  void translateTemplateArguments(const ASTTemplateArgsPtr &In,
6149 
6150  void NoteAllFoundTemplates(TemplateName Name);
6151 
6152  QualType CheckTemplateIdType(TemplateName Template,
6153  SourceLocation TemplateLoc,
6154  TemplateArgumentListInfo &TemplateArgs);
6155 
6156  TypeResult
6157  ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
6158  TemplateTy Template, IdentifierInfo *TemplateII,
6159  SourceLocation TemplateIILoc,
6160  SourceLocation LAngleLoc,
6161  ASTTemplateArgsPtr TemplateArgs,
6162  SourceLocation RAngleLoc,
6163  bool IsCtorOrDtorName = false,
6164  bool IsClassName = false);
6165 
6166  /// \brief Parsed an elaborated-type-specifier that refers to a template-id,
6167  /// such as \c class T::template apply<U>.
6168  TypeResult ActOnTagTemplateIdType(TagUseKind TUK,
6169  TypeSpecifierType TagSpec,
6170  SourceLocation TagLoc,
6171  CXXScopeSpec &SS,
6172  SourceLocation TemplateKWLoc,
6173  TemplateTy TemplateD,
6174  SourceLocation TemplateLoc,
6175  SourceLocation LAngleLoc,
6176  ASTTemplateArgsPtr TemplateArgsIn,
6177  SourceLocation RAngleLoc);
6178 
6179  DeclResult ActOnVarTemplateSpecialization(
6180  Scope *S, Declarator &D, TypeSourceInfo *DI,
6181  SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
6183 
6184  DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
6185  SourceLocation TemplateLoc,
6186  SourceLocation TemplateNameLoc,
6187  const TemplateArgumentListInfo &TemplateArgs);
6188 
6189  ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
6190  const DeclarationNameInfo &NameInfo,
6191  VarTemplateDecl *Template,
6192  SourceLocation TemplateLoc,
6193  const TemplateArgumentListInfo *TemplateArgs);
6194 
6195  ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
6196  SourceLocation TemplateKWLoc,
6197  LookupResult &R,
6198  bool RequiresADL,
6199  const TemplateArgumentListInfo *TemplateArgs);
6200 
6201  ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
6202  SourceLocation TemplateKWLoc,
6203  const DeclarationNameInfo &NameInfo,
6204  const TemplateArgumentListInfo *TemplateArgs);
6205 
6206  TemplateNameKind ActOnDependentTemplateName(
6207  Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
6208  UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,
6209  TemplateTy &Template, bool AllowInjectedClassName = false);
6210 
6211  DeclResult
6212  ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
6213  SourceLocation KWLoc,
6214  SourceLocation ModulePrivateLoc,
6215  TemplateIdAnnotation &TemplateId,
6216  AttributeList *Attr,
6217  MultiTemplateParamsArg TemplateParameterLists,
6218  SkipBodyInfo *SkipBody = nullptr);
6219 
6220  bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,
6221  TemplateDecl *PrimaryTemplate,
6222  unsigned NumExplicitArgs,
6224  void CheckTemplatePartialSpecialization(
6226  void CheckTemplatePartialSpecialization(
6228 
6229  Decl *ActOnTemplateDeclarator(Scope *S,
6230  MultiTemplateParamsArg TemplateParameterLists,
6231  Declarator &D);
6232 
6233  bool
6234  CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
6236  NamedDecl *PrevDecl,
6238  SourceLocation PrevPtOfInstantiation,
6239  bool &SuppressNew);
6240 
6241  bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
6242  const TemplateArgumentListInfo &ExplicitTemplateArgs,
6243  LookupResult &Previous);
6244 
6245  bool CheckFunctionTemplateSpecialization(FunctionDecl *FD,
6246  TemplateArgumentListInfo *ExplicitTemplateArgs,
6247  LookupResult &Previous);
6248  bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
6249  void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
6250 
6251  DeclResult
6252  ActOnExplicitInstantiation(Scope *S,
6253  SourceLocation ExternLoc,
6254  SourceLocation TemplateLoc,
6255  unsigned TagSpec,
6256  SourceLocation KWLoc,
6257  const CXXScopeSpec &SS,
6258  TemplateTy Template,
6259  SourceLocation TemplateNameLoc,
6260  SourceLocation LAngleLoc,
6261  ASTTemplateArgsPtr TemplateArgs,
6262  SourceLocation RAngleLoc,
6263  AttributeList *Attr);
6264 
6265  DeclResult
6266  ActOnExplicitInstantiation(Scope *S,
6267  SourceLocation ExternLoc,
6268  SourceLocation TemplateLoc,
6269  unsigned TagSpec,
6270  SourceLocation KWLoc,
6271  CXXScopeSpec &SS,
6272  IdentifierInfo *Name,
6273  SourceLocation NameLoc,
6274  AttributeList *Attr);
6275 
6276  DeclResult ActOnExplicitInstantiation(Scope *S,
6277  SourceLocation ExternLoc,
6278  SourceLocation TemplateLoc,
6279  Declarator &D);
6280 
6282  SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
6283  SourceLocation TemplateLoc,
6284  SourceLocation RAngleLoc,
6285  Decl *Param,
6287  &Converted,
6288  bool &HasDefaultArg);
6289 
6290  /// \brief Specifies the context in which a particular template
6291  /// argument is being checked.
6293  /// \brief The template argument was specified in the code or was
6294  /// instantiated with some deduced template arguments.
6296 
6297  /// \brief The template argument was deduced via template argument
6298  /// deduction.
6300 
6301  /// \brief The template argument was deduced from an array bound
6302  /// via template argument deduction.
6303  CTAK_DeducedFromArrayBound
6304  };
6305 
6306  bool CheckTemplateArgument(NamedDecl *Param,
6307  TemplateArgumentLoc &Arg,
6308  NamedDecl *Template,
6309  SourceLocation TemplateLoc,
6310  SourceLocation RAngleLoc,
6311  unsigned ArgumentPackIndex,
6313  CheckTemplateArgumentKind CTAK = CTAK_Specified);
6314 
6315  /// \brief Check that the given template arguments can be be provided to
6316  /// the given template, converting the arguments along the way.
6317  ///
6318  /// \param Template The template to which the template arguments are being
6319  /// provided.
6320  ///
6321  /// \param TemplateLoc The location of the template name in the source.
6322  ///
6323  /// \param TemplateArgs The list of template arguments. If the template is
6324  /// a template template parameter, this function may extend the set of
6325  /// template arguments to also include substituted, defaulted template
6326  /// arguments.
6327  ///
6328  /// \param PartialTemplateArgs True if the list of template arguments is
6329  /// intentionally partial, e.g., because we're checking just the initial
6330  /// set of template arguments.
6331  ///
6332  /// \param Converted Will receive the converted, canonicalized template
6333  /// arguments.
6334  ///
6335  /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
6336  /// contain the converted forms of the template arguments as written.
6337  /// Otherwise, \p TemplateArgs will not be modified.
6338  ///
6339  /// \returns true if an error occurred, false otherwise.
6340  bool CheckTemplateArgumentList(TemplateDecl *Template,
6341  SourceLocation TemplateLoc,
6342  TemplateArgumentListInfo &TemplateArgs,
6343  bool PartialTemplateArgs,
6345  bool UpdateArgsWithConversions = true);
6346 
6347  bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
6348  TemplateArgumentLoc &Arg,
6350 
6351  bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
6352  TypeSourceInfo *Arg);
6353  ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
6354  QualType InstantiatedParamType, Expr *Arg,
6355  TemplateArgument &Converted,
6356  CheckTemplateArgumentKind CTAK = CTAK_Specified);
6357  bool CheckTemplateArgument(TemplateTemplateParmDecl *Param,
6358  TemplateArgumentLoc &Arg,
6359  unsigned ArgumentPackIndex);
6360 
6361  ExprResult
6362  BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
6363  QualType ParamType,
6364  SourceLocation Loc);
6365  ExprResult
6366  BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
6367  SourceLocation Loc);
6368 
6369  /// \brief Enumeration describing how template parameter lists are compared
6370  /// for equality.
6372  /// \brief We are matching the template parameter lists of two templates
6373  /// that might be redeclarations.
6374  ///
6375  /// \code
6376  /// template<typename T> struct X;
6377  /// template<typename T> struct X;
6378  /// \endcode
6380 
6381  /// \brief We are matching the template parameter lists of two template
6382  /// template parameters as part of matching the template parameter lists
6383  /// of two templates that might be redeclarations.
6384  ///
6385  /// \code
6386  /// template<template<int I> class TT> struct X;
6387  /// template<template<int Value> class Other> struct X;
6388  /// \endcode
6390 
6391  /// \brief We are matching the template parameter lists of a template
6392  /// template argument against the template parameter lists of a template
6393  /// template parameter.
6394  ///
6395  /// \code
6396  /// template<template<int Value> class Metafun> struct X;
6397  /// template<int Value> struct integer_c;
6398  /// X<integer_c> xic;
6399  /// \endcode
6400  TPL_TemplateTemplateArgumentMatch
6401  };
6402 
6403  bool TemplateParameterListsAreEqual(TemplateParameterList *New,
6404  TemplateParameterList *Old,
6405  bool Complain,
6407  SourceLocation TemplateArgLoc
6408  = SourceLocation());
6409 
6410  bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
6411 
6412  /// \brief Called when the parser has parsed a C++ typename
6413  /// specifier, e.g., "typename T::type".
6414  ///
6415  /// \param S The scope in which this typename type occurs.
6416  /// \param TypenameLoc the location of the 'typename' keyword
6417  /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
6418  /// \param II the identifier we're retrieving (e.g., 'type' in the example).
6419  /// \param IdLoc the location of the identifier.
6420  TypeResult
6421  ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
6422  const CXXScopeSpec &SS, const IdentifierInfo &II,
6423  SourceLocation IdLoc);
6424 
6425  /// \brief Called when the parser has parsed a C++ typename
6426  /// specifier that ends in a template-id, e.g.,
6427  /// "typename MetaFun::template apply<T1, T2>".
6428  ///
6429  /// \param S The scope in which this typename type occurs.
6430  /// \param TypenameLoc the location of the 'typename' keyword
6431  /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
6432  /// \param TemplateLoc the location of the 'template' keyword, if any.
6433  /// \param TemplateName The template name.
6434  /// \param TemplateII The identifier used to name the template.
6435  /// \param TemplateIILoc The location of the template name.
6436  /// \param LAngleLoc The location of the opening angle bracket ('<').
6437  /// \param TemplateArgs The template arguments.
6438  /// \param RAngleLoc The location of the closing angle bracket ('>').
6439  TypeResult
6440  ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
6441  const CXXScopeSpec &SS,
6442  SourceLocation TemplateLoc,
6443  TemplateTy TemplateName,
6444  IdentifierInfo *TemplateII,
6445  SourceLocation TemplateIILoc,
6446  SourceLocation LAngleLoc,
6447  ASTTemplateArgsPtr TemplateArgs,
6448  SourceLocation RAngleLoc);
6449 
6450  QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
6451  SourceLocation KeywordLoc,
6452  NestedNameSpecifierLoc QualifierLoc,
6453  const IdentifierInfo &II,
6454  SourceLocation IILoc);
6455 
6456  TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
6457  SourceLocation Loc,
6458  DeclarationName Name);
6459  bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);
6460 
6461  ExprResult RebuildExprInCurrentInstantiation(Expr *E);
6462  bool RebuildTemplateParamsInCurrentInstantiation(
6463  TemplateParameterList *Params);
6464 
6465  std::string
6466  getTemplateArgumentBindingsText(const TemplateParameterList *Params,
6467  const TemplateArgumentList &Args);
6468 
6469  std::string
6470  getTemplateArgumentBindingsText(const TemplateParameterList *Params,
6471  const TemplateArgument *Args,
6472  unsigned NumArgs);
6473 
6474  //===--------------------------------------------------------------------===//
6475  // C++ Variadic Templates (C++0x [temp.variadic])
6476  //===--------------------------------------------------------------------===//
6477 
6478  /// Determine whether an unexpanded parameter pack might be permitted in this
6479  /// location. Useful for error recovery.
6480  bool isUnexpandedParameterPackPermitted();
6481 
6482  /// \brief The context in which an unexpanded parameter pack is
6483  /// being diagnosed.
6484  ///
6485  /// Note that the values of this enumeration line up with the first
6486  /// argument to the \c err_unexpanded_parameter_pack diagnostic.
6488  /// \brief An arbitrary expression.
6489  UPPC_Expression = 0,
6490 
6491  /// \brief The base type of a class type.
6493 
6494  /// \brief The type of an arbitrary declaration.
6496 
6497  /// \brief The type of a data member.
6499 
6500  /// \brief The size of a bit-field.
6502 
6503  /// \brief The expression in a static assertion.
6505 
6506  /// \brief The fixed underlying type of an enumeration.
6508 
6509  /// \brief The enumerator value.
6511 
6512  /// \brief A using declaration.
6514 
6515  /// \brief A friend declaration.
6517 
6518  /// \brief A declaration qualifier.
6520 
6521  /// \brief An initializer.
6523 
6524  /// \brief A default argument.
6526 
6527  /// \brief The type of a non-type template parameter.
6529 
6530  /// \brief The type of an exception.
6532 
6533  /// \brief Partial specialization.
6535 
6536  /// \brief Microsoft __if_exists.
6538 
6539  /// \brief Microsoft __if_not_exists.
6541 
6542  /// \brief Lambda expression.
6544 
6545  /// \brief Block expression,
6546  UPPC_Block
6547  };
6548 
6549  /// \brief Diagnose unexpanded parameter packs.
6550  ///
6551  /// \param Loc The location at which we should emit the diagnostic.
6552  ///
6553  /// \param UPPC The context in which we are diagnosing unexpanded
6554  /// parameter packs.
6555  ///
6556  /// \param Unexpanded the set of unexpanded parameter packs.
6557  ///
6558  /// \returns true if an error occurred, false otherwise.
6562 
6563  /// \brief If the given type contains an unexpanded parameter pack,
6564  /// diagnose the error.
6565  ///
6566  /// \param Loc The source location where a diagnostc should be emitted.
6567  ///
6568  /// \param T The type that is being checked for unexpanded parameter
6569  /// packs.
6570  ///
6571  /// \returns true if an error occurred, false otherwise.
6572  bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,
6574 
6575  /// \brief If the given expression contains an unexpanded parameter
6576  /// pack, diagnose the error.
6577  ///
6578  /// \param E The expression that is being checked for unexpanded
6579  /// parameter packs.
6580  ///
6581  /// \returns true if an error occurred, false otherwise.
6582  bool DiagnoseUnexpandedParameterPack(Expr *E,
6583  UnexpandedParameterPackContext UPPC = UPPC_Expression);
6584 
6585  /// \brief If the given nested-name-specifier contains an unexpanded
6586  /// parameter pack, diagnose the error.
6587  ///
6588  /// \param SS The nested-name-specifier that is being checked for
6589  /// unexpanded parameter packs.
6590  ///
6591  /// \returns true if an error occurred, false otherwise.
6592  bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
6594 
6595  /// \brief If the given name contains an unexpanded parameter pack,
6596  /// diagnose the error.
6597  ///
6598  /// \param NameInfo The name (with source location information) that
6599  /// is being checked for unexpanded parameter packs.
6600  ///
6601  /// \returns true if an error occurred, false otherwise.
6602  bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
6604 
6605  /// \brief If the given template name contains an unexpanded parameter pack,
6606  /// diagnose the error.
6607  ///
6608  /// \param Loc The location of the template name.
6609  ///
6610  /// \param Template The template name that is being checked for unexpanded
6611  /// parameter packs.
6612  ///
6613  /// \returns true if an error occurred, false otherwise.
6614  bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,
6615  TemplateName Template,
6617 
6618  /// \brief If the given template argument contains an unexpanded parameter
6619  /// pack, diagnose the error.
6620  ///
6621  /// \param Arg The template argument that is being checked for unexpanded
6622  /// parameter packs.
6623  ///
6624  /// \returns true if an error occurred, false otherwise.
6625  bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
6627 
6628  /// \brief Collect the set of unexpanded parameter packs within the given
6629  /// template argument.
6630  ///
6631  /// \param Arg The template argument that will be traversed to find
6632  /// unexpanded parameter packs.
6635 
6636  /// \brief Collect the set of unexpanded parameter packs within the given
6637  /// template argument.
6638  ///
6639  /// \param Arg The template argument that will be traversed to find
6640  /// unexpanded parameter packs.
6643 
6644  /// \brief Collect the set of unexpanded parameter packs within the given
6645  /// type.
6646  ///
6647  /// \param T The type that will be traversed to find
6648  /// unexpanded parameter packs.
6651 
6652  /// \brief Collect the set of unexpanded parameter packs within the given
6653  /// type.
6654  ///
6655  /// \param TL The type that will be traversed to find
6656  /// unexpanded parameter packs.
6659 
6660  /// \brief Collect the set of unexpanded parameter packs within the given
6661  /// nested-name-specifier.
6662  ///
6663  /// \param NNS The nested-name-specifier that will be traversed to find
6664  /// unexpanded parameter packs.
6667 
6668  /// \brief Collect the set of unexpanded parameter packs within the given
6669  /// name.
6670  ///
6671  /// \param NameInfo The name that will be traversed to find
6672  /// unexpanded parameter packs.
6675 
6676  /// \brief Invoked when parsing a template argument followed by an
6677  /// ellipsis, which creates a pack expansion.
6678  ///
6679  /// \param Arg The template argument preceding the ellipsis, which
6680  /// may already be invalid.
6681  ///
6682  /// \param EllipsisLoc The location of the ellipsis.
6683  ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,
6684  SourceLocation EllipsisLoc);
6685 
6686  /// \brief Invoked when parsing a type followed by an ellipsis, which
6687  /// creates a pack expansion.
6688  ///
6689  /// \param Type The type preceding the ellipsis, which will become
6690  /// the pattern of the pack expansion.
6691  ///
6692  /// \param EllipsisLoc The location of the ellipsis.
6693  TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);
6694 
6695  /// \brief Construct a pack expansion type from the pattern of the pack
6696  /// expansion.
6697  TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,
6698  SourceLocation EllipsisLoc,
6699  Optional<unsigned> NumExpansions);
6700 
6701  /// \brief Construct a pack expansion type from the pattern of the pack
6702  /// expansion.
6703  QualType CheckPackExpansion(QualType Pattern,
6704  SourceRange PatternRange,
6705  SourceLocation EllipsisLoc,
6706  Optional<unsigned> NumExpansions);
6707 
6708  /// \brief Invoked when parsing an expression followed by an ellipsis, which
6709  /// creates a pack expansion.
6710  ///
6711  /// \param Pattern The expression preceding the ellipsis, which will become
6712  /// the pattern of the pack expansion.
6713  ///
6714  /// \param EllipsisLoc The location of the ellipsis.
6715  ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
6716 
6717  /// \brief Invoked when parsing an expression followed by an ellipsis, which
6718  /// creates a pack expansion.
6719  ///
6720  /// \param Pattern The expression preceding the ellipsis, which will become
6721  /// the pattern of the pack expansion.
6722  ///
6723  /// \param EllipsisLoc The location of the ellipsis.
6724  ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
6725  Optional<unsigned> NumExpansions);
6726 
6727  /// \brief Determine whether we could expand a pack expansion with the
6728  /// given set of parameter packs into separate arguments by repeatedly
6729  /// transforming the pattern.
6730  ///
6731  /// \param EllipsisLoc The location of the ellipsis that identifies the
6732  /// pack expansion.
6733  ///
6734  /// \param PatternRange The source range that covers the entire pattern of
6735  /// the pack expansion.
6736  ///
6737  /// \param Unexpanded The set of unexpanded parameter packs within the
6738  /// pattern.
6739  ///
6740  /// \param ShouldExpand Will be set to \c true if the transformer should
6741  /// expand the corresponding pack expansions into separate arguments. When
6742  /// set, \c NumExpansions must also be set.
6743  ///
6744  /// \param RetainExpansion Whether the caller should add an unexpanded
6745  /// pack expansion after all of the expanded arguments. This is used
6746  /// when extending explicitly-specified template argument packs per
6747  /// C++0x [temp.arg.explicit]p9.
6748  ///
6749  /// \param NumExpansions The number of separate arguments that will be in
6750  /// the expanded form of the corresponding pack expansion. This is both an
6751  /// input and an output parameter, which can be set by the caller if the
6752  /// number of expansions is known a priori (e.g., due to a prior substitution)
6753  /// and will be set by the callee when the number of expansions is known.
6754  /// The callee must set this value when \c ShouldExpand is \c true; it may
6755  /// set this value in other cases.
6756  ///
6757  /// \returns true if an error occurred (e.g., because the parameter packs
6758  /// are to be instantiated with arguments of different lengths), false
6759  /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
6760  /// must be set.
6761  bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
6762  SourceRange PatternRange,
6764  const MultiLevelTemplateArgumentList &TemplateArgs,
6765  bool &ShouldExpand,
6766  bool &RetainExpansion,
6767  Optional<unsigned> &NumExpansions);
6768 
6769  /// \brief Determine the number of arguments in the given pack expansion
6770  /// type.
6771  ///
6772  /// This routine assumes that the number of arguments in the expansion is
6773  /// consistent across all of the unexpanded parameter packs in its pattern.
6774  ///
6775  /// Returns an empty Optional if the type can't be expanded.
6776  Optional<unsigned> getNumArgumentsInExpansion(QualType T,
6777  const MultiLevelTemplateArgumentList &TemplateArgs);
6778 
6779  /// \brief Determine whether the given declarator contains any unexpanded
6780  /// parameter packs.
6781  ///
6782  /// This routine is used by the parser to disambiguate function declarators
6783  /// with an ellipsis prior to the ')', e.g.,
6784  ///
6785  /// \code
6786  /// void f(T...);
6787  /// \endcode
6788  ///
6789  /// To determine whether we have an (unnamed) function parameter pack or
6790  /// a variadic function.
6791  ///
6792  /// \returns true if the declarator contains any unexpanded parameter packs,
6793  /// false otherwise.
6794  bool containsUnexpandedParameterPacks(Declarator &D);
6795 
6796  /// \brief Returns the pattern of the pack expansion for a template argument.
6797  ///
6798  /// \param OrigLoc The template argument to expand.
6799  ///
6800  /// \param Ellipsis Will be set to the location of the ellipsis.
6801  ///
6802  /// \param NumExpansions Will be set to the number of expansions that will
6803  /// be generated from this pack expansion, if known a priori.
6804  TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(
6805  TemplateArgumentLoc OrigLoc,
6806  SourceLocation &Ellipsis,
6807  Optional<unsigned> &NumExpansions) const;
6808 
6809  /// Given a template argument that contains an unexpanded parameter pack, but
6810  /// which has already been substituted, attempt to determine the number of
6811  /// elements that will be produced once this argument is fully-expanded.
6812  ///
6813  /// This is intended for use when transforming 'sizeof...(Arg)' in order to
6814  /// avoid actually expanding the pack where possible.
6815  Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
6816 
6817  //===--------------------------------------------------------------------===//
6818  // C++ Template Argument Deduction (C++ [temp.deduct])
6819  //===--------------------------------------------------------------------===//
6820 
6821  /// Adjust the type \p ArgFunctionType to match the calling convention,
6822  /// noreturn, and optionally the exception specification of \p FunctionType.
6823  /// Deduction often wants to ignore these properties when matching function
6824  /// types.
6825  QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,
6826  bool AdjustExceptionSpec = false);
6827 
6828  /// \brief Describes the result of template argument deduction.
6829  ///
6830  /// The TemplateDeductionResult enumeration describes the result of
6831  /// template argument deduction, as returned from
6832  /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
6833  /// structure provides additional information about the results of
6834  /// template argument deduction, e.g., the deduced template argument
6835  /// list (if successful) or the specific template parameters or
6836  /// deduced arguments that were involved in the failure.
6838  /// \brief Template argument deduction was successful.
6839  TDK_Success = 0,
6840  /// \brief The declaration was invalid; do nothing.
6842  /// \brief Template argument deduction exceeded the maximum template
6843  /// instantiation depth (which has already been diagnosed).
6845  /// \brief Template argument deduction did not deduce a value
6846  /// for every template parameter.
6848  /// \brief Template argument deduction produced inconsistent
6849  /// deduced values for the given template parameter.
6851  /// \brief Template argument deduction failed due to inconsistent
6852  /// cv-qualifiers on a template parameter type that would
6853  /// otherwise be deduced, e.g., we tried to deduce T in "const T"
6854  /// but were given a non-const "X".
6856  /// \brief Substitution of the deduced template argument values
6857  /// resulted in an error.
6859  /// \brief After substituting deduced template arguments, a dependent
6860  /// parameter type did not match the corresponding argument.
6862  /// \brief After substituting deduced template arguments, an element of
6863  /// a dependent parameter type did not match the corresponding element
6864  /// of the corresponding argument (when deducing from an initializer list).
6866  /// \brief A non-depnedent component of the parameter did not match the
6867  /// corresponding component of the argument.
6869  /// \brief When performing template argument deduction for a function
6870  /// template, there were too many call arguments.
6872  /// \brief When performing template argument deduction for a function
6873  /// template, there were too few call arguments.
6875  /// \brief The explicitly-specified template arguments were not valid
6876  /// template arguments for the given template.
6878  /// \brief Checking non-dependent argument conversions failed.
6880  /// \brief Deduction failed; that's all we know.
6882  /// \brief CUDA Target attributes do not match.
6883  TDK_CUDATargetMismatch
6884  };
6885 
6888  const TemplateArgumentList &TemplateArgs,
6890 
6893  const TemplateArgumentList &TemplateArgs,
6895 
6896  TemplateDeductionResult SubstituteExplicitTemplateArguments(
6897  FunctionTemplateDecl *FunctionTemplate,
6898  TemplateArgumentListInfo &ExplicitTemplateArgs,
6902 
6903  /// brief A function argument from which we performed template argument
6904  // deduction for a call.
6906  OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,
6907  unsigned ArgIdx, QualType OriginalArgType)
6908  : OriginalParamType(OriginalParamType),
6909  DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),
6910  OriginalArgType(OriginalArgType) {}
6911 
6914  unsigned ArgIdx;
6916  };
6917 
6919  FunctionTemplateDecl *FunctionTemplate,
6921  unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
6923  SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
6924  bool PartialOverloading = false,
6925  llvm::function_ref<bool()> CheckNonDependent = []{ return false; });
6926 
6928  FunctionTemplateDecl *FunctionTemplate,
6929  TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
6930  FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
6931  bool PartialOverloading,
6932  llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
6933 
6936  TemplateArgumentListInfo *ExplicitTemplateArgs,
6937  QualType ArgFunctionType,
6938  FunctionDecl *&Specialization,
6940  bool IsAddressOfFunction = false);
6941 
6944  QualType ToType,
6945  CXXConversionDecl *&Specialization,
6947 
6950  TemplateArgumentListInfo *ExplicitTemplateArgs,
6951  FunctionDecl *&Specialization,
6953  bool IsAddressOfFunction = false);
6954 
6955  /// \brief Substitute Replacement for \p auto in \p TypeWithAuto
6956  QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
6957  /// \brief Substitute Replacement for auto in TypeWithAuto
6958  TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
6959  QualType Replacement);
6960  /// \brief Completely replace the \c auto in \p TypeWithAuto by
6961  /// \p Replacement. This does not retain any \c auto type sugar.
6962  QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
6963 
6964  /// \brief Result type of DeduceAutoType.
6968  DAR_FailedAlreadyDiagnosed
6969  };
6970 
6972  DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
6973  Optional<unsigned> DependentDeductionDepth = None);
6975  DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
6976  Optional<unsigned> DependentDeductionDepth = None);
6977  void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
6978  bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
6979  bool Diagnose = true);
6980 
6981  /// \brief Declare implicit deduction guides for a class template if we've
6982  /// not already done so.
6983  void DeclareImplicitDeductionGuides(TemplateDecl *Template,
6984  SourceLocation Loc);
6985 
6986  QualType DeduceTemplateSpecializationFromInitializer(
6987  TypeSourceInfo *TInfo, const InitializedEntity &Entity,
6988  const InitializationKind &Kind, MultiExprArg Init);
6989 
6990  QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
6991  QualType Type, TypeSourceInfo *TSI,
6992  SourceRange Range, bool DirectInit,
6993  Expr *Init);
6994 
6995  TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;
6996 
6997  bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
6998  SourceLocation ReturnLoc,
6999  Expr *&RetExpr, AutoType *AT);
7000 
7001  FunctionTemplateDecl *getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
7002  FunctionTemplateDecl *FT2,
7003  SourceLocation Loc,
7005  unsigned NumCallArguments1,
7006  unsigned NumCallArguments2);
7008  getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
7009  TemplateSpecCandidateSet &FailedCandidates,
7010  SourceLocation Loc,
7011  const PartialDiagnostic &NoneDiag,
7012  const PartialDiagnostic &AmbigDiag,
7013  const PartialDiagnostic &CandidateDiag,
7014  bool Complain = true, QualType TargetType = QualType());
7015 
7017  getMoreSpecializedPartialSpecialization(
7020  SourceLocation Loc);
7021 
7022  bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,
7024 
7025  VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
7028 
7029  bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
7031 
7032  bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
7034 
7035  void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
7036  bool OnlyDeduced,
7037  unsigned Depth,
7038  llvm::SmallBitVector &Used);
7040  const FunctionTemplateDecl *FunctionTemplate,
7041  llvm::SmallBitVector &Deduced) {
7042  return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
7043  }
7044  static void MarkDeducedTemplateParameters(ASTContext &Ctx,
7045  const FunctionTemplateDecl *FunctionTemplate,
7046  llvm::SmallBitVector &Deduced);
7047 
7048  //===--------------------------------------------------------------------===//
7049  // C++ Template Instantiation
7050  //
7051 
7053  getTemplateInstantiationArgs(NamedDecl *D,
7054  const TemplateArgumentList *Innermost = nullptr,
7055  bool RelativeToPrimary = false,
7056  const FunctionDecl *Pattern = nullptr);
7057 
7058  /// A context in which code is being synthesized (where a source location
7059  /// alone is not sufficient to identify the context). This covers template
7060  /// instantiation and various forms of implicitly-generated functions.
7062  /// \brief The kind of template instantiation we are performing
7064  /// We are instantiating a template declaration. The entity is
7065  /// the declaration we're instantiating (e.g., a CXXRecordDecl).
7067 
7068  /// We are instantiating a default argument for a template
7069  /// parameter. The Entity is the template parameter whose argument is
7070  /// being instantiated, the Template is the template, and the
7071  /// TemplateArgs/NumTemplateArguments provide the template arguments as
7072  /// specified.
7074 
7075  /// We are instantiating a default argument for a function.
7076  /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
7077  /// provides the template arguments as specified.
7079 
7080  /// We are substituting explicit template arguments provided for
7081  /// a function template. The entity is a FunctionTemplateDecl.
7083 
7084  /// We are substituting template argument determined as part of
7085  /// template argument deduction for either a class template
7086  /// partial specialization or a function template. The
7087  /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or
7088  /// a TemplateDecl.
7090 
7091  /// We are substituting prior template arguments into a new
7092  /// template parameter. The template parameter itself is either a
7093  /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
7095 
7096  /// We are checking the validity of a default template argument that
7097  /// has been used when naming a template-id.
7099 
7100  /// We are instantiating the exception specification for a function
7101  /// template which was deferred until it was needed.
7103 
7104  /// We are declaring an implicit special member function.
7106 
7107  /// We are defining a synthesized function (such as a defaulted special
7108  /// member).
7110  } Kind;
7111 
7112  /// \brief Was the enclosing context a non-instantiation SFINAE context?
7114 
7115  /// \brief The point of instantiation or synthesis within the source code.
7117 
7118  /// \brief The entity that is being synthesized.
7119  Decl *Entity;
7120 
7121  /// \brief The template (or partial specialization) in which we are
7122  /// performing the instantiation, for substitutions of prior template
7123  /// arguments.
7125 
7126  /// \brief The list of template arguments we are substituting, if they
7127  /// are not part of the entity.
7129 
7130  // FIXME: Wrap this union around more members, or perhaps store the
7131  // kind-specific members in the RAII object owning the context.
7132  union {
7133  /// \brief The number of template arguments in TemplateArgs.
7135 
7136  /// \brief The special member being declared or defined.
7138  };
7139 
7141  assert(Kind != DeclaringSpecialMember);
7142  return {TemplateArgs, NumTemplateArgs};
7143  }
7144 
7145  /// \brief The template deduction info object associated with the
7146  /// substitution or checking of explicit or deduced template arguments.
7148 
7149  /// \brief The source range that covers the construct that cause
7150  /// the instantiation, e.g., the template-id that causes a class
7151  /// template instantiation.
7153 
7155  : Kind(TemplateInstantiation), Entity(nullptr), Template(nullptr),
7156  TemplateArgs(nullptr), NumTemplateArgs(0), DeductionInfo(nullptr) {}
7157 
7158  /// \brief Determines whether this template is an actual instantiation
7159  /// that should be counted toward the maximum instantiation depth.
7160  bool isInstantiationRecord() const;
7161  };
7162 
7163  /// \brief List of active code synthesis contexts.
7164  ///
7165  /// This vector is treated as a stack. As synthesis of one entity requires
7166  /// synthesis of another, additional contexts are pushed onto the stack.
7168 
7169  /// Specializations whose definitions are currently being instantiated.
7171 
7172  /// Non-dependent types used in templates that have already been instantiated
7173  /// by some template instantiation.
7175 
7176  /// \brief Extra modules inspected when performing a lookup during a template
7177  /// instantiation. Computed lazily.
7179 
7180  /// \brief Cache of additional modules that should be used for name lookup
7181  /// within the current template instantiation. Computed lazily; use
7182  /// getLookupModules() to get a complete set.
7184 
7185  /// \brief Get the set of additional modules that should be checked during
7186  /// name lookup. A module and its imports become visible when instanting a
7187  /// template defined within it.
7188  llvm::DenseSet<Module*> &getLookupModules();
7189 
7190  /// \brief Map from the most recent declaration of a namespace to the most
7191  /// recent visible declaration of that namespace.
7192  llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;
7193 
7194  /// \brief Whether we are in a SFINAE context that is not associated with
7195  /// template instantiation.
7196  ///
7197  /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside
7198  /// of a template instantiation or template argument deduction.
7200 
7201  /// \brief The number of \p CodeSynthesisContexts that are not template
7202  /// instantiations and, therefore, should not be counted as part of the
7203  /// instantiation depth.
7204  ///
7205  /// When the instantiation depth reaches the user-configurable limit
7206  /// \p LangOptions::InstantiationDepth we will abort instantiation.
7207  // FIXME: Should we have a similar limit for other forms of synthesis?
7209 
7210  /// \brief The depth of the context stack at the point when the most recent
7211  /// error or warning was produced.
7212  ///
7213  /// This value is used to suppress printing of redundant context stacks
7214  /// when there are multiple errors or warnings in the same instantiation.
7215  // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.
7216  unsigned LastEmittedCodeSynthesisContextDepth = 0;
7217 
7218  /// \brief The current index into pack expansion arguments that will be
7219  /// used for substitution of parameter packs.
7220  ///
7221  /// The pack expansion index will be -1 to indicate that parameter packs
7222  /// should be instantiated as themselves. Otherwise, the index specifies
7223  /// which argument within the parameter pack will be used for substitution.
7225 
7226  /// \brief RAII object used to change the argument pack substitution index
7227  /// within a \c Sema object.
7228  ///
7229  /// See \c ArgumentPackSubstitutionIndex for more information.
7231  Sema &Self;
7232  int OldSubstitutionIndex;
7233 
7234  public:
7235  ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
7236  : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {
7237  Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;
7238  }
7239 
7241  Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;
7242  }
7243  };
7244 
7245  friend class ArgumentPackSubstitutionRAII;
7246 
7247  /// \brief For each declaration that involved template argument deduction, the
7248  /// set of diagnostics that were suppressed during that template argument
7249  /// deduction.
7250  ///
7251  /// FIXME: Serialize this structure to the AST file.
7252  typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >
7255 
7256  /// \brief A stack object to be created when performing template
7257  /// instantiation.
7258  ///
7259  /// Construction of an object of type \c InstantiatingTemplate
7260  /// pushes the current instantiation onto the stack of active
7261  /// instantiations. If the size of this stack exceeds the maximum
7262  /// number of recursive template instantiations, construction
7263  /// produces an error and evaluates true.
7264  ///
7265  /// Destruction of this object will pop the named instantiation off
7266  /// the stack.
7268  /// \brief Note that we are instantiating a class template,
7269  /// function template, variable template, alias template,
7270  /// or a member thereof.
7271  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7272  Decl *Entity,
7273  SourceRange InstantiationRange = SourceRange());
7274 
7276  /// \brief Note that we are instantiating an exception specification
7277  /// of a function template.
7278  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7279  FunctionDecl *Entity, ExceptionSpecification,
7280  SourceRange InstantiationRange = SourceRange());
7281 
7282  /// \brief Note that we are instantiating a default argument in a
7283  /// template-id.
7284  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7285  TemplateParameter Param, TemplateDecl *Template,
7286  ArrayRef<TemplateArgument> TemplateArgs,
7287  SourceRange InstantiationRange = SourceRange());
7288 
7289  /// \brief Note that we are substituting either explicitly-specified or
7290  /// deduced template arguments during function template argument deduction.
7291  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7292  FunctionTemplateDecl *FunctionTemplate,
7293  ArrayRef<TemplateArgument> TemplateArgs,
7295  sema::TemplateDeductionInfo &DeductionInfo,
7296  SourceRange InstantiationRange = SourceRange());
7297 
7298  /// \brief Note that we are instantiating as part of template
7299  /// argument deduction for a class template declaration.
7300  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7301  TemplateDecl *Template,
7302  ArrayRef<TemplateArgument> TemplateArgs,
7303  sema::TemplateDeductionInfo &DeductionInfo,
7304  SourceRange InstantiationRange = SourceRange());
7305 
7306  /// \brief Note that we are instantiating as part of template
7307  /// argument deduction for a class template partial
7308  /// specialization.
7309  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7311  ArrayRef<TemplateArgument> TemplateArgs,
7312  sema::TemplateDeductionInfo &DeductionInfo,
7313  SourceRange InstantiationRange = SourceRange());
7314 
7315  /// \brief Note that we are instantiating as part of template
7316  /// argument deduction for a variable template partial
7317  /// specialization.
7318  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7320  ArrayRef<TemplateArgument> TemplateArgs,
7321  sema::TemplateDeductionInfo &DeductionInfo,
7322  SourceRange InstantiationRange = SourceRange());
7323 
7324  /// \brief Note that we are instantiating a default argument for a function
7325  /// parameter.
7326  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7327  ParmVarDecl *Param,
7328  ArrayRef<TemplateArgument> TemplateArgs,
7329  SourceRange InstantiationRange = SourceRange());
7330 
7331  /// \brief Note that we are substituting prior template arguments into a
7332  /// non-type parameter.
7333  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7334  NamedDecl *Template,
7335  NonTypeTemplateParmDecl *Param,
7336  ArrayRef<TemplateArgument> TemplateArgs,
7337  SourceRange InstantiationRange);
7338 
7339  /// \brief Note that we are substituting prior template arguments into a
7340  /// template template parameter.
7341  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7342  NamedDecl *Template,
7343  TemplateTemplateParmDecl *Param,
7344  ArrayRef<TemplateArgument> TemplateArgs,
7345  SourceRange InstantiationRange);
7346 
7347  /// \brief Note that we are checking the default template argument
7348  /// against the template parameter for a given template-id.
7349  InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
7350  TemplateDecl *Template,
7351  NamedDecl *Param,
7352  ArrayRef<TemplateArgument> TemplateArgs,
7353  SourceRange InstantiationRange);
7354 
7355 
7356  /// \brief Note that we have finished instantiating this template.
7357  void Clear();
7358 
7359  ~InstantiatingTemplate() { Clear(); }
7360 
7361  /// \brief Determines whether we have exceeded the maximum
7362  /// recursive template instantiations.
7363  bool isInvalid() const { return Invalid; }
7364 
7365  /// \brief Determine whether we are already instantiating this
7366  /// specialization in some surrounding active instantiation.
7367  bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
7368 
7369  private:
7370  Sema &SemaRef;
7371  bool Invalid;
7372  bool AlreadyInstantiating;
7373  bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
7374  SourceRange InstantiationRange);
7375 
7378  SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
7379  Decl *Entity, NamedDecl *Template = nullptr,
7380  ArrayRef<TemplateArgument> TemplateArgs = None,
7381  sema::TemplateDeductionInfo *DeductionInfo = nullptr);
7382 
7384 
7386  operator=(const InstantiatingTemplate&) = delete;
7387  };
7388 
7389  void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
7390  void popCodeSynthesisContext();
7391 
7392  /// Determine whether we are currently performing template instantiation.
7394  return CodeSynthesisContexts.size() > NonInstantiationEntries;
7395  }
7396 
7398  if (!CodeSynthesisContexts.empty() &&
7399  CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {
7400  PrintInstantiationStack();
7401  LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();
7402  }
7403  if (PragmaAttributeCurrentTargetDecl)
7404  PrintPragmaAttributeInstantiationPoint();
7405  }
7406  void PrintInstantiationStack();
7407 
7408  void PrintPragmaAttributeInstantiationPoint();
7409 
7410  /// \brief Determines whether we are currently in a context where
7411  /// template argument substitution failures are not considered
7412  /// errors.
7413  ///
7414  /// \returns An empty \c Optional if we're not in a SFINAE context.
7415  /// Otherwise, contains a pointer that, if non-NULL, contains the nearest
7416  /// template-deduction context object, which can be used to capture
7417  /// diagnostics that will be suppressed.
7418  Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;
7419 
7420  /// \brief Determines whether we are currently in a context that
7421  /// is not evaluated as per C++ [expr] p5.
7422  bool isUnevaluatedContext() const {
7423  assert(!ExprEvalContexts.empty() &&
7424  "Must be in an expression evaluation context");
7425  return ExprEvalContexts.back().isUnevaluated();
7426  }
7427 
7428  /// \brief RAII class used to determine whether SFINAE has
7429  /// trapped any errors that occur during template argument
7430  /// deduction.
7431  class SFINAETrap {
7432  Sema &SemaRef;
7433  unsigned PrevSFINAEErrors;
7434  bool PrevInNonInstantiationSFINAEContext;
7435  bool PrevAccessCheckingSFINAE;
7436  bool PrevLastDiagnosticIgnored;
7437 
7438  public:
7439  explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
7440  : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
7441  PrevInNonInstantiationSFINAEContext(
7442  SemaRef.InNonInstantiationSFINAEContext),
7443  PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),
7444  PrevLastDiagnosticIgnored(
7445  SemaRef.getDiagnostics().isLastDiagnosticIgnored())
7446  {
7447  if (!SemaRef.isSFINAEContext())
7448  SemaRef.InNonInstantiationSFINAEContext = true;
7449  SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;
7450  }
7451 
7453  SemaRef.NumSFINAEErrors = PrevSFINAEErrors;
7455  = PrevInNonInstantiationSFINAEContext;
7456  SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;
7458  PrevLastDiagnosticIgnored);
7459  }
7460 
7461  /// \brief Determine whether any SFINAE errors have been trapped.
7462  bool hasErrorOccurred() const {
7463  return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
7464  }
7465  };
7466 
7467  /// \brief RAII class used to indicate that we are performing provisional
7468  /// semantic analysis to determine the validity of a construct, so
7469  /// typo-correction and diagnostics in the immediate context (not within
7470  /// implicitly-instantiated templates) should be suppressed.
7472  Sema &SemaRef;
7473  // FIXME: Using a SFINAETrap for this is a hack.
7474  SFINAETrap Trap;
7475  bool PrevDisableTypoCorrection;
7476  public:
7477  explicit TentativeAnalysisScope(Sema &SemaRef)
7478  : SemaRef(SemaRef), Trap(SemaRef, true),
7479  PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {
7480  SemaRef.DisableTypoCorrection = true;
7481  }
7483  SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;
7484  }
7485  };
7486 
7487  /// \brief The current instantiation scope used to store local
7488  /// variables.
7490 
7491  /// \brief Tracks whether we are in a context where typo correction is
7492  /// disabled.
7494 
7495  /// \brief The number of typos corrected by CorrectTypo.
7496  unsigned TyposCorrected;
7497 
7498  typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet;
7499  typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
7500 
7501  /// \brief A cache containing identifiers for which typo correction failed and
7502  /// their locations, so that repeated attempts to correct an identifier in a
7503  /// given location are ignored if typo correction already failed for it.
7504  IdentifierSourceLocations TypoCorrectionFailures;
7505 
7506  /// \brief Worker object for performing CFG-based warnings.
7509 
7510  /// \brief An entity for which implicit template instantiation is required.
7511  ///
7512  /// The source location associated with the declaration is the first place in
7513  /// the source code where the declaration was "used". It is not necessarily
7514  /// the point of instantiation (which will be either before or after the
7515  /// namespace-scope declaration that triggered this implicit instantiation),
7516  /// However, it is the location that diagnostics should generally refer to,
7517  /// because users will need to know what code triggered the instantiation.
7518  typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
7519 
7520  /// \brief The queue of implicit template instantiations that are required
7521  /// but have not yet been performed.
7522  std::deque<PendingImplicitInstantiation> PendingInstantiations;
7523 
7525  public:
7527  : S(S), Enabled(Enabled) {
7528  if (!Enabled) return;
7529 
7530  SavedPendingInstantiations.swap(S.PendingInstantiations);
7531  SavedVTableUses.swap(S.VTableUses);
7532  }
7533 
7534  void perform() {
7535  if (Enabled) {
7536  S.DefineUsedVTables();
7537  S.PerformPendingInstantiations();
7538  }
7539  }
7540 
7542  if (!Enabled) return;
7543 
7544  // Restore the set of pending vtables.
7545  assert(S.VTableUses.empty() &&
7546  "VTableUses should be empty before it is discarded.");
7547  S.VTableUses.swap(SavedVTableUses);
7548 
7549  // Restore the set of pending implicit instantiations.
7550  assert(S.PendingInstantiations.empty() &&
7551  "PendingInstantiations should be empty before it is discarded.");
7552  S.PendingInstantiations.swap(SavedPendingInstantiations);
7553  }
7554 
7555  private:
7556  Sema &S;
7557  SmallVector<VTableUse, 16> SavedVTableUses;
7558  std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
7559  bool Enabled;
7560  };
7561 
7562  /// \brief The queue of implicit template instantiations that are required
7563  /// and must be performed within the current local scope.
7564  ///
7565  /// This queue is only used for member functions of local classes in
7566  /// templates, which must be instantiated in the same scope as their
7567  /// enclosing function, so that they can reference function-local
7568  /// types, static variables, enumerators, etc.
7569  std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;
7570 
7572  public:
7574  SavedPendingLocalImplicitInstantiations.swap(
7576  }
7577 
7578  void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }
7579 
7581  assert(S.PendingLocalImplicitInstantiations.empty() &&
7582  "there shouldn't be any pending local implicit instantiations");
7583  SavedPendingLocalImplicitInstantiations.swap(
7584  S.PendingLocalImplicitInstantiations);
7585  }
7586 
7587  private:
7588  Sema &S;
7589  std::deque<PendingImplicitInstantiation>
7590  SavedPendingLocalImplicitInstantiations;
7591  };
7592 
7593  /// A helper class for building up ExtParameterInfos.
7596  bool HasInteresting = false;
7597 
7598  public:
7599  /// Set the ExtParameterInfo for the parameter at the given index,
7600  ///
7601  void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
7602  assert(Infos.size() <= index);
7603  Infos.resize(index);
7604  Infos.push_back(info);
7605 
7606  if (!HasInteresting)
7607  HasInteresting = (info != FunctionProtoType::ExtParameterInfo());
7608  }
7609 
7610  /// Return a pointer (suitable for setting in an ExtProtoInfo) to the
7611  /// ExtParameterInfo array we've built up.
7613  getPointerOrNull(unsigned numParams) {
7614  if (!HasInteresting) return nullptr;
7615  Infos.resize(numParams);
7616  return Infos.data();
7617  }
7618  };
7619 
7620  void PerformPendingInstantiations(bool LocalOnly = false);
7621 
7622  TypeSourceInfo *SubstType(TypeSourceInfo *T,
7623  const MultiLevelTemplateArgumentList &TemplateArgs,
7624  SourceLocation Loc, DeclarationName Entity,
7625  bool AllowDeducedTST = false);
7626 
7627  QualType SubstType(QualType T,
7628  const MultiLevelTemplateArgumentList &TemplateArgs,
7629  SourceLocation Loc, DeclarationName Entity);
7630 
7631  TypeSourceInfo *SubstType(TypeLoc TL,
7632  const MultiLevelTemplateArgumentList &TemplateArgs,
7633  SourceLocation Loc, DeclarationName Entity);
7634 
7635  TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
7636  const MultiLevelTemplateArgumentList &TemplateArgs,
7637  SourceLocation Loc,
7638  DeclarationName Entity,
7639  CXXRecordDecl *ThisContext,
7640  unsigned ThisTypeQuals);
7641  void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
7642  const MultiLevelTemplateArgumentList &Args);
7643  bool SubstExceptionSpec(SourceLocation Loc,
7645  SmallVectorImpl<QualType> &ExceptionStorage,
7646  const MultiLevelTemplateArgumentList &Args);
7647  ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
7648  const MultiLevelTemplateArgumentList &TemplateArgs,
7649  int indexAdjustment,
7650  Optional<unsigned> NumExpansions,
7651  bool ExpectParameterPack);
7652  bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
7653  const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
7654  const MultiLevelTemplateArgumentList &TemplateArgs,
7655  SmallVectorImpl<QualType> &ParamTypes,
7656  SmallVectorImpl<ParmVarDecl *> *OutParams,
7657  ExtParameterInfoBuilder &ParamInfos);
7658  ExprResult SubstExpr(Expr *E,
7659  const MultiLevelTemplateArgumentList &TemplateArgs);
7660 
7661  /// \brief Substitute the given template arguments into a list of
7662  /// expressions, expanding pack expansions if required.
7663  ///
7664  /// \param Exprs The list of expressions to substitute into.
7665  ///
7666  /// \param IsCall Whether this is some form of call, in which case
7667  /// default arguments will be dropped.
7668  ///
7669  /// \param TemplateArgs The set of template arguments to substitute.
7670  ///
7671  /// \param Outputs Will receive all of the substituted arguments.
7672  ///
7673  /// \returns true if an error occurred, false otherwise.
7674  bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
7675  const MultiLevelTemplateArgumentList &TemplateArgs,
7676  SmallVectorImpl<Expr *> &Outputs);
7677 
7678  StmtResult SubstStmt(Stmt *S,
7679  const MultiLevelTemplateArgumentList &TemplateArgs);
7680 
7681  Decl *SubstDecl(Decl *D, DeclContext *Owner,
7682  const MultiLevelTemplateArgumentList &TemplateArgs);
7683 
7684  ExprResult SubstInitializer(Expr *E,
7685  const MultiLevelTemplateArgumentList &TemplateArgs,
7686  bool CXXDirectInit);
7687 
7688  bool
7689  SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
7690  CXXRecordDecl *Pattern,
7691  const MultiLevelTemplateArgumentList &TemplateArgs);
7692 
7693  bool
7694  InstantiateClass(SourceLocation PointOfInstantiation,
7695  CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
7696  const MultiLevelTemplateArgumentList &TemplateArgs,
7698  bool Complain = true);
7699 
7700  bool InstantiateEnum(SourceLocation PointOfInstantiation,
7701  EnumDecl *Instantiation, EnumDecl *Pattern,
7702  const MultiLevelTemplateArgumentList &TemplateArgs,
7704 
7705  bool InstantiateInClassInitializer(
7706  SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
7707  FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);
7708 
7710  const Attr *TmplAttr;
7712  Decl *NewDecl;
7713 
7715  Decl *D)
7716  : TmplAttr(A), Scope(S), NewDecl(D)
7717  { }
7718  };
7720 
7721  void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
7722  const Decl *Pattern, Decl *Inst,
7723  LateInstantiatedAttrVec *LateAttrs = nullptr,
7724  LocalInstantiationScope *OuterMostScope = nullptr);
7725 
7726  void
7727  InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
7728  const Decl *Pattern, Decl *Inst,
7729  LateInstantiatedAttrVec *LateAttrs = nullptr,
7730  LocalInstantiationScope *OuterMostScope = nullptr);
7731 
7732  bool usesPartialOrExplicitSpecialization(
7733  SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
7734 
7735  bool
7736  InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
7737  ClassTemplateSpecializationDecl *ClassTemplateSpec,
7739  bool Complain = true);
7740 
7741  void InstantiateClassMembers(SourceLocation PointOfInstantiation,
7742  CXXRecordDecl *Instantiation,
7743  const MultiLevelTemplateArgumentList &TemplateArgs,
7745 
7746  void InstantiateClassTemplateSpecializationMembers(
7747  SourceLocation PointOfInstantiation,
7748  ClassTemplateSpecializationDecl *ClassTemplateSpec,
7750 
7752  SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
7753  const MultiLevelTemplateArgumentList &TemplateArgs);
7754 
7756  SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
7757  const MultiLevelTemplateArgumentList &TemplateArgs);
7758  TemplateName
7759  SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
7760  SourceLocation Loc,
7761  const MultiLevelTemplateArgumentList &TemplateArgs);
7762  bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
7763  TemplateArgumentListInfo &Result,
7764  const MultiLevelTemplateArgumentList &TemplateArgs);
7765 
7766  void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
7767  FunctionDecl *Function);
7768  FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
7769  const TemplateArgumentList *Args,
7770  SourceLocation Loc);
7771  void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
7772  FunctionDecl *Function,
7773  bool Recursive = false,
7774  bool DefinitionRequired = false,
7775  bool AtEndOfTU = false);
7776  VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
7777  VarTemplateDecl *VarTemplate, VarDecl *FromVar,
7778  const TemplateArgumentList &TemplateArgList,
7779  const TemplateArgumentListInfo &TemplateArgsInfo,
7781  SourceLocation PointOfInstantiation, void *InsertPos,
7782  LateInstantiatedAttrVec *LateAttrs = nullptr,
7783  LocalInstantiationScope *StartingScope = nullptr);
7784  VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
7785  VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
7786  const MultiLevelTemplateArgumentList &TemplateArgs);
7787  void
7788  BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
7789  const MultiLevelTemplateArgumentList &TemplateArgs,
7790  LateInstantiatedAttrVec *LateAttrs,
7791  DeclContext *Owner,
7792  LocalInstantiationScope *StartingScope,
7793  bool InstantiatingVarTemplate = false);
7794  void InstantiateVariableInitializer(
7795  VarDecl *Var, VarDecl *OldVar,
7796  const MultiLevelTemplateArgumentList &TemplateArgs);
7797  void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
7798  VarDecl *Var, bool Recursive = false,
7799  bool DefinitionRequired = false,
7800  bool AtEndOfTU = false);
7801 
7802  void InstantiateMemInitializers(CXXConstructorDecl *New,
7803  const CXXConstructorDecl *Tmpl,
7804  const MultiLevelTemplateArgumentList &TemplateArgs);
7805 
7806  NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
7807  const MultiLevelTemplateArgumentList &TemplateArgs,
7808  bool FindingInstantiatedContext = false);
7809  DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
7810  const MultiLevelTemplateArgumentList &TemplateArgs);
7811 
7812  // Objective-C declarations.
7814  OCK_None = -1,
7815  OCK_Interface = 0,
7820  OCK_CategoryImplementation
7821  };
7822  ObjCContainerKind getObjCContainerKind() const;
7823 
7824  DeclResult actOnObjCTypeParam(Scope *S,
7825  ObjCTypeParamVariance variance,
7826  SourceLocation varianceLoc,
7827  unsigned index,
7828  IdentifierInfo *paramName,
7829  SourceLocation paramLoc,
7830  SourceLocation colonLoc,
7831  ParsedType typeBound);
7832 
7833  ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,
7834  ArrayRef<Decl *> typeParams,
7835  SourceLocation rAngleLoc);
7836  void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);
7837 
7838  Decl *ActOnStartClassInterface(Scope *S,
7839  SourceLocation AtInterfaceLoc,
7840  IdentifierInfo *ClassName,
7841  SourceLocation ClassLoc,
7842  ObjCTypeParamList *typeParamList,
7843  IdentifierInfo *SuperName,
7844  SourceLocation SuperLoc,
7845  ArrayRef<ParsedType> SuperTypeArgs,
7846  SourceRange SuperTypeArgsRange,
7847  Decl * const *ProtoRefs,
7848  unsigned NumProtoRefs,
7849  const SourceLocation *ProtoLocs,
7850  SourceLocation EndProtoLoc,
7851  AttributeList *AttrList);
7852 
7853  void ActOnSuperClassOfClassInterface(Scope *S,
7854  SourceLocation AtInterfaceLoc,
7855  ObjCInterfaceDecl *IDecl,
7856  IdentifierInfo *ClassName,
7857  SourceLocation ClassLoc,
7858  IdentifierInfo *SuperName,
7859  SourceLocation SuperLoc,
7860  ArrayRef<ParsedType> SuperTypeArgs,
7861  SourceRange SuperTypeArgsRange);
7862 
7863  void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
7864  SmallVectorImpl<SourceLocation> &ProtocolLocs,
7865  IdentifierInfo *SuperName,
7866  SourceLocation SuperLoc);
7867 
7868  Decl *ActOnCompatibilityAlias(
7869  SourceLocation AtCompatibilityAliasLoc,
7870  IdentifierInfo *AliasName, SourceLocation AliasLocation,
7871  IdentifierInfo *ClassName, SourceLocation ClassLocation);
7872 
7873  bool CheckForwardProtocolDeclarationForCircularDependency(
7874  IdentifierInfo *PName,
7875  SourceLocation &PLoc, SourceLocation PrevLoc,
7876  const ObjCList<ObjCProtocolDecl> &PList);
7877 
7878  Decl *ActOnStartProtocolInterface(
7879  SourceLocation AtProtoInterfaceLoc,
7880  IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
7881  Decl * const *ProtoRefNames, unsigned NumProtoRefs,
7882  const SourceLocation *ProtoLocs,
7883  SourceLocation EndProtoLoc,
7884  AttributeList *AttrList);
7885 
7886  Decl *ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
7887  IdentifierInfo *ClassName,
7888  SourceLocation ClassLoc,
7889  ObjCTypeParamList *typeParamList,
7890  IdentifierInfo *CategoryName,
7891  SourceLocation CategoryLoc,
7892  Decl * const *ProtoRefs,
7893  unsigned NumProtoRefs,
7894  const SourceLocation *ProtoLocs,
7895  SourceLocation EndProtoLoc,
7896  AttributeList *AttrList);
7897 
7898  Decl *ActOnStartClassImplementation(
7899  SourceLocation AtClassImplLoc,
7900  IdentifierInfo *ClassName, SourceLocation ClassLoc,
7901  IdentifierInfo *SuperClassname,
7902  SourceLocation SuperClassLoc);
7903 
7904  Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,
7905  IdentifierInfo *ClassName,
7906  SourceLocation ClassLoc,
7907  IdentifierInfo *CatName,
7908  SourceLocation CatLoc);
7909 
7910  DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
7911  ArrayRef<Decl *> Decls);
7912 
7913  DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
7914  IdentifierInfo **IdentList,
7915  SourceLocation *IdentLocs,
7916  ArrayRef<ObjCTypeParamList *> TypeParamLists,
7917  unsigned NumElts);
7918 
7919  DeclGroupPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
7920  ArrayRef<IdentifierLocPair> IdentList,
7921  AttributeList *attrList);
7922 
7923  void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
7924  ArrayRef<IdentifierLocPair> ProtocolId,
7925  SmallVectorImpl<Decl *> &Protocols);
7926 
7927  void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
7928  SourceLocation ProtocolLoc,
7929  IdentifierInfo *TypeArgId,
7930  SourceLocation TypeArgLoc,
7931  bool SelectProtocolFirst = false);
7932 
7933  /// Given a list of identifiers (and their locations), resolve the
7934  /// names to either Objective-C protocol qualifiers or type
7935  /// arguments, as appropriate.
7936  void actOnObjCTypeArgsOrProtocolQualifiers(
7937  Scope *S,
7938  ParsedType baseType,
7939  SourceLocation lAngleLoc,
7940  ArrayRef<IdentifierInfo *> identifiers,
7941  ArrayRef<SourceLocation> identifierLocs,
7942  SourceLocation rAngleLoc,
7943  SourceLocation &typeArgsLAngleLoc,
7944  SmallVectorImpl<ParsedType> &typeArgs,
7945  SourceLocation &typeArgsRAngleLoc,
7946  SourceLocation &protocolLAngleLoc,
7947  SmallVectorImpl<Decl *> &protocols,
7948  SourceLocation &protocolRAngleLoc,
7949  bool warnOnIncompleteProtocols);
7950 
7951  /// Build a an Objective-C protocol-qualified 'id' type where no
7952  /// base type was specified.
7953  TypeResult actOnObjCProtocolQualifierType(
7954  SourceLocation lAngleLoc,
7955  ArrayRef<Decl *> protocols,
7956  ArrayRef<SourceLocation> protocolLocs,
7957  SourceLocation rAngleLoc);
7958 
7959  /// Build a specialized and/or protocol-qualified Objective-C type.
7960  TypeResult actOnObjCTypeArgsAndProtocolQualifiers(
7961  Scope *S,
7962  SourceLocation Loc,
7963  ParsedType BaseType,
7964  SourceLocation TypeArgsLAngleLoc,
7965  ArrayRef<ParsedType> TypeArgs,
7966  SourceLocation TypeArgsRAngleLoc,
7967  SourceLocation ProtocolLAngleLoc,
7968  ArrayRef<Decl *> Protocols,
7969  ArrayRef<SourceLocation> ProtocolLocs,
7970  SourceLocation ProtocolRAngleLoc);
7971 
7972  /// Build an Objective-C type parameter type.
7973  QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
7974  SourceLocation ProtocolLAngleLoc,
7975  ArrayRef<ObjCProtocolDecl *> Protocols,
7976  ArrayRef<SourceLocation> ProtocolLocs,
7977  SourceLocation ProtocolRAngleLoc,
7978  bool FailOnError = false);
7979 
7980  /// Build an Objective-C object pointer type.
7981  QualType BuildObjCObjectType(QualType BaseType,
7982  SourceLocation Loc,
7983  SourceLocation TypeArgsLAngleLoc,
7984  ArrayRef<TypeSourceInfo *> TypeArgs,
7985  SourceLocation TypeArgsRAngleLoc,
7986  SourceLocation ProtocolLAngleLoc,
7987  ArrayRef<ObjCProtocolDecl *> Protocols,
7988  ArrayRef<SourceLocation> ProtocolLocs,
7989  SourceLocation ProtocolRAngleLoc,
7990  bool FailOnError = false);
7991 
7992  /// Check the application of the Objective-C '__kindof' qualifier to
7993  /// the given type.
7994  bool checkObjCKindOfType(QualType &type, SourceLocation loc);
7995 
7996  /// Ensure attributes are consistent with type.
7997  /// \param [in, out] Attributes The attributes to check; they will
7998  /// be modified to be consistent with \p PropertyTy.
7999  void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,
8000  SourceLocation Loc,
8001  unsigned &Attributes,
8002  bool propertyInPrimaryClass);
8003 
8004  /// Process the specified property declaration and create decls for the
8005  /// setters and getters as needed.
8006  /// \param property The property declaration being processed
8007  void ProcessPropertyDecl(ObjCPropertyDecl *property);
8008 
8009 
8010  void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
8011  ObjCPropertyDecl *SuperProperty,
8012  const IdentifierInfo *Name,
8013  bool OverridingProtocolProperty);
8014 
8015  void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
8016  ObjCInterfaceDecl *ID);
8017 
8018  Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,
8019  ArrayRef<Decl *> allMethods = None,
8020  ArrayRef<DeclGroupPtrTy> allTUVars = None);
8021 
8022  Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,
8023  SourceLocation LParenLoc,
8024  FieldDeclarator &FD, ObjCDeclSpec &ODS,
8025  Selector GetterSel, Selector SetterSel,
8026  tok::ObjCKeywordKind MethodImplKind,
8027  DeclContext *lexicalDC = nullptr);
8028 
8029  Decl *ActOnPropertyImplDecl(Scope *S,
8030  SourceLocation AtLoc,
8031  SourceLocation PropertyLoc,
8032  bool ImplKind,
8033  IdentifierInfo *PropertyId,
8034  IdentifierInfo *PropertyIvar,
8035  SourceLocation PropertyIvarLoc,
8036  ObjCPropertyQueryKind QueryKind);
8037 
8044  OSMK_NonRetainingInit
8045  };
8046 
8047  struct ObjCArgInfo {
8050  // The Type is null if no type was specified, and the DeclSpec is invalid
8051  // in this case.
8054 
8055  /// ArgAttrs - Attribute list for this argument.
8057  };
8058 
8059  Decl *ActOnMethodDeclaration(
8060  Scope *S,
8061  SourceLocation BeginLoc, // location of the + or -.
8062  SourceLocation EndLoc, // location of the ; or {.
8063  tok::TokenKind MethodType,
8064  ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
8065  ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
8066  // optional arguments. The number of types/arguments is obtained
8067  // from the Sel.getNumArgs().
8068  ObjCArgInfo *ArgInfo,
8069  DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
8070  AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
8071  bool isVariadic, bool MethodDefinition);
8072 
8073  ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,
8074  const ObjCObjectPointerType *OPT,
8075  bool IsInstance);
8076  ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,
8077  bool IsInstance);
8078 
8079  bool CheckARCMethodDecl(ObjCMethodDecl *method);
8080  bool inferObjCARCLifetime(ValueDecl *decl);
8081 
8082  ExprResult
8083  HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
8084  Expr *BaseExpr,
8085  SourceLocation OpLoc,
8086  DeclarationName MemberName,
8087  SourceLocation MemberLoc,
8088  SourceLocation SuperLoc, QualType SuperType,
8089  bool Super);
8090 
8091  ExprResult
8092  ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
8093  IdentifierInfo &propertyName,
8094  SourceLocation receiverNameLoc,
8095  SourceLocation propertyNameLoc);
8096 
8097  ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);
8098 
8099  /// \brief Describes the kind of message expression indicated by a message
8100  /// send that starts with an identifier.
8102  /// \brief The message is sent to 'super'.
8104  /// \brief The message is an instance message.
8106  /// \brief The message is a class message, and the identifier is a type
8107  /// name.
8108  ObjCClassMessage
8109  };
8110 
8111  ObjCMessageKind getObjCMessageKind(Scope *S,
8112  IdentifierInfo *Name,
8113  SourceLocation NameLoc,
8114  bool IsSuper,
8115  bool HasTrailingDot,
8116  ParsedType &ReceiverType);
8117 
8118  ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
8119  Selector Sel,
8120  SourceLocation LBracLoc,
8121  ArrayRef<SourceLocation> SelectorLocs,
8122  SourceLocation RBracLoc,
8123  MultiExprArg Args);
8124 
8125  ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
8126  QualType ReceiverType,
8127  SourceLocation SuperLoc,
8128  Selector Sel,
8129  ObjCMethodDecl *Method,
8130  SourceLocation LBracLoc,
8131  ArrayRef<SourceLocation> SelectorLocs,
8132  SourceLocation RBracLoc,
8133  MultiExprArg Args,
8134  bool isImplicit = false);
8135 
8136  ExprResult BuildClassMessageImplicit(QualType ReceiverType,
8137  bool isSuperReceiver,
8138  SourceLocation Loc,
8139  Selector Sel,
8140  ObjCMethodDecl *Method,
8141  MultiExprArg Args);
8142 
8143  ExprResult ActOnClassMessage(Scope *S,
8144  ParsedType Receiver,
8145  Selector Sel,
8146  SourceLocation LBracLoc,
8147  ArrayRef<SourceLocation> SelectorLocs,
8148  SourceLocation RBracLoc,
8149  MultiExprArg Args);
8150 
8151  ExprResult BuildInstanceMessage(Expr *Receiver,
8152  QualType ReceiverType,
8153  SourceLocation SuperLoc,
8154  Selector Sel,
8155  ObjCMethodDecl *Method,
8156  SourceLocation LBracLoc,
8157  ArrayRef<SourceLocation> SelectorLocs,
8158  SourceLocation RBracLoc,
8159  MultiExprArg Args,
8160  bool isImplicit = false);
8161 
8162  ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
8163  QualType ReceiverType,
8164  SourceLocation Loc,
8165  Selector Sel,
8166  ObjCMethodDecl *Method,
8167  MultiExprArg Args);
8168 
8169  ExprResult ActOnInstanceMessage(Scope *S,
8170  Expr *Receiver,
8171  Selector Sel,
8172  SourceLocation LBracLoc,
8173  ArrayRef<SourceLocation> SelectorLocs,
8174  SourceLocation RBracLoc,
8175  MultiExprArg Args);
8176 
8177  ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,
8178  ObjCBridgeCastKind Kind,
8179  SourceLocation BridgeKeywordLoc,
8180  TypeSourceInfo *TSInfo,
8181  Expr *SubExpr);
8182 
8183  ExprResult ActOnObjCBridgedCast(Scope *S,
8184  SourceLocation LParenLoc,
8185  ObjCBridgeCastKind Kind,
8186  SourceLocation BridgeKeywordLoc,
8187  ParsedType Type,
8188  SourceLocation RParenLoc,
8189  Expr *SubExpr);
8190 
8191  void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
8192 
8193  void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
8194 
8195  bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
8196  CastKind &Kind);
8197 
8198  bool checkObjCBridgeRelatedComponents(SourceLocation Loc,
8199  QualType DestType, QualType SrcType,
8200  ObjCInterfaceDecl *&RelatedClass,
8201  ObjCMethodDecl *&ClassMethod,
8202  ObjCMethodDecl *&InstanceMethod,
8203  TypedefNameDecl *&TDNDecl,
8204  bool CfToNs, bool Diagnose = true);
8205 
8206  bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
8207  QualType DestType, QualType SrcType,
8208  Expr *&SrcExpr, bool Diagnose = true);
8209 
8210  bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr,
8211  bool Diagnose = true);
8212 
8213  bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
8214 
8215  /// \brief Check whether the given new method is a valid override of the
8216  /// given overridden method, and set any properties that should be inherited.
8217  void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
8218  const ObjCMethodDecl *Overridden);
8219 
8220  /// \brief Describes the compatibility of a result type with its method.
8224  RTC_Unknown
8225  };
8226 
8227  void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
8228  ObjCInterfaceDecl *CurrentClass,
8230 
8232  POAK_Native, // #pragma options align=native
8233  POAK_Natural, // #pragma options align=natural
8234  POAK_Packed, // #pragma options align=packed
8235  POAK_Power, // #pragma options align=power
8236  POAK_Mac68k, // #pragma options align=mac68k
8237  POAK_Reset // #pragma options align=reset
8238  };
8239 
8240  /// ActOnPragmaClangSection - Called on well formed \#pragma clang section
8241  void ActOnPragmaClangSection(SourceLocation PragmaLoc,
8242  PragmaClangSectionAction Action,
8243  PragmaClangSectionKind SecKind, StringRef SecName);
8244 
8245  /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align.
8246  void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
8247  SourceLocation PragmaLoc);
8248 
8249  /// ActOnPragmaPack - Called on well formed \#pragma pack(...).
8250  void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
8251  StringRef SlotLabel, Expr *Alignment);
8252 
8254  NonDefaultStateAtInclude,
8255  ChangedStateAtExit
8256  };
8257 
8258  void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
8259  SourceLocation IncludeLoc);
8260  void DiagnoseUnterminatedPragmaPack();
8261 
8262  /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off].
8263  void ActOnPragmaMSStruct(PragmaMSStructKind Kind);
8264 
8265  /// ActOnPragmaMSComment - Called on well formed
8266  /// \#pragma comment(kind, "arg").
8267  void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,
8268  StringRef Arg);
8269 
8270  /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
8271  /// pointers_to_members(representation method[, general purpose
8272  /// representation]).
8273  void ActOnPragmaMSPointersToMembers(
8275  SourceLocation PragmaLoc);
8276 
8277  /// \brief Called on well formed \#pragma vtordisp().
8278  void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
8279  SourceLocation PragmaLoc,
8280  MSVtorDispAttr::Mode Value);
8281 
8287  };
8288 
8289  bool UnifySection(StringRef SectionName,
8290  int SectionFlags,
8291  DeclaratorDecl *TheDecl);
8292  bool UnifySection(StringRef SectionName,
8293  int SectionFlags,
8294  SourceLocation PragmaSectionLocation);
8295 
8296  /// \brief Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
8297  void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
8298  PragmaMsStackAction Action,
8299  llvm::StringRef StackSlotLabel,
8300  StringLiteral *SegmentName,
8301  llvm::StringRef PragmaName);
8302 
8303  /// \brief Called on well formed \#pragma section().
8304  void ActOnPragmaMSSection(SourceLocation PragmaLocation,
8305  int SectionFlags, StringLiteral *SegmentName);
8306 
8307  /// \brief Called on well-formed \#pragma init_seg().
8308  void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
8309  StringLiteral *SegmentName);
8310 
8311  /// \brief Called on #pragma clang __debug dump II
8312  void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);
8313 
8314  /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
8315  void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
8316  StringRef Value);
8317 
8318  /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
8319  void ActOnPragmaUnused(const Token &Identifier,
8320  Scope *curScope,
8321  SourceLocation PragmaLoc);
8322 
8323  /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... .
8324  void ActOnPragmaVisibility(const IdentifierInfo* VisType,
8325  SourceLocation PragmaLoc);
8326 
8327  NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
8328  SourceLocation Loc);
8329  void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
8330 
8331  /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident.
8332  void ActOnPragmaWeakID(IdentifierInfo* WeakName,
8333  SourceLocation PragmaLoc,
8334  SourceLocation WeakNameLoc);
8335 
8336  /// ActOnPragmaRedefineExtname - Called on well formed
8337  /// \#pragma redefine_extname oldname newname.
8338  void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,
8339  IdentifierInfo* AliasName,
8340  SourceLocation PragmaLoc,
8341  SourceLocation WeakNameLoc,
8342  SourceLocation AliasNameLoc);
8343 
8344  /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident.
8345  void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
8346  IdentifierInfo* AliasName,
8347  SourceLocation PragmaLoc,
8348  SourceLocation WeakNameLoc,
8349  SourceLocation AliasNameLoc);
8350 
8351  /// ActOnPragmaFPContract - Called on well formed
8352  /// \#pragma {STDC,OPENCL} FP_CONTRACT and
8353  /// \#pragma clang fp contract
8354  void ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC);
8355 
8356  /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
8357  /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
8358  void AddAlignmentAttributesForRecord(RecordDecl *RD);
8359 
8360  /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
8361  void AddMsStructLayoutForRecord(RecordDecl *RD);
8362 
8363  /// FreePackedContext - Deallocate and null out PackContext.
8364  void FreePackedContext();
8365 
8366  /// PushNamespaceVisibilityAttr - Note that we've entered a
8367  /// namespace with a visibility attribute.
8368  void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
8369  SourceLocation Loc);
8370 
8371  /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used,
8372  /// add an appropriate visibility attribute.
8373  void AddPushedVisibilityAttribute(Decl *RD);
8374 
8375  /// PopPragmaVisibility - Pop the top element of the visibility stack; used
8376  /// for '\#pragma GCC visibility' and visibility attributes on namespaces.
8377  void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);
8378 
8379  /// FreeVisContext - Deallocate and null out VisContext.
8380  void FreeVisContext();
8381 
8382  /// AddCFAuditedAttribute - Check whether we're currently within
8383  /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding
8384  /// the appropriate attribute.
8385  void AddCFAuditedAttribute(Decl *D);
8386 
8387  /// \brief Called on well-formed '\#pragma clang attribute push'.
8388  void ActOnPragmaAttributePush(AttributeList &Attribute,
8389  SourceLocation PragmaLoc,
8391 
8392  /// \brief Called on well-formed '\#pragma clang attribute pop'.
8393  void ActOnPragmaAttributePop(SourceLocation PragmaLoc);
8394 
8395  /// \brief Adds the attributes that have been specified using the
8396  /// '\#pragma clang attribute push' directives to the given declaration.
8397  void AddPragmaAttributes(Scope *S, Decl *D);
8398 
8399  void DiagnoseUnterminatedPragmaAttribute();
8400 
8401  /// \brief Called on well formed \#pragma clang optimize.
8402  void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
8403 
8404  /// \brief Get the location for the currently active "\#pragma clang optimize
8405  /// off". If this location is invalid, then the state of the pragma is "on".
8407  return OptimizeOffPragmaLocation;
8408  }
8409 
8410  /// \brief Only called on function definitions; if there is a pragma in scope
8411  /// with the effect of a range-based optnone, consider marking the function
8412  /// with attribute optnone.
8413  void AddRangeBasedOptnone(FunctionDecl *FD);
8414 
8415  /// \brief Adds the 'optnone' attribute to the function declaration if there
8416  /// are no conflicts; Loc represents the location causing the 'optnone'
8417  /// attribute to be added (usually because of a pragma).
8418  void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
8419 
8420  /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
8421  void AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
8422  unsigned SpellingListIndex, bool IsPackExpansion);
8423  void AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *T,
8424  unsigned SpellingListIndex, bool IsPackExpansion);
8425 
8426  /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
8427  /// declaration.
8428  void AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, Expr *OE,
8429  unsigned SpellingListIndex);
8430 
8431  /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular
8432  /// declaration.
8433  void AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
8434  unsigned SpellingListIndex);
8435 
8436  /// AddAlignValueAttr - Adds an align_value attribute to a particular
8437  /// declaration.
8438  void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
8439  unsigned SpellingListIndex);
8440 
8441  /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
8442  /// declaration.
8443  void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
8444  Expr *MinBlocks, unsigned SpellingListIndex);
8445 
8446  /// AddModeAttr - Adds a mode attribute to a particular declaration.
8447  void AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
8448  unsigned SpellingListIndex, bool InInstantiation = false);
8449 
8450  void AddParameterABIAttr(SourceRange AttrRange, Decl *D,
8451  ParameterABI ABI, unsigned SpellingListIndex);
8452 
8453  void AddNSConsumedAttr(SourceRange AttrRange, Decl *D,
8454  unsigned SpellingListIndex, bool isNSConsumed,
8456 
8457  bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
8458 
8459  //===--------------------------------------------------------------------===//
8460  // C++ Coroutines TS
8461  //
8462  bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
8463  StringRef Keyword);
8464  ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
8465  ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
8466  StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
8467 
8468  ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
8469  bool IsImplicit = false);
8470  ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
8471  UnresolvedLookupExpr* Lookup);
8472  ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
8473  StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
8474  bool IsImplicit = false);
8475  StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
8476  VarDecl *buildCoroutinePromise(SourceLocation Loc);
8477  void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
8478 
8479  //===--------------------------------------------------------------------===//
8480  // OpenCL extensions.
8481  //
8482 private:
8483  std::string CurrOpenCLExtension;
8484  /// Extensions required by an OpenCL type.
8485  llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap;
8486  /// Extensions required by an OpenCL declaration.
8487  llvm::DenseMap<const Decl*, std::set<std::string>> OpenCLDeclExtMap;
8488 public:
8489  llvm::StringRef getCurrentOpenCLExtension() const {
8490  return CurrOpenCLExtension;
8491  }
8492  void setCurrentOpenCLExtension(llvm::StringRef Ext) {
8493  CurrOpenCLExtension = Ext;
8494  }
8495 
8496  /// \brief Set OpenCL extensions for a type which can only be used when these
8497  /// OpenCL extensions are enabled. If \p Exts is empty, do nothing.
8498  /// \param Exts A space separated list of OpenCL extensions.
8499  void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts);
8500 
8501  /// \brief Set OpenCL extensions for a declaration which can only be
8502  /// used when these OpenCL extensions are enabled. If \p Exts is empty, do
8503  /// nothing.
8504  /// \param Exts A space separated list of OpenCL extensions.
8505  void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts);
8506 
8507  /// \brief Set current OpenCL extensions for a type which can only be used
8508  /// when these OpenCL extensions are enabled. If current OpenCL extension is
8509  /// empty, do nothing.
8510  void setCurrentOpenCLExtensionForType(QualType T);
8511 
8512  /// \brief Set current OpenCL extensions for a declaration which
8513  /// can only be used when these OpenCL extensions are enabled. If current
8514  /// OpenCL extension is empty, do nothing.
8515  void setCurrentOpenCLExtensionForDecl(Decl *FD);
8516 
8517  bool isOpenCLDisabledDecl(Decl *FD);
8518 
8519  /// \brief Check if type \p T corresponding to declaration specifier \p DS
8520  /// is disabled due to required OpenCL extensions being disabled. If so,
8521  /// emit diagnostics.
8522  /// \return true if type is disabled.
8523  bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T);
8524 
8525  /// \brief Check if declaration \p D used by expression \p E
8526  /// is disabled due to required OpenCL extensions being disabled. If so,
8527  /// emit diagnostics.
8528  /// \return true if type is disabled.
8529  bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);
8530 
8531  //===--------------------------------------------------------------------===//
8532  // OpenMP directives and clauses.
8533  //
8534 private:
8535  void *VarDataSharingAttributesStack;
8536  /// Set to true inside '#pragma omp declare target' region.
8537  bool IsInOpenMPDeclareTargetContext = false;
8538  /// \brief Initialization of data-sharing attributes stack.
8539  void InitDataSharingAttributesStack();
8540  void DestroyDataSharingAttributesStack();
8541  ExprResult
8542  VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
8543  bool StrictlyPositive = true);
8544  /// Returns OpenMP nesting level for current directive.
8545  unsigned getOpenMPNestingLevel() const;
8546 
8547  /// Adjusts the function scopes index for the target-based regions.
8548  void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
8549  unsigned Level) const;
8550 
8551  /// Push new OpenMP function region for non-capturing function.
8552  void pushOpenMPFunctionRegion();
8553 
8554  /// Pop OpenMP function region for non-capturing function.
8555  void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
8556 
8557  /// Checks if a type or a declaration is disabled due to the owning extension
8558  /// being disabled, and emits diagnostic messages if it is disabled.
8559  /// \param D type or declaration to be checked.
8560  /// \param DiagLoc source location for the diagnostic message.
8561  /// \param DiagInfo information to be emitted for the diagnostic message.
8562  /// \param SrcRange source range of the declaration.
8563  /// \param Map maps type or declaration to the extensions.
8564  /// \param Selector selects diagnostic message: 0 for type and 1 for
8565  /// declaration.
8566  /// \return true if the type or declaration is disabled.
8567  template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
8568  bool checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo,
8569  MapT &Map, unsigned Selector = 0,
8570  SourceRange SrcRange = SourceRange());
8571 
8572 public:
8573  /// \brief Return true if the provided declaration \a VD should be captured by
8574  /// reference.
8575  /// \param Level Relative level of nested OpenMP construct for that the check
8576  /// is performed.
8577  bool IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level);
8578 
8579  /// \brief Check if the specified variable is used in one of the private
8580  /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP
8581  /// constructs.
8582  VarDecl *IsOpenMPCapturedDecl(ValueDecl *D);
8583  ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
8584  ExprObjectKind OK, SourceLocation Loc);
8585 
8586  /// \brief Check if the specified variable is used in 'private' clause.
8587  /// \param Level Relative level of nested OpenMP construct for that the check
8588  /// is performed.
8589  bool isOpenMPPrivateDecl(ValueDecl *D, unsigned Level);
8590 
8591  /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)
8592  /// for \p FD based on DSA for the provided corresponding captured declaration
8593  /// \p D.
8594  void setOpenMPCaptureKind(FieldDecl *FD, ValueDecl *D, unsigned Level);
8595 
8596  /// \brief Check if the specified variable is captured by 'target' directive.
8597  /// \param Level Relative level of nested OpenMP construct for that the check
8598  /// is performed.
8599  bool isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level);
8600 
8601  ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,
8602  Expr *Op);
8603  /// \brief Called on start of new data sharing attribute block.
8604  void StartOpenMPDSABlock(OpenMPDirectiveKind K,
8605  const DeclarationNameInfo &DirName, Scope *CurScope,
8606  SourceLocation Loc);
8607  /// \brief Start analysis of clauses.
8608  void StartOpenMPClause(OpenMPClauseKind K);
8609  /// \brief End analysis of clauses.
8610  void EndOpenMPClause();
8611  /// \brief Called on end of data sharing attribute block.
8612  void EndOpenMPDSABlock(Stmt *CurDirective);
8613 
8614  /// \brief Check if the current region is an OpenMP loop region and if it is,
8615  /// mark loop control variable, used in \p Init for loop initialization, as
8616  /// private by default.
8617  /// \param Init First part of the for loop.
8618  void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
8619 
8620  // OpenMP directives and clauses.
8621  /// \brief Called on correct id-expression from the '#pragma omp
8622  /// threadprivate'.
8623  ExprResult ActOnOpenMPIdExpression(Scope *CurScope,
8624  CXXScopeSpec &ScopeSpec,
8625  const DeclarationNameInfo &Id);
8626  /// \brief Called on well-formed '#pragma omp threadprivate'.
8627  DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
8628  SourceLocation Loc,
8629  ArrayRef<Expr *> VarList);
8630  /// \brief Builds a new OpenMPThreadPrivateDecl and checks its correctness.
8631  OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(
8632  SourceLocation Loc,
8633  ArrayRef<Expr *> VarList);
8634  /// \brief Check if the specified type is allowed to be used in 'omp declare
8635  /// reduction' construct.
8636  QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
8638  /// \brief Called on start of '#pragma omp declare reduction'.
8639  DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(
8640  Scope *S, DeclContext *DC, DeclarationName Name,
8641  ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
8642  AccessSpecifier AS, Decl *PrevDeclInScope = nullptr);
8643  /// \brief Initialize declare reduction construct initializer.
8644  void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D);
8645  /// \brief Finish current declare reduction construct initializer.
8646  void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);
8647  /// \brief Initialize declare reduction construct initializer.
8648  /// \return omp_priv variable.
8649  VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D);
8650  /// \brief Finish current declare reduction construct initializer.
8651  void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
8652  VarDecl *OmpPrivParm);
8653  /// \brief Called at the end of '#pragma omp declare reduction'.
8654  DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(
8655  Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid);
8656 
8657  /// Called on the start of target region i.e. '#pragma omp declare target'.
8658  bool ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc);
8659  /// Called at the end of target region i.e. '#pragme omp end declare target'.
8660  void ActOnFinishOpenMPDeclareTargetDirective();
8661  /// Called on correct id-expression from the '#pragma omp declare target'.
8662  void ActOnOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec,
8663  const DeclarationNameInfo &Id,
8664  OMPDeclareTargetDeclAttr::MapTypeTy MT,
8665  NamedDeclSetType &SameDirectiveDecls);
8666  /// Check declaration inside target region.
8667  void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
8668  SourceLocation IdLoc = SourceLocation());
8669  /// Return true inside OpenMP declare target region.
8671  return IsInOpenMPDeclareTargetContext;
8672  }
8673  /// Return true inside OpenMP target region.
8674  bool isInOpenMPTargetExecutionDirective() const;
8675  /// Return true if (un)supported features for the current target should be
8676  /// diagnosed if OpenMP (offloading) is enabled.
8678  return !getLangOpts().OpenMPIsDevice || isInOpenMPDeclareTargetContext() ||
8679  isInOpenMPTargetExecutionDirective();
8680  }
8681 
8682  /// Return the number of captured regions created for an OpenMP directive.
8683  static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);
8684 
8685  /// \brief Initialization of captured region for OpenMP region.
8686  void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
8687  /// \brief End of OpenMP region.
8688  ///
8689  /// \param S Statement associated with the current OpenMP region.
8690  /// \param Clauses List of clauses for the current OpenMP region.
8691  ///
8692  /// \returns Statement for finished OpenMP region.
8693  StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
8694  StmtResult ActOnOpenMPExecutableDirective(
8695  OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
8696  OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
8697  Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
8698  /// \brief Called on well-formed '\#pragma omp parallel' after parsing
8699  /// of the associated statement.
8700  StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
8701  Stmt *AStmt,
8702  SourceLocation StartLoc,
8703  SourceLocation EndLoc);
8704  /// \brief Called on well-formed '\#pragma omp simd' after parsing
8705  /// of the associated statement.
8706  StmtResult ActOnOpenMPSimdDirective(
8707  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8708  SourceLocation EndLoc,
8709  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8710  /// \brief Called on well-formed '\#pragma omp for' after parsing
8711  /// of the associated statement.
8712  StmtResult ActOnOpenMPForDirective(
8713  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8714  SourceLocation EndLoc,
8715  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8716  /// \brief Called on well-formed '\#pragma omp for simd' after parsing
8717  /// of the associated statement.
8718  StmtResult ActOnOpenMPForSimdDirective(
8719  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8720  SourceLocation EndLoc,
8721  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8722  /// \brief Called on well-formed '\#pragma omp sections' after parsing
8723  /// of the associated statement.
8724  StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
8725  Stmt *AStmt, SourceLocation StartLoc,
8726  SourceLocation EndLoc);
8727  /// \brief Called on well-formed '\#pragma omp section' after parsing of the
8728  /// associated statement.
8729  StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
8730  SourceLocation EndLoc);
8731  /// \brief Called on well-formed '\#pragma omp single' after parsing of the
8732  /// associated statement.
8733  StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
8734  Stmt *AStmt, SourceLocation StartLoc,
8735  SourceLocation EndLoc);
8736  /// \brief Called on well-formed '\#pragma omp master' after parsing of the
8737  /// associated statement.
8738  StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
8739  SourceLocation EndLoc);
8740  /// \brief Called on well-formed '\#pragma omp critical' after parsing of the
8741  /// associated statement.
8742  StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,
8743  ArrayRef<OMPClause *> Clauses,
8744  Stmt *AStmt, SourceLocation StartLoc,
8745  SourceLocation EndLoc);
8746  /// \brief Called on well-formed '\#pragma omp parallel for' after parsing
8747  /// of the associated statement.
8748  StmtResult ActOnOpenMPParallelForDirective(
8749  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8750  SourceLocation EndLoc,
8751  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8752  /// \brief Called on well-formed '\#pragma omp parallel for simd' after
8753  /// parsing of the associated statement.
8754  StmtResult ActOnOpenMPParallelForSimdDirective(
8755  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8756  SourceLocation EndLoc,
8757  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8758  /// \brief Called on well-formed '\#pragma omp parallel sections' after
8759  /// parsing of the associated statement.
8760  StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
8761  Stmt *AStmt,
8762  SourceLocation StartLoc,
8763  SourceLocation EndLoc);
8764  /// \brief Called on well-formed '\#pragma omp task' after parsing of the
8765  /// associated statement.
8766  StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
8767  Stmt *AStmt, SourceLocation StartLoc,
8768  SourceLocation EndLoc);
8769  /// \brief Called on well-formed '\#pragma omp taskyield'.
8770  StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
8771  SourceLocation EndLoc);
8772  /// \brief Called on well-formed '\#pragma omp barrier'.
8773  StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
8774  SourceLocation EndLoc);
8775  /// \brief Called on well-formed '\#pragma omp taskwait'.
8776  StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
8777  SourceLocation EndLoc);
8778  /// \brief Called on well-formed '\#pragma omp taskgroup'.
8779  StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,
8780  Stmt *AStmt, SourceLocation StartLoc,
8781  SourceLocation EndLoc);
8782  /// \brief Called on well-formed '\#pragma omp flush'.
8783  StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
8784  SourceLocation StartLoc,
8785  SourceLocation EndLoc);
8786  /// \brief Called on well-formed '\#pragma omp ordered' after parsing of the
8787  /// associated statement.
8788  StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
8789  Stmt *AStmt, SourceLocation StartLoc,
8790  SourceLocation EndLoc);
8791  /// \brief Called on well-formed '\#pragma omp atomic' after parsing of the
8792  /// associated statement.
8793  StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
8794  Stmt *AStmt, SourceLocation StartLoc,
8795  SourceLocation EndLoc);
8796  /// \brief Called on well-formed '\#pragma omp target' after parsing of the
8797  /// associated statement.
8798  StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
8799  Stmt *AStmt, SourceLocation StartLoc,
8800  SourceLocation EndLoc);
8801  /// \brief Called on well-formed '\#pragma omp target data' after parsing of
8802  /// the associated statement.
8803  StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
8804  Stmt *AStmt, SourceLocation StartLoc,
8805  SourceLocation EndLoc);
8806  /// \brief Called on well-formed '\#pragma omp target enter data' after
8807  /// parsing of the associated statement.
8808  StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
8809  SourceLocation StartLoc,
8810  SourceLocation EndLoc,
8811  Stmt *AStmt);
8812  /// \brief Called on well-formed '\#pragma omp target exit data' after
8813  /// parsing of the associated statement.
8814  StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
8815  SourceLocation StartLoc,
8816  SourceLocation EndLoc,
8817  Stmt *AStmt);
8818  /// \brief Called on well-formed '\#pragma omp target parallel' after
8819  /// parsing of the associated statement.
8820  StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
8821  Stmt *AStmt,
8822  SourceLocation StartLoc,
8823  SourceLocation EndLoc);
8824  /// \brief Called on well-formed '\#pragma omp target parallel for' after
8825  /// parsing of the associated statement.
8826  StmtResult ActOnOpenMPTargetParallelForDirective(
8827  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8828  SourceLocation EndLoc,
8829  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8830  /// \brief Called on well-formed '\#pragma omp teams' after parsing of the
8831  /// associated statement.
8832  StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
8833  Stmt *AStmt, SourceLocation StartLoc,
8834  SourceLocation EndLoc);
8835  /// \brief Called on well-formed '\#pragma omp cancellation point'.
8836  StmtResult
8837  ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
8838  SourceLocation EndLoc,
8839  OpenMPDirectiveKind CancelRegion);
8840  /// \brief Called on well-formed '\#pragma omp cancel'.
8841  StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
8842  SourceLocation StartLoc,
8843  SourceLocation EndLoc,
8844  OpenMPDirectiveKind CancelRegion);
8845  /// \brief Called on well-formed '\#pragma omp taskloop' after parsing of the
8846  /// associated statement.
8847  StmtResult ActOnOpenMPTaskLoopDirective(
8848  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8849  SourceLocation EndLoc,
8850  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8851  /// \brief Called on well-formed '\#pragma omp taskloop simd' after parsing of
8852  /// the associated statement.
8853  StmtResult ActOnOpenMPTaskLoopSimdDirective(
8854  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8855  SourceLocation EndLoc,
8856  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8857  /// \brief Called on well-formed '\#pragma omp distribute' after parsing
8858  /// of the associated statement.
8859  StmtResult ActOnOpenMPDistributeDirective(
8860  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8861  SourceLocation EndLoc,
8862  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8863  /// \brief Called on well-formed '\#pragma omp target update'.
8864  StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
8865  SourceLocation StartLoc,
8866  SourceLocation EndLoc,
8867  Stmt *AStmt);
8868  /// \brief Called on well-formed '\#pragma omp distribute parallel for' after
8869  /// parsing of the associated statement.
8870  StmtResult ActOnOpenMPDistributeParallelForDirective(
8871  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8872  SourceLocation EndLoc,
8873  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8874  /// \brief Called on well-formed '\#pragma omp distribute parallel for simd'
8875  /// after parsing of the associated statement.
8876  StmtResult ActOnOpenMPDistributeParallelForSimdDirective(
8877  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8878  SourceLocation EndLoc,
8879  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8880  /// \brief Called on well-formed '\#pragma omp distribute simd' after
8881  /// parsing of the associated statement.
8882  StmtResult ActOnOpenMPDistributeSimdDirective(
8883  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8884  SourceLocation EndLoc,
8885  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8886  /// \brief Called on well-formed '\#pragma omp target parallel for simd' after
8887  /// parsing of the associated statement.
8888  StmtResult ActOnOpenMPTargetParallelForSimdDirective(
8889  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8890  SourceLocation EndLoc,
8891  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8892  /// \brief Called on well-formed '\#pragma omp target simd' after parsing of
8893  /// the associated statement.
8894  StmtResult ActOnOpenMPTargetSimdDirective(
8895  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8896  SourceLocation EndLoc,
8897  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8898  /// Called on well-formed '\#pragma omp teams distribute' after parsing of
8899  /// the associated statement.
8900  StmtResult ActOnOpenMPTeamsDistributeDirective(
8901  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8902  SourceLocation EndLoc,
8903  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8904  /// Called on well-formed '\#pragma omp teams distribute simd' after parsing
8905  /// of the associated statement.
8906  StmtResult ActOnOpenMPTeamsDistributeSimdDirective(
8907  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8908  SourceLocation EndLoc,
8909  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8910  /// Called on well-formed '\#pragma omp teams distribute parallel for simd'
8911  /// after parsing of the associated statement.
8912  StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(
8913  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8914  SourceLocation EndLoc,
8915  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8916  /// Called on well-formed '\#pragma omp teams distribute parallel for'
8917  /// after parsing of the associated statement.
8918  StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(
8919  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8920  SourceLocation EndLoc,
8921  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8922  /// Called on well-formed '\#pragma omp target teams' after parsing of the
8923  /// associated statement.
8924  StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
8925  Stmt *AStmt,
8926  SourceLocation StartLoc,
8927  SourceLocation EndLoc);
8928  /// Called on well-formed '\#pragma omp target teams distribute' after parsing
8929  /// of the associated statement.
8930  StmtResult ActOnOpenMPTargetTeamsDistributeDirective(
8931  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8932  SourceLocation EndLoc,
8933  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8934  /// Called on well-formed '\#pragma omp target teams distribute parallel for'
8935  /// after parsing of the associated statement.
8936  StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(
8937  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8938  SourceLocation EndLoc,
8939  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8940  /// Called on well-formed '\#pragma omp target teams distribute parallel for
8941  /// simd' after parsing of the associated statement.
8942  StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
8943  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8944  SourceLocation EndLoc,
8945  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8946  /// Called on well-formed '\#pragma omp target teams distribute simd' after
8947  /// parsing of the associated statement.
8948  StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
8949  ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8950  SourceLocation EndLoc,
8951  llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA);
8952 
8953  /// Checks correctness of linear modifiers.
8954  bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
8955  SourceLocation LinLoc);
8956  /// Checks that the specified declaration matches requirements for the linear
8957  /// decls.
8958  bool CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc,
8959  OpenMPLinearClauseKind LinKind, QualType Type);
8960 
8961  /// \brief Called on well-formed '\#pragma omp declare simd' after parsing of
8962  /// the associated method/function.
8963  DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
8964  DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
8965  Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
8966  ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
8967  ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
8968 
8969  OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
8970  Expr *Expr,
8971  SourceLocation StartLoc,
8972  SourceLocation LParenLoc,
8973  SourceLocation EndLoc);
8974  /// \brief Called on well-formed 'if' clause.
8975  OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
8976  Expr *Condition, SourceLocation StartLoc,
8977  SourceLocation LParenLoc,
8978  SourceLocation NameModifierLoc,
8979  SourceLocation ColonLoc,
8980  SourceLocation EndLoc);
8981  /// \brief Called on well-formed 'final' clause.
8982  OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
8983  SourceLocation LParenLoc,
8984  SourceLocation EndLoc);
8985  /// \brief Called on well-formed 'num_threads' clause.
8986  OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
8987  SourceLocation StartLoc,
8988  SourceLocation LParenLoc,
8989  SourceLocation EndLoc);
8990  /// \brief Called on well-formed 'safelen' clause.
8991  OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
8992  SourceLocation StartLoc,
8993  SourceLocation LParenLoc,
8994  SourceLocation EndLoc);
8995  /// \brief Called on well-formed 'simdlen' clause.
8996  OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
8997  SourceLocation LParenLoc,
8998  SourceLocation EndLoc);
8999  /// \brief Called on well-formed 'collapse' clause.
9000  OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,
9001  SourceLocation StartLoc,
9002  SourceLocation LParenLoc,
9003  SourceLocation EndLoc);
9004  /// \brief Called on well-formed 'ordered' clause.
9005  OMPClause *
9006  ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,
9007  SourceLocation LParenLoc = SourceLocation(),
9008  Expr *NumForLoops = nullptr);
9009  /// \brief Called on well-formed 'grainsize' clause.
9010  OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,
9011  SourceLocation LParenLoc,
9012  SourceLocation EndLoc);
9013  /// \brief Called on well-formed 'num_tasks' clause.
9014  OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
9015  SourceLocation LParenLoc,
9016  SourceLocation EndLoc);
9017  /// \brief Called on well-formed 'hint' clause.
9018  OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
9019  SourceLocation LParenLoc,
9020  SourceLocation EndLoc);
9021 
9022  OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
9023  unsigned Argument,
9024  SourceLocation ArgumentLoc,
9025  SourceLocation StartLoc,
9026  SourceLocation LParenLoc,
9027  SourceLocation EndLoc);
9028  /// \brief Called on well-formed 'default' clause.
9029  OMPClause *ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind,
9030  SourceLocation KindLoc,
9031  SourceLocation StartLoc,
9032  SourceLocation LParenLoc,
9033  SourceLocation EndLoc);
9034  /// \brief Called on well-formed 'proc_bind' clause.
9035  OMPClause *ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind,
9036  SourceLocation KindLoc,
9037  SourceLocation StartLoc,
9038  SourceLocation LParenLoc,
9039  SourceLocation EndLoc);
9040 
9041  OMPClause *ActOnOpenMPSingleExprWithArgClause(
9042  OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
9043  SourceLocation StartLoc, SourceLocation LParenLoc,
9044  ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,
9045  SourceLocation EndLoc);
9046  /// \brief Called on well-formed 'schedule' clause.
9047  OMPClause *ActOnOpenMPScheduleClause(
9049  OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
9050  SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
9051  SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);
9052 
9053  OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,
9054  SourceLocation EndLoc);
9055  /// \brief Called on well-formed 'nowait' clause.
9056  OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,
9057  SourceLocation EndLoc);
9058  /// \brief Called on well-formed 'untied' clause.
9059  OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,
9060  SourceLocation EndLoc);
9061  /// \brief Called on well-formed 'mergeable' clause.
9062  OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,
9063  SourceLocation EndLoc);
9064  /// \brief Called on well-formed 'read' clause.
9065  OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,
9066  SourceLocation EndLoc);
9067  /// \brief Called on well-formed 'write' clause.
9068  OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,
9069  SourceLocation EndLoc);
9070  /// \brief Called on well-formed 'update' clause.
9071  OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
9072  SourceLocation EndLoc);
9073  /// \brief Called on well-formed 'capture' clause.
9074  OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
9075  SourceLocation EndLoc);
9076  /// \brief Called on well-formed 'seq_cst' clause.
9077  OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
9078  SourceLocation EndLoc);
9079  /// \brief Called on well-formed 'threads' clause.
9080  OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
9081  SourceLocation EndLoc);
9082  /// \brief Called on well-formed 'simd' clause.
9083  OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
9084  SourceLocation EndLoc);
9085  /// \brief Called on well-formed 'nogroup' clause.
9086  OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,
9087  SourceLocation EndLoc);
9088 
9089  OMPClause *ActOnOpenMPVarListClause(
9090  OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *TailExpr,
9091  SourceLocation StartLoc, SourceLocation LParenLoc,
9092  SourceLocation ColonLoc, SourceLocation EndLoc,
9093  CXXScopeSpec &ReductionIdScopeSpec,
9094  const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind,
9095  OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier,
9096  OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
9097  SourceLocation DepLinMapLoc);
9098  /// \brief Called on well-formed 'private' clause.
9099  OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
9100  SourceLocation StartLoc,
9101  SourceLocation LParenLoc,
9102  SourceLocation EndLoc);
9103  /// \brief Called on well-formed 'firstprivate' clause.
9104  OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
9105  SourceLocation StartLoc,
9106  SourceLocation LParenLoc,
9107  SourceLocation EndLoc);
9108  /// \brief Called on well-formed 'lastprivate' clause.
9109  OMPClause *ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList,
9110  SourceLocation StartLoc,
9111  SourceLocation LParenLoc,
9112  SourceLocation EndLoc);
9113  /// \brief Called on well-formed 'shared' clause.
9114  OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
9115  SourceLocation StartLoc,
9116  SourceLocation LParenLoc,
9117  SourceLocation EndLoc);
9118  /// \brief Called on well-formed 'reduction' clause.
9119  OMPClause *ActOnOpenMPReductionClause(
9120  ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9121  SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
9122  CXXScopeSpec &ReductionIdScopeSpec,
9123  const DeclarationNameInfo &ReductionId,
9124  ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9125  /// Called on well-formed 'task_reduction' clause.
9126  OMPClause *ActOnOpenMPTaskReductionClause(
9127  ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9128  SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
9129  CXXScopeSpec &ReductionIdScopeSpec,
9130  const DeclarationNameInfo &ReductionId,
9131  ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9132  /// Called on well-formed 'in_reduction' clause.
9133  OMPClause *ActOnOpenMPInReductionClause(
9134  ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9135  SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
9136  CXXScopeSpec &ReductionIdScopeSpec,
9137  const DeclarationNameInfo &ReductionId,
9138  ArrayRef<Expr *> UnresolvedReductions = llvm::None);
9139  /// \brief Called on well-formed 'linear' clause.
9140  OMPClause *
9141  ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
9142  SourceLocation StartLoc, SourceLocation LParenLoc,
9143  OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,
9144  SourceLocation ColonLoc, SourceLocation EndLoc);
9145  /// \brief Called on well-formed 'aligned' clause.
9146  OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,
9147  Expr *Alignment,
9148  SourceLocation StartLoc,
9149  SourceLocation LParenLoc,
9150  SourceLocation ColonLoc,
9151  SourceLocation EndLoc);
9152  /// \brief Called on well-formed 'copyin' clause.
9153  OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
9154  SourceLocation StartLoc,
9155  SourceLocation LParenLoc,
9156  SourceLocation EndLoc);
9157  /// \brief Called on well-formed 'copyprivate' clause.
9158  OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
9159  SourceLocation StartLoc,
9160  SourceLocation LParenLoc,
9161  SourceLocation EndLoc);
9162  /// \brief Called on well-formed 'flush' pseudo clause.
9163  OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
9164  SourceLocation StartLoc,
9165  SourceLocation LParenLoc,
9166  SourceLocation EndLoc);
9167  /// \brief Called on well-formed 'depend' clause.
9168  OMPClause *
9169  ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
9170  SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
9171  SourceLocation StartLoc, SourceLocation LParenLoc,
9172  SourceLocation EndLoc);
9173  /// \brief Called on well-formed 'device' clause.
9174  OMPClause *ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc,
9175  SourceLocation LParenLoc,
9176  SourceLocation EndLoc);
9177  /// \brief Called on well-formed 'map' clause.
9178  OMPClause *
9179  ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier,
9180  OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
9181  SourceLocation MapLoc, SourceLocation ColonLoc,
9182  ArrayRef<Expr *> VarList, SourceLocation StartLoc,
9183  SourceLocation LParenLoc, SourceLocation EndLoc);
9184  /// \brief Called on well-formed 'num_teams' clause.
9185  OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
9186  SourceLocation LParenLoc,
9187  SourceLocation EndLoc);
9188  /// \brief Called on well-formed 'thread_limit' clause.
9189  OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
9190  SourceLocation StartLoc,
9191  SourceLocation LParenLoc,
9192  SourceLocation EndLoc);
9193  /// \brief Called on well-formed 'priority' clause.
9194  OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
9195  SourceLocation LParenLoc,
9196  SourceLocation EndLoc);
9197  /// \brief Called on well-formed 'dist_schedule' clause.
9198  OMPClause *ActOnOpenMPDistScheduleClause(
9199  OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
9200  SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,
9201  SourceLocation CommaLoc, SourceLocation EndLoc);
9202  /// \brief Called on well-formed 'defaultmap' clause.
9203  OMPClause *ActOnOpenMPDefaultmapClause(
9205  SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
9206  SourceLocation KindLoc, SourceLocation EndLoc);
9207  /// \brief Called on well-formed 'to' clause.
9208  OMPClause *ActOnOpenMPToClause(ArrayRef<Expr *> VarList,
9209  SourceLocation StartLoc,
9210  SourceLocation LParenLoc,
9211  SourceLocation EndLoc);
9212  /// \brief Called on well-formed 'from' clause.
9213  OMPClause *ActOnOpenMPFromClause(ArrayRef<Expr *> VarList,
9214  SourceLocation StartLoc,
9215  SourceLocation LParenLoc,
9216  SourceLocation EndLoc);
9217  /// Called on well-formed 'use_device_ptr' clause.
9218  OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
9219  SourceLocation StartLoc,
9220  SourceLocation LParenLoc,
9221  SourceLocation EndLoc);
9222  /// Called on well-formed 'is_device_ptr' clause.
9223  OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
9224  SourceLocation StartLoc,
9225  SourceLocation LParenLoc,
9226  SourceLocation EndLoc);
9227 
9228  /// \brief The kind of conversion being performed.
9230  /// \brief An implicit conversion.
9232  /// \brief A C-style cast.
9234  /// \brief A functional-style cast.
9236  /// \brief A cast other than a C-style cast.
9237  CCK_OtherCast
9238  };
9239 
9240  /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
9241  /// cast. If there is already an implicit cast, merge into the existing one.
9242  /// If isLvalue, the result of the cast is an lvalue.
9243  ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
9244  ExprValueKind VK = VK_RValue,
9245  const CXXCastPath *BasePath = nullptr,
9247  = CCK_ImplicitConversion);
9248 
9249  /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
9250  /// to the conversion from scalar type ScalarTy to the Boolean type.
9251  static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
9252 
9253  /// IgnoredValueConversions - Given that an expression's result is
9254  /// syntactically ignored, perform any conversions that are
9255  /// required.
9256  ExprResult IgnoredValueConversions(Expr *E);
9257 
9258  // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
9259  // functions and arrays to their respective pointers (C99 6.3.2.1).
9260  ExprResult UsualUnaryConversions(Expr *E);
9261 
9262  /// CallExprUnaryConversions - a special case of an unary conversion
9263  /// performed on a function designator of a call expression.
9264  ExprResult CallExprUnaryConversions(Expr *E);
9265 
9266  // DefaultFunctionArrayConversion - converts functions and arrays
9267  // to their respective pointers (C99 6.3.2.1).
9268  ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);
9269 
9270  // DefaultFunctionArrayLvalueConversion - converts functions and
9271  // arrays to their respective pointers and performs the
9272  // lvalue-to-rvalue conversion.
9273  ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
9274  bool Diagnose = true);
9275 
9276  // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on
9277  // the operand. This is DefaultFunctionArrayLvalueConversion,
9278  // except that it assumes the operand isn't of function or array
9279  // type.
9280  ExprResult DefaultLvalueConversion(Expr *E);
9281 
9282  // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
9283  // do not have a prototype. Integer promotions are performed on each
9284  // argument, and arguments that have type float are promoted to double.
9285  ExprResult DefaultArgumentPromotion(Expr *E);
9286 
9287  /// If \p E is a prvalue denoting an unmaterialized temporary, materialize
9288  /// it as an xvalue. In C++98, the result will still be a prvalue, because
9289  /// we don't have xvalues there.
9290  ExprResult TemporaryMaterializationConversion(Expr *E);
9291 
9292  // Used for emitting the right warning by DefaultVariadicArgumentPromotion
9298  VariadicDoesNotApply
9299  };
9300 
9301  VariadicCallType getVariadicCallType(FunctionDecl *FDecl,
9302  const FunctionProtoType *Proto,
9303  Expr *Fn);
9304 
9305  // Used for determining in which context a type is allowed to be passed to a
9306  // vararg function.
9307  enum VarArgKind {
9312  VAK_Invalid
9313  };
9314 
9315  // Determines which VarArgKind fits an expression.
9316  VarArgKind isValidVarArgType(const QualType &Ty);
9317 
9318  /// Check to see if the given expression is a valid argument to a variadic
9319  /// function, issuing a diagnostic if not.
9320  void checkVariadicArgument(const Expr *E, VariadicCallType CT);
9321 
9322  /// Check to see if a given expression could have '.c_str()' called on it.
9323  bool hasCStrMethod(const Expr *E);
9324 
9325  /// GatherArgumentsForCall - Collector argument expressions for various
9326  /// form of call prototypes.
9327  bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
9328  const FunctionProtoType *Proto,
9329  unsigned FirstParam, ArrayRef<Expr *> Args,
9330  SmallVectorImpl<Expr *> &AllArgs,
9331  VariadicCallType CallType = VariadicDoesNotApply,
9332  bool AllowExplicit = false,
9333  bool IsListInitialization = false);
9334 
9335  // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
9336  // will create a runtime trap if the resulting type is not a POD type.
9337  ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
9338  FunctionDecl *FDecl);
9339 
9340  // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
9341  // operands and then handles various conversions that are common to binary
9342  // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
9343  // routine returns the first non-arithmetic type found. The client is
9344  // responsible for emitting appropriate error diagnostics.
9345  QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
9346  bool IsCompAssign = false);
9347 
9348  /// AssignConvertType - All of the 'assignment' semantic checks return this
9349  /// enum to indicate whether the assignment was allowed. These checks are
9350  /// done for simple assignments, as well as initialization, return from
9351  /// function, argument passing, etc. The query is phrased in terms of a
9352  /// source and destination type.
9354  /// Compatible - the types are compatible according to the standard.
9356 
9357  /// PointerToInt - The assignment converts a pointer to an int, which we
9358  /// accept as an extension.
9360 
9361  /// IntToPointer - The assignment converts an int to a pointer, which we
9362  /// accept as an extension.
9364 
9365  /// FunctionVoidPointer - The assignment is between a function pointer and
9366  /// void*, which the standard doesn't allow, but we accept as an extension.
9368 
9369  /// IncompatiblePointer - The assignment is between two pointers types that
9370  /// are not compatible, but we accept them as an extension.
9372 
9373  /// IncompatiblePointerSign - The assignment is between two pointers types
9374  /// which point to integers which have a different sign, but are otherwise
9375  /// identical. This is a subset of the above, but broken out because it's by
9376  /// far the most common case of incompatible pointers.
9378 
9379  /// CompatiblePointerDiscardsQualifiers - The assignment discards
9380  /// c/v/r qualifiers, which we accept as an extension.
9382 
9383  /// IncompatiblePointerDiscardsQualifiers - The assignment
9384  /// discards qualifiers that we don't permit to be discarded,
9385  /// like address spaces.
9387 
9388  /// IncompatibleNestedPointerQualifiers - The assignment is between two
9389  /// nested pointer types, and the qualifiers other than the first two
9390  /// levels differ e.g. char ** -> const char **, but we accept them as an
9391  /// extension.
9393 
9394  /// IncompatibleVectors - The assignment is between two vector types that
9395  /// have the same size, which we accept as an extension.
9397 
9398  /// IntToBlockPointer - The assignment converts an int to a block
9399  /// pointer. We disallow this.
9401 
9402  /// IncompatibleBlockPointer - The assignment is between two block
9403  /// pointers types that are not compatible.
9405 
9406  /// IncompatibleObjCQualifiedId - The assignment is between a qualified
9407  /// id type and something else (that is incompatible with it). For example,
9408  /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
9410 
9411  /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an
9412  /// object with __weak qualifier.
9414 
9415  /// Incompatible - We reject this conversion outright, it is invalid to
9416  /// represent it in the AST.
9417  Incompatible
9418  };
9419 
9420  /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
9421  /// assignment conversion type specified by ConvTy. This returns true if the
9422  /// conversion was invalid or false if the conversion was accepted.
9423  bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
9424  SourceLocation Loc,
9425  QualType DstType, QualType SrcType,
9426  Expr *SrcExpr, AssignmentAction Action,
9427  bool *Complained = nullptr);
9428 
9429  /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag
9430  /// enum. If AllowMask is true, then we also allow the complement of a valid
9431  /// value, to be used as a mask.
9432  bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
9433  bool AllowMask) const;
9434 
9435  /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant
9436  /// integer not in the range of enum values.
9437  void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
9438  Expr *SrcExpr);
9439 
9440  /// CheckAssignmentConstraints - Perform type checking for assignment,
9441  /// argument passing, variable initialization, and function return values.
9442  /// C99 6.5.16.
9443  AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,
9444  QualType LHSType,
9445  QualType RHSType);
9446 
9447  /// Check assignment constraints and optionally prepare for a conversion of
9448  /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS
9449  /// is true.
9450  AssignConvertType CheckAssignmentConstraints(QualType LHSType,
9451  ExprResult &RHS,
9452  CastKind &Kind,
9453  bool ConvertRHS = true);
9454 
9455  /// Check assignment constraints for an assignment of RHS to LHSType.
9456  ///
9457  /// \param LHSType The destination type for the assignment.
9458  /// \param RHS The source expression for the assignment.
9459  /// \param Diagnose If \c true, diagnostics may be produced when checking
9460  /// for assignability. If a diagnostic is produced, \p RHS will be
9461  /// set to ExprError(). Note that this function may still return
9462  /// without producing a diagnostic, even for an invalid assignment.
9463  /// \param DiagnoseCFAudited If \c true, the target is a function parameter
9464  /// in an audited Core Foundation API and does not need to be checked
9465  /// for ARC retain issues.
9466  /// \param ConvertRHS If \c true, \p RHS will be updated to model the
9467  /// conversions necessary to perform the assignment. If \c false,
9468  /// \p Diagnose must also be \c false.
9469  AssignConvertType CheckSingleAssignmentConstraints(
9470  QualType LHSType, ExprResult &RHS, bool Diagnose = true,
9471  bool DiagnoseCFAudited = false, bool ConvertRHS = true);
9472 
9473  // \brief If the lhs type is a transparent union, check whether we
9474  // can initialize the transparent union with the given expression.
9475  AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,
9476  ExprResult &RHS);
9477 
9478  bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
9479 
9480  bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
9481 
9482  ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9483  AssignmentAction Action,
9484  bool AllowExplicit = false);
9485  ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9486  AssignmentAction Action,
9487  bool AllowExplicit,
9489  ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9490  const ImplicitConversionSequence& ICS,
9491  AssignmentAction Action,
9493  = CCK_ImplicitConversion);
9494  ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
9495  const StandardConversionSequence& SCS,
9496  AssignmentAction Action,
9497  CheckedConversionKind CCK);
9498 
9499  /// the following "Check" methods will return a valid/converted QualType
9500  /// or a null QualType (indicating an error diagnostic was issued).
9501 
9502  /// type checking binary operators (subroutines of CreateBuiltinBinOp).
9503  QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
9504  ExprResult &RHS);
9505  QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
9506  ExprResult &RHS);
9507  QualType CheckPointerToMemberOperands( // C++ 5.5
9508  ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
9509  SourceLocation OpLoc, bool isIndirect);
9510  QualType CheckMultiplyDivideOperands( // C99 6.5.5
9511  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
9512  bool IsDivide);
9513  QualType CheckRemainderOperands( // C99 6.5.5
9514  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9515  bool IsCompAssign = false);
9516  QualType CheckAdditionOperands( // C99 6.5.6
9517  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9518  BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);
9519  QualType CheckSubtractionOperands( // C99 6.5.6
9520  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9521  QualType* CompLHSTy = nullptr);
9522  QualType CheckShiftOperands( // C99 6.5.7
9523  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9524  BinaryOperatorKind Opc, bool IsCompAssign = false);
9525  QualType CheckCompareOperands( // C99 6.5.8/9
9526  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9527  BinaryOperatorKind Opc, bool isRelational);
9528  QualType CheckBitwiseOperands( // C99 6.5.[10...12]
9529  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9530  BinaryOperatorKind Opc);
9531  QualType CheckLogicalOperands( // C99 6.5.[13,14]
9532  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9533  BinaryOperatorKind Opc);
9534  // CheckAssignmentOperands is used for both simple and compound assignment.
9535  // For simple assignment, pass both expressions and a null converted type.
9536  // For compound assignment, pass both expressions and the converted type.
9537  QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
9538  Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
9539 
9540  ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,
9541  UnaryOperatorKind Opcode, Expr *Op);
9542  ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,
9543  BinaryOperatorKind Opcode,
9544  Expr *LHS, Expr *RHS);
9545  ExprResult checkPseudoObjectRValue(Expr *E);
9546  Expr *recreateSyntacticForm(PseudoObjectExpr *E);
9547 
9548  QualType CheckConditionalOperands( // C99 6.5.15
9549  ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
9550  ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);
9551  QualType CXXCheckConditionalOperands( // C++ 5.16
9552  ExprResult &cond, ExprResult &lhs, ExprResult &rhs,
9553  ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);
9554  QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
9555  bool ConvertArgs = true);
9557  ExprResult &E1, ExprResult &E2,
9558  bool ConvertArgs = true) {
9559  Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();
9560  QualType Composite =
9561  FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);
9562  E1 = E1Tmp;
9563  E2 = E2Tmp;
9564  return Composite;
9565  }
9566 
9567  QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
9568  SourceLocation QuestionLoc);
9569 
9570  bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
9571  SourceLocation QuestionLoc);
9572 
9573  void DiagnoseAlwaysNonNullPointer(Expr *E,
9575  bool IsEqual, SourceRange Range);
9576 
9577  /// type checking for vector binary operators.
9578  QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
9579  SourceLocation Loc, bool IsCompAssign,
9580  bool AllowBothBool, bool AllowBoolConversion);
9581  QualType GetSignedVectorType(QualType V);
9582  QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
9583  SourceLocation Loc, bool isRelational);
9584  QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
9585  SourceLocation Loc);
9586 
9587  bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
9588  bool isLaxVectorConversion(QualType srcType, QualType destType);
9589 
9590  /// type checking declaration initializers (C99 6.7.8)
9591  bool CheckForConstantInitializer(Expr *e, QualType t);
9592 
9593  // type checking C++ declaration initializers (C++ [dcl.init]).
9594 
9595  /// ReferenceCompareResult - Expresses the result of comparing two
9596  /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
9597  /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
9599  /// Ref_Incompatible - The two types are incompatible, so direct
9600  /// reference binding is not possible.
9601  Ref_Incompatible = 0,
9602  /// Ref_Related - The two types are reference-related, which means
9603  /// that their unqualified forms (T1 and T2) are either the same
9604  /// or T1 is a base class of T2.
9606  /// Ref_Compatible - The two types are reference-compatible.
9607  Ref_Compatible
9608  };
9609 
9610  ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc,
9611  QualType T1, QualType T2,
9612  bool &DerivedToBase,
9613  bool &ObjCConversion,
9614  bool &ObjCLifetimeConversion);
9615 
9616  ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
9617  Expr *CastExpr, CastKind &CastKind,
9618  ExprValueKind &VK, CXXCastPath &Path);
9619 
9620  /// \brief Force an expression with unknown-type to an expression of the
9621  /// given type.
9622  ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
9623 
9624  /// \brief Type-check an expression that's being passed to an
9625  /// __unknown_anytype parameter.
9626  ExprResult checkUnknownAnyArg(SourceLocation callLoc,
9627  Expr *result, QualType &paramType);
9628 
9629  // CheckVectorCast - check type constraints for vectors.
9630  // Since vectors are an extension, there are no C standard reference for this.
9631  // We allow casting between vectors and integer datatypes of the same size.
9632  // returns true if the cast is invalid
9633  bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
9634  CastKind &Kind);
9635 
9636  /// \brief Prepare `SplattedExpr` for a vector splat operation, adding
9637  /// implicit casts if necessary.
9638  ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
9639 
9640  // CheckExtVectorCast - check type constraints for extended vectors.
9641  // Since vectors are an extension, there are no C standard reference for this.
9642  // We allow casting between vectors and integer datatypes of the same size,
9643  // or vectors and the element type of that vector.
9644  // returns the cast expr
9645  ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
9646  CastKind &Kind);
9647 
9648  ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,
9649  SourceLocation LParenLoc,
9650  Expr *CastExpr,
9651  SourceLocation RParenLoc);
9652 
9653  enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };
9654 
9655  /// \brief Checks for invalid conversions and casts between
9656  /// retainable pointers and other pointer kinds for ARC and Weak.
9657  ARCConversionResult CheckObjCConversion(SourceRange castRange,
9658  QualType castType, Expr *&op,
9660  bool Diagnose = true,
9661  bool DiagnoseCFAudited = false,
9662  BinaryOperatorKind Opc = BO_PtrMemD
9663  );
9664 
9665  Expr *stripARCUnbridgedCast(Expr *e);
9666  void diagnoseARCUnbridgedCast(Expr *e);
9667 
9668  bool CheckObjCARCUnavailableWeakConversion(QualType castType,
9669  QualType ExprType);
9670 
9671  /// checkRetainCycles - Check whether an Objective-C message send
9672  /// might create an obvious retain cycle.
9673  void checkRetainCycles(ObjCMessageExpr *msg);
9674  void checkRetainCycles(Expr *receiver, Expr *argument);
9675  void checkRetainCycles(VarDecl *Var, Expr *Init);
9676 
9677  /// checkUnsafeAssigns - Check whether +1 expr is being assigned
9678  /// to weak/__unsafe_unretained type.
9679  bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
9680 
9681  /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned
9682  /// to weak/__unsafe_unretained expression.
9683  void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
9684 
9685  /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
9686  /// \param Method - May be null.
9687  /// \param [out] ReturnType - The return type of the send.
9688  /// \return true iff there were any incompatible types.
9689  bool CheckMessageArgumentTypes(QualType ReceiverType,
9690  MultiExprArg Args, Selector Sel,
9691  ArrayRef<SourceLocation> SelectorLocs,
9692  ObjCMethodDecl *Method, bool isClassMessage,
9693  bool isSuperMessage,
9694  SourceLocation lbrac, SourceLocation rbrac,
9695  SourceRange RecRange,
9696  QualType &ReturnType, ExprValueKind &VK);
9697 
9698  /// \brief Determine the result of a message send expression based on
9699  /// the type of the receiver, the method expected to receive the message,
9700  /// and the form of the message send.
9701  QualType getMessageSendResultType(QualType ReceiverType,
9702  ObjCMethodDecl *Method,
9703  bool isClassMessage, bool isSuperMessage);
9704 
9705  /// \brief If the given expression involves a message send to a method
9706  /// with a related result type, emit a note describing what happened.
9707  void EmitRelatedResultTypeNote(const Expr *E);
9708 
9709  /// \brief Given that we had incompatible pointer types in a return
9710  /// statement, check whether we're in a method with a related result
9711  /// type, and if so, emit a note describing what happened.
9712  void EmitRelatedResultTypeNoteForReturn(QualType destType);
9713 
9715  Decl *ConditionVar;
9716  FullExprArg Condition;
9717  bool Invalid;
9718  bool HasKnownValue;
9719  bool KnownValue;
9720 
9721  friend class Sema;
9722  ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,
9723  bool IsConstexpr)
9724  : ConditionVar(ConditionVar), Condition(Condition), Invalid(false),
9725  HasKnownValue(IsConstexpr && Condition.get() &&
9726  !Condition.get()->isValueDependent()),
9727  KnownValue(HasKnownValue &&
9728  !!Condition.get()->EvaluateKnownConstInt(S.Context)) {}
9729  explicit ConditionResult(bool Invalid)
9730  : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid),
9731  HasKnownValue(false), KnownValue(false) {}
9732 
9733  public:
9735  bool isInvalid() const { return Invalid; }
9736  std::pair<VarDecl *, Expr *> get() const {
9737  return std::make_pair(cast_or_null<VarDecl>(ConditionVar),
9738  Condition.get());
9739  }
9741  if (!HasKnownValue)
9742  return None;
9743  return KnownValue;
9744  }
9745  };
9747 
9748  enum class ConditionKind {
9749  Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.
9750  ConstexprIf, ///< A constant boolean condition from 'if constexpr'.
9751  Switch ///< An integral condition for a 'switch' statement.
9752  };
9753 
9754  ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,
9755  Expr *SubExpr, ConditionKind CK);
9756 
9757  ConditionResult ActOnConditionVariable(Decl *ConditionVar,
9758  SourceLocation StmtLoc,
9759  ConditionKind CK);
9760 
9761  DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);
9762 
9763  ExprResult CheckConditionVariable(VarDecl *ConditionVar,
9764  SourceLocation StmtLoc,
9765  ConditionKind CK);
9766  ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
9767 
9768  /// CheckBooleanCondition - Diagnose problems involving the use of
9769  /// the given expression as a boolean condition (e.g. in an if
9770  /// statement). Also performs the standard function and array
9771  /// decays, possibly changing the input variable.
9772  ///
9773  /// \param Loc - A location associated with the condition, e.g. the
9774  /// 'if' keyword.
9775  /// \return true iff there were any errors
9776  ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
9777  bool IsConstexpr = false);
9778 
9779  /// DiagnoseAssignmentAsCondition - Given that an expression is
9780  /// being used as a boolean condition, warn if it's an assignment.
9781  void DiagnoseAssignmentAsCondition(Expr *E);
9782 
9783  /// \brief Redundant parentheses over an equality comparison can indicate
9784  /// that the user intended an assignment used as condition.
9785  void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
9786 
9787  /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
9788  ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
9789 
9790  /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
9791  /// the specified width and sign. If an overflow occurs, detect it and emit
9792  /// the specified diagnostic.
9793  void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
9794  unsigned NewWidth, bool NewSign,
9795  SourceLocation Loc, unsigned DiagID);
9796 
9797  /// Checks that the Objective-C declaration is declared in the global scope.
9798  /// Emits an error and marks the declaration as invalid if it's not declared
9799  /// in the global scope.
9800  bool CheckObjCDeclScope(Decl *D);
9801 
9802  /// \brief Abstract base class used for diagnosing integer constant
9803  /// expression violations.
9805  public:
9806  bool Suppress;
9807 
9808  VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
9809 
9810  virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) =0;
9811  virtual void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR);
9812  virtual ~VerifyICEDiagnoser() { }
9813  };
9814 
9815  /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
9816  /// and reports the appropriate diagnostics. Returns false on success.
9817  /// Can optionally return the value of the expression.
9818  ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
9819  VerifyICEDiagnoser &Diagnoser,
9820  bool AllowFold = true);
9821  ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
9822  unsigned DiagID,
9823  bool AllowFold = true);
9824  ExprResult VerifyIntegerConstantExpression(Expr *E,
9825  llvm::APSInt *Result = nullptr);
9826 
9827  /// VerifyBitField - verifies that a bit field expression is an ICE and has
9828  /// the correct width, and that the field type is valid.
9829  /// Returns false on success.
9830  /// Can optionally return whether the bit-field is of width 0
9831  ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
9832  QualType FieldTy, bool IsMsStruct,
9833  Expr *BitWidth, bool *ZeroWidth = nullptr);
9834 
9835 private:
9836  unsigned ForceCUDAHostDeviceDepth = 0;
9837 
9838 public:
9839  /// Increments our count of the number of times we've seen a pragma forcing
9840  /// functions to be __host__ __device__. So long as this count is greater
9841  /// than zero, all functions encountered will be __host__ __device__.
9842  void PushForceCUDAHostDevice();
9843 
9844  /// Decrements our count of the number of times we've seen a pragma forcing
9845  /// functions to be __host__ __device__. Returns false if the count is 0
9846  /// before incrementing, so you can emit an error.
9847  bool PopForceCUDAHostDevice();
9848 
9849  /// Diagnostics that are emitted only if we discover that the given function
9850  /// must be codegen'ed. Because handling these correctly adds overhead to
9851  /// compilation, this is currently only enabled for CUDA compilations.
9852  llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
9853  std::vector<PartialDiagnosticAt>>
9855 
9856  /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the
9857  /// key in a hashtable, both the FD and location are hashed.
9861  };
9862 
9863  /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a
9864  /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the
9865  /// same deferred diag twice.
9867 
9868  /// An inverse call graph, mapping known-emitted functions to one of their
9869  /// known-emitted callers (plus the location of the call).
9870  ///
9871  /// Functions that we can tell a priori must be emitted aren't added to this
9872  /// map.
9873  llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,
9874  /* Caller = */ FunctionDeclAndLoc>
9876 
9877  /// A partial call graph maintained during CUDA compilation to support
9878  /// deferred diagnostics.
9879  ///
9880  /// Functions are only added here if, at the time they're considered, they are
9881  /// not known-emitted. As soon as we discover that a function is
9882  /// known-emitted, we remove it and everything it transitively calls from this
9883  /// set and add those functions to CUDAKnownEmittedFns.
9884  llvm::DenseMap</* Caller = */ CanonicalDeclPtr<FunctionDecl>,
9885  /* Callees = */ llvm::MapVector<CanonicalDeclPtr<FunctionDecl>,
9886  SourceLocation>>
9888 
9889  /// Diagnostic builder for CUDA errors which may or may not be deferred.
9890  ///
9891  /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
9892  /// which are not allowed to appear inside __device__ functions and are
9893  /// allowed to appear in __host__ __device__ functions only if the host+device
9894  /// function is never codegen'ed.
9895  ///
9896  /// To handle this, we use the notion of "deferred diagnostics", where we
9897  /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
9898  ///
9899  /// This class lets you emit either a regular diagnostic, a deferred
9900  /// diagnostic, or no diagnostic at all, according to an argument you pass to
9901  /// its constructor, thus simplifying the process of creating these "maybe
9902  /// deferred" diagnostics.
9904  public:
9905  enum Kind {
9906  /// Emit no diagnostics.
9908  /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
9910  /// Emit the diagnostic immediately, and, if it's a warning or error, also
9911  /// emit a call stack showing how this function can be reached by an a
9912  /// priori known-emitted function.
9914  /// Create a deferred diagnostic, which is emitted only if the function
9915  /// it's attached to is codegen'ed. Also emit a call stack as with
9916  /// K_ImmediateWithCallStack.
9917  K_Deferred
9918  };
9919 
9920  CUDADiagBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
9921  FunctionDecl *Fn, Sema &S);
9922  ~CUDADiagBuilder();
9923 
9924  /// Convertible to bool: True if we immediately emitted an error, false if
9925  /// we didn't emit an error or we created a deferred error.
9926  ///
9927  /// Example usage:
9928  ///
9929  /// if (CUDADiagBuilder(...) << foo << bar)
9930  /// return ExprError();
9931  ///
9932  /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
9933  /// want to use these instead of creating a CUDADiagBuilder yourself.
9934  operator bool() const { return ImmediateDiag.hasValue(); }
9935 
9936  template <typename T>
9937  friend const CUDADiagBuilder &operator<<(const CUDADiagBuilder &Diag,
9938  const T &Value) {
9939  if (Diag.ImmediateDiag.hasValue())
9940  *Diag.ImmediateDiag << Value;
9941  else if (Diag.PartialDiag.hasValue())
9942  *Diag.PartialDiag << Value;
9943  return Diag;
9944  }
9945 
9946  private:
9947  Sema &S;
9948  SourceLocation Loc;
9949  unsigned DiagID;
9950  FunctionDecl *Fn;
9951  bool ShowCallStack;
9952 
9953  // Invariant: At most one of these Optionals has a value.
9954  // FIXME: Switch these to a Variant once that exists.
9957  };
9958 
9959  /// Creates a CUDADiagBuilder that emits the diagnostic if the current context
9960  /// is "used as device code".
9961  ///
9962  /// - If CurContext is a __host__ function, does not emit any diagnostics.
9963  /// - If CurContext is a __device__ or __global__ function, emits the
9964  /// diagnostics immediately.
9965  /// - If CurContext is a __host__ __device__ function and we are compiling for
9966  /// the device, creates a diagnostic which is emitted if and when we realize
9967  /// that the function will be codegen'ed.
9968  ///
9969  /// Example usage:
9970  ///
9971  /// // Variable-length arrays are not allowed in CUDA device code.
9972  /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())
9973  /// return ExprError();
9974  /// // Otherwise, continue parsing as normal.
9975  CUDADiagBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID);
9976 
9977  /// Creates a CUDADiagBuilder that emits the diagnostic if the current context
9978  /// is "used as host code".
9979  ///
9980  /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched.
9981  CUDADiagBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);
9982 
9988  CFT_InvalidTarget
9989  };
9990 
9991  /// Determines whether the given function is a CUDA device/host/kernel/etc.
9992  /// function.
9993  ///
9994  /// Use this rather than examining the function's attributes yourself -- you
9995  /// will get it wrong. Returns CFT_Host if D is null.
9996  CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,
9997  bool IgnoreImplicitHDAttr = false);
9998  CUDAFunctionTarget IdentifyCUDATarget(const AttributeList *Attr);
9999 
10000  /// Gets the CUDA target for the current context.
10002  return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
10003  }
10004 
10005  // CUDA function call preference. Must be ordered numerically from
10006  // worst to best.
10008  CFP_Never, // Invalid caller/callee combination.
10009  CFP_WrongSide, // Calls from host-device to host or device
10010  // function that do not match current compilation
10011  // mode.
10012  CFP_HostDevice, // Any calls to host/device functions.
10013  CFP_SameSide, // Calls from host-device to host or device
10014  // function matching current compilation mode.
10015  CFP_Native, // host-to-host or device-to-device calls.
10016  };
10017 
10018  /// Identifies relative preference of a given Caller/Callee
10019  /// combination, based on their host/device attributes.
10020  /// \param Caller function which needs address of \p Callee.
10021  /// nullptr in case of global context.
10022  /// \param Callee target function
10023  ///
10024  /// \returns preference value for particular Caller/Callee combination.
10025  CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,
10026  const FunctionDecl *Callee);
10027 
10028  /// Determines whether Caller may invoke Callee, based on their CUDA
10029  /// host/device attributes. Returns false if the call is not allowed.
10030  ///
10031  /// Note: Will return true for CFP_WrongSide calls. These may appear in
10032  /// semantically correct CUDA programs, but only if they're never codegen'ed.
10033  bool IsAllowedCUDACall(const FunctionDecl *Caller,
10034  const FunctionDecl *Callee) {
10035  return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;
10036  }
10037 
10038  /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,
10039  /// depending on FD and the current compilation settings.
10040  void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,
10041  const LookupResult &Previous);
10042 
10043 public:
10044  /// Check whether we're allowed to call Callee from the current context.
10045  ///
10046  /// - If the call is never allowed in a semantically-correct program
10047  /// (CFP_Never), emits an error and returns false.
10048  ///
10049  /// - If the call is allowed in semantically-correct programs, but only if
10050  /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to
10051  /// be emitted if and when the caller is codegen'ed, and returns true.
10052  ///
10053  /// Will only create deferred diagnostics for a given SourceLocation once,
10054  /// so you can safely call this multiple times without generating duplicate
10055  /// deferred errors.
10056  ///
10057  /// - Otherwise, returns true without emitting any diagnostics.
10058  bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);
10059 
10060  /// Set __device__ or __host__ __device__ attributes on the given lambda
10061  /// operator() method.
10062  ///
10063  /// CUDA lambdas declared inside __device__ or __global__ functions inherit
10064  /// the __device__ attribute. Similarly, lambdas inside __host__ __device__
10065  /// functions become __host__ __device__ themselves.
10066  void CUDASetLambdaAttrs(CXXMethodDecl *Method);
10067 
10068  /// Finds a function in \p Matches with highest calling priority
10069  /// from \p Caller context and erases all functions with lower
10070  /// calling priority.
10071  void EraseUnwantedCUDAMatches(
10072  const FunctionDecl *Caller,
10073  SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
10074 
10075  /// Given a implicit special member, infer its CUDA target from the
10076  /// calls it needs to make to underlying base/field special members.
10077  /// \param ClassDecl the class for which the member is being created.
10078  /// \param CSM the kind of special member.
10079  /// \param MemberDecl the special member itself.
10080  /// \param ConstRHS true if this is a copy operation with a const object on
10081  /// its RHS.
10082  /// \param Diagnose true if this call should emit diagnostics.
10083  /// \return true if there was an error inferring.
10084  /// The result of this call is implicit CUDA target attribute(s) attached to
10085  /// the member declaration.
10086  bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
10087  CXXSpecialMember CSM,
10088  CXXMethodDecl *MemberDecl,
10089  bool ConstRHS,
10090  bool Diagnose);
10091 
10092  /// \return true if \p CD can be considered empty according to CUDA
10093  /// (E.2.3.1 in CUDA 7.5 Programming guide).
10094  bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);
10095  bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);
10096 
10097  /// Check whether NewFD is a valid overload for CUDA. Emits
10098  /// diagnostics and invalidates NewFD if not.
10099  void checkCUDATargetOverload(FunctionDecl *NewFD,
10100  const LookupResult &Previous);
10101  /// Copies target attributes from the template TD to the function FD.
10102  void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD);
10103 
10104  /// \name Code completion
10105  //@{
10106  /// \brief Describes the context in which code completion occurs.
10108  /// \brief Code completion occurs at top-level or namespace context.
10110  /// \brief Code completion occurs within a class, struct, or union.
10112  /// \brief Code completion occurs within an Objective-C interface, protocol,
10113  /// or category.
10115  /// \brief Code completion occurs within an Objective-C implementation or
10116  /// category implementation
10118  /// \brief Code completion occurs within the list of instance variables
10119  /// in an Objective-C interface, protocol, category, or implementation.
10121  /// \brief Code completion occurs following one or more template
10122  /// headers.
10124  /// \brief Code completion occurs following one or more template
10125  /// headers within a class.
10127  /// \brief Code completion occurs within an expression.
10129  /// \brief Code completion occurs within a statement, which may
10130  /// also be an expression or a declaration.
10132  /// \brief Code completion occurs at the beginning of the
10133  /// initialization statement (or expression) in a for loop.
10135  /// \brief Code completion occurs within the condition of an if,
10136  /// while, switch, or for statement.
10138  /// \brief Code completion occurs within the body of a function on a
10139  /// recovery path, where we do not have a specific handle on our position
10140  /// in the grammar.
10142  /// \brief Code completion occurs where only a type is permitted.
10144  /// \brief Code completion occurs in a parenthesized expression, which
10145  /// might also be a type cast.
10147  /// \brief Code completion occurs within a sequence of declaration
10148  /// specifiers within a function, method, or block.
10149  PCC_LocalDeclarationSpecifiers
10150  };
10151 
10152  void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);
10153  void CodeCompleteOrdinaryName(Scope *S,
10154  ParserCompletionContext CompletionContext);
10155  void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
10156  bool AllowNonIdentifiers,
10157  bool AllowNestedNameSpecifiers);
10158 
10160  void CodeCompleteExpression(Scope *S,
10161  const CodeCompleteExpressionData &Data);
10162  void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
10163  SourceLocation OpLoc, bool IsArrow,
10164  bool IsBaseExprStatement);
10165  void CodeCompletePostfixExpression(Scope *S, ExprResult LHS);
10166  void CodeCompleteTag(Scope *S, unsigned TagSpec);
10167  void CodeCompleteTypeQualifiers(DeclSpec &DS);
10168  void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
10169  const VirtSpecifiers *VS = nullptr);
10170  void CodeCompleteBracketDeclarator(Scope *S);
10171  void CodeCompleteCase(Scope *S);
10172  void CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args);
10173  void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
10174  ArrayRef<Expr *> Args);
10175  void CodeCompleteInitializer(Scope *S, Decl *D);
10176  void CodeCompleteReturn(Scope *S);
10177  void CodeCompleteAfterIf(Scope *S);
10178  void CodeCompleteAssignmentRHS(Scope *S, Expr *LHS);
10179 
10180  void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
10181  bool EnteringContext);
10182  void CodeCompleteUsing(Scope *S);
10183  void CodeCompleteUsingDirective(Scope *S);
10184  void CodeCompleteNamespaceDecl(Scope *S);
10185  void CodeCompleteNamespaceAliasDecl(Scope *S);
10186  void CodeCompleteOperatorName(Scope *S);
10187  void CodeCompleteConstructorInitializer(
10188  Decl *Constructor,
10189  ArrayRef<CXXCtorInitializer *> Initializers);
10190 
10191  void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
10192  bool AfterAmpersand);
10193 
10194  void CodeCompleteObjCAtDirective(Scope *S);
10195  void CodeCompleteObjCAtVisibility(Scope *S);
10196  void CodeCompleteObjCAtStatement(Scope *S);
10197  void CodeCompleteObjCAtExpression(Scope *S);
10198  void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
10199  void CodeCompleteObjCPropertyGetter(Scope *S);
10200  void CodeCompleteObjCPropertySetter(Scope *S);
10201  void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
10202  bool IsParameter);
10203  void CodeCompleteObjCMessageReceiver(Scope *S);
10204  void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
10205  ArrayRef<IdentifierInfo *> SelIdents,
10206  bool AtArgumentExpression);
10207  void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
10208  ArrayRef<IdentifierInfo *> SelIdents,
10209  bool AtArgumentExpression,
10210  bool IsSuper = false);
10211  void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
10212  ArrayRef<IdentifierInfo *> SelIdents,
10213  bool AtArgumentExpression,
10214  ObjCInterfaceDecl *Super = nullptr);
10215  void CodeCompleteObjCForCollection(Scope *S,
10216  DeclGroupPtrTy IterationVar);
10217  void CodeCompleteObjCSelector(Scope *S,
10218  ArrayRef<IdentifierInfo *> SelIdents);
10219  void CodeCompleteObjCProtocolReferences(
10220  ArrayRef<IdentifierLocPair> Protocols);
10221  void CodeCompleteObjCProtocolDecl(Scope *S);
10222  void CodeCompleteObjCInterfaceDecl(Scope *S);
10223  void CodeCompleteObjCSuperclass(Scope *S,
10224  IdentifierInfo *ClassName,
10225  SourceLocation ClassNameLoc);
10226  void CodeCompleteObjCImplementationDecl(Scope *S);
10227  void CodeCompleteObjCInterfaceCategory(Scope *S,
10228  IdentifierInfo *ClassName,
10229  SourceLocation ClassNameLoc);
10230  void CodeCompleteObjCImplementationCategory(Scope *S,
10231  IdentifierInfo *ClassName,
10232  SourceLocation ClassNameLoc);
10233  void CodeCompleteObjCPropertyDefinition(Scope *S);
10234  void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
10235  IdentifierInfo *PropertyName);
10236  void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
10237  ParsedType ReturnType);
10238  void CodeCompleteObjCMethodDeclSelector(Scope *S,
10239  bool IsInstanceMethod,
10240  bool AtParameterName,
10241  ParsedType ReturnType,
10242  ArrayRef<IdentifierInfo *> SelIdents);
10243  void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,
10244  SourceLocation ClassNameLoc,
10245  bool IsBaseExprStatement);
10246  void CodeCompletePreprocessorDirective(bool InConditional);
10247  void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
10248  void CodeCompletePreprocessorMacroName(bool IsDefinition);
10249  void CodeCompletePreprocessorExpression();
10250  void CodeCompletePreprocessorMacroArgument(Scope *S,
10251  IdentifierInfo *Macro,
10253  unsigned Argument);
10254  void CodeCompleteNaturalLanguage();
10255  void CodeCompleteAvailabilityPlatformName();
10256  void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
10257  CodeCompletionTUInfo &CCTUInfo,
10259  //@}
10260 
10261  //===--------------------------------------------------------------------===//
10262  // Extra semantic analysis beyond the C type system
10263 
10264 public:
10265  SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
10266  unsigned ByteNo) const;
10267 
10268 private:
10269  void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
10270  const ArraySubscriptExpr *ASE=nullptr,
10271  bool AllowOnePastEnd=true, bool IndexNegated=false);
10272  void CheckArrayAccess(const Expr *E);
10273  // Used to grab the relevant information from a FormatAttr and a
10274  // FunctionDeclaration.
10275  struct FormatStringInfo {
10276  unsigned FormatIdx;
10277  unsigned FirstDataArg;
10278  bool HasVAListArg;
10279  };
10280 
10281  static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
10282  FormatStringInfo *FSI);
10283  bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
10284  const FunctionProtoType *Proto);
10285  bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
10286  ArrayRef<const Expr *> Args);
10287  bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
10288  const FunctionProtoType *Proto);
10289  bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
10290  void CheckConstructorCall(FunctionDecl *FDecl,
10292  const FunctionProtoType *Proto,
10293  SourceLocation Loc);
10294 
10295  void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
10296  const Expr *ThisArg, ArrayRef<const Expr *> Args,
10297  bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
10298  VariadicCallType CallType);
10299 
10300  bool CheckObjCString(Expr *Arg);
10301  ExprResult CheckOSLogFormatStringArg(Expr *Arg);
10302 
10303  ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,
10304  unsigned BuiltinID, CallExpr *TheCall);
10305 
10306  bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
10307  unsigned MaxWidth);
10308  bool CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10309  bool CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10310 
10311  bool CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10312  bool CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10313  bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10314  bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
10315  bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
10316  bool CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10317  bool CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
10318 
10319  bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
10320  bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
10321  bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
10322  bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
10323  bool SemaBuiltinVSX(CallExpr *TheCall);
10324  bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
10325 
10326 public:
10327  // Used by C++ template instantiation.
10328  ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
10329  ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
10330  SourceLocation BuiltinLoc,
10331  SourceLocation RParenLoc);
10332 
10333 private:
10334  bool SemaBuiltinPrefetch(CallExpr *TheCall);
10335  bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
10336  bool SemaBuiltinAssume(CallExpr *TheCall);
10337  bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
10338  bool SemaBuiltinLongjmp(CallExpr *TheCall);
10339  bool SemaBuiltinSetjmp(CallExpr *TheCall);
10340  ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
10341  ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
10342  ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
10344  bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
10345  llvm::APSInt &Result);
10346  bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
10347  int Low, int High);
10348  bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
10349  unsigned Multiple);
10350  bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
10351  int ArgNum, unsigned ExpectedFieldNum,
10352  bool AllowName);
10353 public:
10364  FST_Unknown
10365  };
10366  static FormatStringType GetFormatStringType(const FormatAttr *Format);
10367 
10368  bool FormatStringHasSArg(const StringLiteral *FExpr);
10369 
10370  static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx);
10371 
10372 private:
10373  bool CheckFormatArguments(const FormatAttr *Format,
10375  bool IsCXXMember,
10376  VariadicCallType CallType,
10377  SourceLocation Loc, SourceRange Range,
10378  llvm::SmallBitVector &CheckedVarArgs);
10379  bool CheckFormatArguments(ArrayRef<const Expr *> Args,
10380  bool HasVAListArg, unsigned format_idx,
10381  unsigned firstDataArg, FormatStringType Type,
10382  VariadicCallType CallType,
10383  SourceLocation Loc, SourceRange range,
10384  llvm::SmallBitVector &CheckedVarArgs);
10385 
10386  void CheckAbsoluteValueFunction(const CallExpr *Call,
10387  const FunctionDecl *FDecl);
10388 
10389  void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);
10390 
10391  void CheckMemaccessArguments(const CallExpr *Call,
10392  unsigned BId,
10393  IdentifierInfo *FnName);
10394 
10395  void CheckStrlcpycatArguments(const CallExpr *Call,
10396  IdentifierInfo *FnName);
10397 
10398  void CheckStrncatArguments(const CallExpr *Call,
10399  IdentifierInfo *FnName);
10400 
10401  void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
10402  SourceLocation ReturnLoc,
10403  bool isObjCMethod = false,
10404  const AttrVec *Attrs = nullptr,
10405  const FunctionDecl *FD = nullptr);
10406 
10407  void CheckFloatComparison(SourceLocation Loc, Expr* LHS, Expr* RHS);
10408  void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
10409  void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
10410  void CheckForIntOverflow(Expr *E);
10411  void CheckUnsequencedOperations(Expr *E);
10412 
10413  /// \brief Perform semantic checks on a completed expression. This will either
10414  /// be a full-expression or a default argument expression.
10415  void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
10416  bool IsConstexpr = false);
10417 
10418  void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,
10419  Expr *Init);
10420 
10421  /// Check if there is a field shadowing.
10422  void CheckShadowInheritedFields(const SourceLocation &Loc,
10423  DeclarationName FieldName,
10424  const CXXRecordDecl *RD);
10425 
10426  /// \brief Check if the given expression contains 'break' or 'continue'
10427  /// statement that produces control flow different from GCC.
10428  void CheckBreakContinueBinding(Expr *E);
10429 
10430  /// \brief Check whether receiver is mutable ObjC container which
10431  /// attempts to add itself into the container
10432  void CheckObjCCircularContainer(ObjCMessageExpr *Message);
10433 
10434  void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
10435  void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
10436  bool DeleteWasArrayForm);
10437 public:
10438  /// \brief Register a magic integral constant to be used as a type tag.
10439  void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
10440  uint64_t MagicValue, QualType Type,
10441  bool LayoutCompatible, bool MustBeNull);
10442 
10443  struct TypeTagData {
10445 
10446  TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :
10447  Type(Type), LayoutCompatible(LayoutCompatible),
10448  MustBeNull(MustBeNull)
10449  {}
10450 
10452 
10453  /// If true, \c Type should be compared with other expression's types for
10454  /// layout-compatibility.
10455  unsigned LayoutCompatible : 1;
10456  unsigned MustBeNull : 1;
10457  };
10458 
10459  /// A pair of ArgumentKind identifier and magic value. This uniquely
10460  /// identifies the magic value.
10461  typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;
10462 
10463 private:
10464  /// \brief A map from magic value to type information.
10465  std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>
10466  TypeTagForDatatypeMagicValues;
10467 
10468  /// \brief Peform checks on a call of a function with argument_with_type_tag
10469  /// or pointer_with_type_tag attributes.
10470  void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,
10471  const ArrayRef<const Expr *> ExprArgs,
10472  SourceLocation CallSiteLoc);
10473 
10474  /// \brief Check if we are taking the address of a packed field
10475  /// as this may be a problem if the pointer value is dereferenced.
10476  void CheckAddressOfPackedMember(Expr *rhs);
10477 
10478  /// \brief The parser's current scope.
10479  ///
10480  /// The parser maintains this state here.
10481  Scope *CurScope;
10482 
10483  mutable IdentifierInfo *Ident_super;
10484  mutable IdentifierInfo *Ident___float128;
10485 
10486  /// Nullability type specifiers.
10487  IdentifierInfo *Ident__Nonnull = nullptr;
10488  IdentifierInfo *Ident__Nullable = nullptr;
10489  IdentifierInfo *Ident__Null_unspecified = nullptr;
10490 
10491  IdentifierInfo *Ident_NSError = nullptr;
10492 
10493  /// \brief The handler for the FileChanged preprocessor events.
10494  ///
10495  /// Used for diagnostics that implement custom semantic analysis for #include
10496  /// directives, like -Wpragma-pack.
10497  sema::SemaPPCallbacks *SemaPPCallbackHandler;
10498 
10499 protected:
10500  friend class Parser;
10502  friend class ASTReader;
10503  friend class ASTDeclReader;
10504  friend class ASTWriter;
10505 
10506 public:
10507  /// Retrieve the keyword associated
10508  IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);
10509 
10510  /// The struct behind the CFErrorRef pointer.
10511  RecordDecl *CFError = nullptr;
10512 
10513  /// Retrieve the identifier "NSError".
10514  IdentifierInfo *getNSErrorIdent();
10515 
10516  /// \brief Retrieve the parser's current scope.
10517  ///
10518  /// This routine must only be used when it is certain that semantic analysis
10519  /// and the parser are in precisely the same context, which is not the case
10520  /// when, e.g., we are performing any kind of template instantiation.
10521  /// Therefore, the only safe places to use this scope are in the parser
10522  /// itself and in routines directly invoked from the parser and *never* from
10523  /// template substitution or instantiation.
10524  Scope *getCurScope() const { return CurScope; }
10525 
10527  return CurScope->incrementMSManglingNumber();
10528  }
10529 
10530  IdentifierInfo *getSuperIdentifier() const;
10531  IdentifierInfo *getFloat128Identifier() const;
10532 
10533  Decl *getObjCDeclContext() const;
10534 
10536  return OriginalLexicalContext ? OriginalLexicalContext : CurContext;
10537  }
10538 
10540  const DeclContext *DC = getCurLexicalContext();
10541  // A category implicitly has the attribute of the interface.
10542  if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))
10543  DC = CatD->getClassInterface();
10544  return DC;
10545  }
10546 
10547  /// \brief To be used for checking whether the arguments being passed to
10548  /// function exceeds the number of parameters expected for it.
10549  static bool TooManyArguments(size_t NumParams, size_t NumArgs,
10550  bool PartialOverloading = false) {
10551  // We check whether we're just after a comma in code-completion.
10552  if (NumArgs > 0 && PartialOverloading)
10553  return NumArgs + 1 > NumParams; // If so, we view as an extra argument.
10554  return NumArgs > NumParams;
10555  }
10556 
10557  // Emitting members of dllexported classes is delayed until the class
10558  // (including field initializers) is fully parsed.
10560 
10561 private:
10562  class SavePendingParsedClassStateRAII {
10563  public:
10564  SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }
10565 
10566  ~SavePendingParsedClassStateRAII() {
10567  assert(S.DelayedExceptionSpecChecks.empty() &&
10568  "there shouldn't be any pending delayed exception spec checks");
10569  assert(S.DelayedDefaultedMemberExceptionSpecs.empty() &&
10570  "there shouldn't be any pending delayed defaulted member "
10571  "exception specs");
10572  assert(S.DelayedDllExportClasses.empty() &&
10573  "there shouldn't be any pending delayed DLL export classes");
10574  swapSavedState();
10575  }
10576 
10577  private:
10578  Sema &S;
10579  decltype(DelayedExceptionSpecChecks) SavedExceptionSpecChecks;
10580  decltype(DelayedDefaultedMemberExceptionSpecs)
10581  SavedDefaultedMemberExceptionSpecs;
10582  decltype(DelayedDllExportClasses) SavedDllExportClasses;
10583 
10584  void swapSavedState() {
10585  SavedExceptionSpecChecks.swap(S.DelayedExceptionSpecChecks);
10586  SavedDefaultedMemberExceptionSpecs.swap(
10588  SavedDllExportClasses.swap(S.DelayedDllExportClasses);
10589  }
10590  };
10591 
10592  /// \brief Helper class that collects misaligned member designations and
10593  /// their location info for delayed diagnostics.
10594  struct MisalignedMember {
10595  Expr *E;
10596  RecordDecl *RD;
10597  ValueDecl *MD;
10598  CharUnits Alignment;
10599 
10600  MisalignedMember() : E(), RD(), MD(), Alignment() {}
10601  MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,
10602  CharUnits Alignment)
10603  : E(E), RD(RD), MD(MD), Alignment(Alignment) {}
10604  explicit MisalignedMember(Expr *E)
10605  : MisalignedMember(E, nullptr, nullptr, CharUnits()) {}
10606 
10607  bool operator==(const MisalignedMember &m) { return this->E == m.E; }
10608  };
10609  /// \brief Small set of gathered accesses to potentially misaligned members
10610  /// due to the packed attribute.
10611  SmallVector<MisalignedMember, 4> MisalignedMembers;
10612 
10613  /// \brief Adds an expression to the set of gathered misaligned members.
10614  void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
10615  CharUnits Alignment);
10616 
10617 public:
10618  /// \brief Diagnoses the current set of gathered accesses. This typically
10619  /// happens at full expression level. The set is cleared after emitting the
10620  /// diagnostics.
10621  void DiagnoseMisalignedMembers();
10622 
10623  /// \brief This function checks if the expression is in the sef of potentially
10624  /// misaligned members and it is converted to some pointer type T with lower
10625  /// or equal alignment requirements. If so it removes it. This is used when
10626  /// we do not want to diagnose such misaligned access (e.g. in conversions to
10627  /// void*).
10628  void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
10629 
10630  /// \brief This function calls Action when it determines that E designates a
10631  /// misaligned member due to the packed attribute. This is used to emit
10632  /// local diagnostics like in reference binding.
10633  void RefersToMemberWithReducedAlignment(
10634  Expr *E,
10635  llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
10636  Action);
10637 };
10638 
10639 /// \brief RAII object that enters a new expression evaluation context.
10641  Sema &Actions;
10642  bool Entered = true;
10643 
10644 public:
10645 
10648  Decl *LambdaContextDecl = nullptr,
10649  bool IsDecltype = false,
10650  bool ShouldEnter = true)
10651  : Actions(Actions), Entered(ShouldEnter) {
10652  if (Entered)
10653  Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
10654  IsDecltype);
10655  }
10659  bool IsDecltype = false)
10660  : Actions(Actions) {
10661  Actions.PushExpressionEvaluationContext(NewContext,
10662  Sema::ReuseLambdaContextDecl,
10663  IsDecltype);
10664  }
10665 
10666  enum InitListTag { InitList };
10668  bool ShouldEnter = true)
10669  : Actions(Actions), Entered(false) {
10670  // In C++11 onwards, narrowing checks are performed on the contents of
10671  // braced-init-lists, even when they occur within unevaluated operands.
10672  // Therefore we still need to instantiate constexpr functions used in such
10673  // a context.
10674  if (ShouldEnter && Actions.isUnevaluatedContext() &&
10675  Actions.getLangOpts().CPlusPlus11) {
10677  Sema::ExpressionEvaluationContext::UnevaluatedList, nullptr, false);
10678  Entered = true;
10679  }
10680  }
10681 
10683  if (Entered)
10685  }
10686 };
10687 
10691 
10692 /// \brief Contains a late templated function.
10693 /// Will be parsed at the end of the translation unit, used by Sema & Parser.
10696  /// \brief The template function declaration to be late parsed.
10697  Decl *D;
10698 };
10699 
10700 } // end namespace clang
10701 
10702 namespace llvm {
10703 // Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
10704 // SourceLocation.
10705 template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
10708 
10710  return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()};
10711  }
10712 
10714  return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()};
10715  }
10716 
10717  static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {
10718  return hash_combine(FDBaseInfo::getHashValue(FDL.FD),
10719  FDL.Loc.getRawEncoding());
10720  }
10721 
10722  static bool isEqual(const FunctionDeclAndLoc &LHS,
10723  const FunctionDeclAndLoc &RHS) {
10724  return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;
10725  }
10726 };
10727 } // namespace llvm
10728 
10729 #endif
FileNullabilityMap NullabilityMap
A mapping that describes the nullability we&#39;ve seen in each header file.
Definition: Sema.h:481
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1483
VariadicCallType
Definition: Sema.h:9293
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:851
PragmaStack< StringLiteral * > CodeSegStack
Definition: Sema.h:465
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used...
Definition: Sema.h:596
We are defining a synthesized function (such as a defaulted special member).
Definition: Sema.h:7109
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:3045
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args)
Definition: Sema.h:1635
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:558
A set of visible modules.
Definition: Module.h:571
UnexpandedParameterPackContext
The context in which an unexpanded parameter pack is being diagnosed.
Definition: Sema.h:6487
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl * >, SourceLocation > UnexpandedParameterPack
Definition: Sema.h:223
SourceLocation getOptimizeOffPragmaLocation() const
Get the location for the currently active "\#pragma clang optimize off". If this location is invalid...
Definition: Sema.h:8406
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
ExtVectorDeclsType ExtVectorDecls
ExtVectorDecls - This is a list all the extended vector types.
Definition: Sema.h:546
AttributeList * ArgAttrs
ArgAttrs - Attribute list for this argument.
Definition: Sema.h:8056
NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc, SourceLocation ColonColonLoc, ParsedType ObjectType=ParsedType())
Creates info object for the most typical case.
Definition: Sema.h:5307
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1203
SuppressedDiagnosticsMap SuppressedDiagnostics
Definition: Sema.h:7254
CXXMethodDecl * getMethod() const
Definition: Sema.h:1041
no exception specification
Smart pointer class that efficiently represents Objective-C method names.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:751
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, llvm::MapVector< CanonicalDeclPtr< FunctionDecl >, SourceLocation > > CUDACallGraph
A partial call graph maintained during CUDA compilation to support deferred diagnostics.
Definition: Sema.h:9887
EnterExpressionEvaluationContext(Sema &Actions, Sema::ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false, bool ShouldEnter=true)
Definition: Sema.h:10646
PointerToInt - The assignment converts a pointer to an int, which we accept as an extension...
Definition: Sema.h:9359
Stores the type being destroyed by a pseudo-destructor expression.
Definition: ExprCXX.h:2146
A (possibly-)qualified type.
Definition: Type.h:653
ASTConsumer & Consumer
Definition: Sema.h:317
Keeps information about an identifier in a nested-name-spec.
Definition: Sema.h:5292
GlobalEagerInstantiationScope(Sema &S, bool Enabled)
Definition: Sema.h:7526
Simple class containing the result of Sema::CorrectTypo.
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6837
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:630
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
SmallVectorImpl< Decl * > & WeakTopLevelDecls()
WeakTopLevelDeclDecls - access to #pragma weak-generated Decls.
Definition: Sema.h:1366
Instantiation or recovery rebuild of a for-range statement.
Definition: Sema.h:3758
NameClassification(const IdentifierInfo *Keyword)
Definition: Sema.h:1735
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:62
void SentinelAction(PragmaMsStackAction Action, StringRef Label)
Definition: Sema.h:421
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
Defines enumerations for the type traits support.
LateParsedTemplateMapT LateParsedTemplateMap
Definition: Sema.h:625
SmallVector< PackIncludeState, 8 > PackIncludeStack
Definition: Sema.h:460
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:202
llvm::MutableArrayRef< ImplicitConversionSequence > ConversionSequenceList
A list of implicit conversion sequences for the arguments of an OverloadCandidate.
Definition: Overload.h:621
FormatStringType
Definition: Sema.h:10354
CorrectTypoKind
Definition: Sema.h:3208
static bool getPrintable(bool B)
Definition: Sema.h:1492
bool operator==(CanQual< T > x, CanQual< U > y)
Code completion occurs within a class, struct, or union.
Definition: Sema.h:10111
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:830
OpenCL supported extensions and optional core features.
Definition: OpenCLOptions.h:23
PragmaStack< StringLiteral * > DataSegStack
Definition: Sema.h:462
Represents a lazily-loaded vector of data.
ObjCBridgeCastKind
The kind of bridging performed by the Objective-C bridge cast.
std::unique_ptr< RecordDeclSetTy > PureVirtualClassDiagSet
PureVirtualClassDiagSet - a set of class declarations which we have emitted a list of pure virtual fu...
Definition: Sema.h:574
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:653
OpenMPDefaultmapClauseKind
OpenMP attributes for &#39;defaultmap&#39; clause.
Definition: OpenMPKinds.h:107
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:26
Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
Definition: Sema.h:9909
A structure used to record information about a failed template argument deduction, for diagnosis.
static ConditionResult ConditionError()
Definition: Sema.h:9746
Checking non-dependent argument conversions failed.
Definition: Sema.h:6879
An initializer.
Definition: Sema.h:6522
TypePropertyCache< Private > Cache
Definition: Type.cpp:3396
ObjCMessageKind
Describes the kind of message expression indicated by a message send that starts with an identifier...
Definition: Sema.h:8101
Look up the name of an Objective-C protocol.
Definition: Sema.h:3028
Decl * Entity
The entity that is being synthesized.
Definition: Sema.h:7119
QualType CXXThisTypeOverride
When non-NULL, the C++ &#39;this&#39; expression is allowed despite the current context not being a non-stati...
Definition: Sema.h:5036
OpenCLOptions OpenCLFeatures
Definition: Sema.h:311
Stmt - This represents one statement.
Definition: Stmt.h:66
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:282
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:6379
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
FullExprArg MakeFullExpr(Expr *Arg)
Definition: Sema.h:3648
Provides information about an attempted template argument deduction, whose success or failure was des...
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
Definition: Sema.h:2396
Microsoft __if_not_exists.
Definition: Sema.h:6540
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2671
LazyVector< CXXConstructorDecl *, ExternalSemaSource, &ExternalSemaSource::ReadDelegatingConstructors, 2, 2 > DelegatingCtorDeclsType
Definition: Sema.h:600
bool hasValue() const
Definition: Sema.h:431
The name refers to a function template or a set of overloaded functions that includes at least one fu...
Definition: TemplateKinds.h:26
TypedefDecl - Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier...
Definition: Decl.h:2898
ActionResult< Expr * > ExprResult
Definition: Ownership.h:251
ObjCSubscriptKind
Definition: Sema.h:2665
llvm::StringRef StackSlotLabel
Definition: Sema.h:392
SmallVector< Scope *, 2 > CurrentSEHFinally
Stack of active SEH __finally scopes. Can be empty.
Definition: Sema.h:345
void setCurrentOpenCLExtension(llvm::StringRef Ext)
Definition: Sema.h:8492
Defines the clang::Module class, which describes a module in the source code.
OriginalCallArg(QualType OriginalParamType, bool DecomposedParam, unsigned ArgIdx, QualType OriginalArgType)
Definition: Sema.h:6906
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:765
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
Definition: Lambda.h:23
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:7522
AssignConvertType
AssignConvertType - All of the &#39;assignment&#39; semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9353
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2736
Microsoft __if_exists.
Definition: Sema.h:6537
PragmaOptionsAlignKind
Definition: Sema.h:8231
Defines the C++ template declaration subclasses.
StringRef P
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:805
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4401
DeclContext * OriginalLexicalContext
Generally null except when we temporarily switch decl contexts, like in.
Definition: Sema.h:332
friend const CUDADiagBuilder & operator<<(const CUDADiagBuilder &Diag, const T &Value)
Definition: Sema.h:9937
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1665
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7167
The size of a bit-field.
Definition: Sema.h:6501
SmallVector< Module *, 16 > CodeSynthesisContextLookupModules
Extra modules inspected when performing a lookup during a template instantiation. ...
Definition: Sema.h:7178
The base class of the type hierarchy.
Definition: Type.h:1351
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
Definition: Sema.h:7569
void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Definition: Sema.h:3585
llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate > > LateParsedTemplateMapT
Definition: Sema.h:624
MissingImportKind
Kinds of missing import.
Definition: Sema.h:2095
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1207
Declaration of a variable template.
ForRangeStatus
Definition: Sema.h:2893
TemplateParamListContext
The context in which we are checking a template parameter list.
Definition: Sema.h:6111
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
Template argument deduction produced inconsistent deduced values for the given template parameter...
Definition: Sema.h:6850
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition: Sema.h:3039
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:95
LazyVector< const DeclaratorDecl *, ExternalSemaSource, &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2 > UnusedFileScopedDeclsType
Definition: Sema.h:592
A container of type source information.
Definition: Decl.h:86
static const IdentifierInfo * getPrintable(const IdentifierInfo *II)
Definition: Sema.h:1496
Wrapper for void* pointer.
Definition: Ownership.h:45
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
Look up of a name that precedes the &#39;::&#39; scope resolution operator in C++.
Definition: Sema.h:3010
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
Definition: Sema.h:7518
bool hasVisibleDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module *> *Modules=nullptr)
Determine whether any declaration of an entity is visible.
Definition: Sema.h:1567
Floating point control options.
Definition: LangOptions.h:208
We are instantiating a default argument for a template parameter.
Definition: Sema.h:7073
DelayedDiagnosticsState pushUndelayed()
Enter a new scope where access and deprecation diagnostics are not delayed.
Definition: Sema.h:690
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:9804
FileNullability Nullability
Definition: Sema.h:252
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
LiteralOperatorLookupResult
The possible outcomes of name lookup for a literal operator.
Definition: Sema.h:3064
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4035
OpenMPDefaultmapClauseModifier
OpenMP modifiers for &#39;defaultmap&#39; clause.
Definition: OpenMPKinds.h:115
SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
Definition: Sema.h:1052
unsigned NonInstantiationEntries
The number of CodeSynthesisContexts that are not template instantiations and, therefore, should not be counted as part of the instantiation depth.
Definition: Sema.h:7208
NameClassificationKind getKind() const
Definition: Sema.h:1767
static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark the template parameters that are used by this template argument.
VerifyICEDiagnoser(bool Suppress=false)
Definition: Sema.h:9808
RAII object to handle the state changes required to synthesize a function body.
Definition: Sema.h:739
Look up a namespace name within a C++ using directive or namespace alias definition, ignoring non-namespace names (C++ [basic.lookup.udir]p1).
Definition: Sema.h:3014
Consumes visible declarations found when searching for all visible names within a given scope or cont...
Definition: Lookup.h:763
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7493
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:82
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10640
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
IfExistsResult
Describes the result of an "if-exists" condition check.
Definition: Sema.h:4450
CleanupInfo Cleanup
Used to control the generation of ExprWithCleanups.
Definition: Sema.h:516
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
DiagnosticsEngine & Diags
Definition: Sema.h:318
llvm::SmallSetVector< DeclContext *, 16 > AssociatedNamespaceSet
Definition: Sema.h:2692
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:2128
llvm::SmallPtrSet< const NamedDecl *, 4 > TypoCorrectedFunctionDefinitions
The function definitions which were renamed as part of typo-correction to match their respective decl...
Definition: Sema.h:1151
Records and restores the FP_CONTRACT state on entry/exit of compound statements.
Definition: Sema.h:1171
Extra information about a function prototype.
Definition: Type.h:3387
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
CUDAFunctionPreference
Definition: Sema.h:10007
Represents a variable template specialization, which refers to a variable template with a given set o...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:10559
void diagnose(Sema &S, SourceLocation Loc, QualType T) override
Definition: Sema.h:1524
RAII object used to temporarily allow the C++ &#39;this&#39; expression to be used, with the given qualifiers...
Definition: Sema.h:5040
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1097
The lookup found a single &#39;cooked&#39; literal operator, which expects a normal literal to be built and p...
Definition: Sema.h:3071
PragmaClangSection PragmaClangBSSSection
Definition: Sema.h:374
BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
Definition: Sema.h:1519
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7061
Code completion occurs within an Objective-C implementation or category implementation.
Definition: Sema.h:10117
ObjCMethodDecl * ValueWithBytesObjCTypeMethod
The declaration of the valueWithBytes:objCType: method.
Definition: Sema.h:860
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
Definition: Sema.h:1126
bool IsDecltype
Whether we are in a decltype expression.
Definition: Sema.h:945
NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc, SourceLocation ColonColonLoc, QualType ObjectType)
Definition: Sema.h:5313
static NameClassification NestedNameSpecifier()
Definition: Sema.h:1745
SourceLocation PragmaLocation
Definition: Sema.h:394
Look up an ordinary name that is going to be redeclared as a name with linkage.
Definition: Sema.h:3023
FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const
Overwrite an EPI&#39;s exception specification with this computed exception specification.
Definition: Sema.h:4728
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1194
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:869
FPOptions & getFPOptions()
Definition: Sema.h:1195
const TemplateArgument * TemplateArgs
The list of template arguments we are substituting, if they are not part of the entity.
Definition: Sema.h:7128
The collection of all-type qualifiers we support.
Definition: Type.h:152
MethodMatchStrategy
Definition: Sema.h:3495
Information about a template-id annotation token.
static SourceRange getPrintable(TypeLoc TL)
Definition: Sema.h:1504
void setMethod(CXXMethodDecl *MD)
Definition: Sema.h:1042
void threadSafetyCleanup(BeforeSet *Cache)
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
friend const SemaDiagnosticBuilder & operator<<(const SemaDiagnosticBuilder &Diag, const T &Value)
Teach operator<< to produce an object of the correct type.
Definition: Sema.h:1261
ContextualImplicitConverter(bool Suppress=false, bool SuppressConversion=false)
Definition: Sema.h:2594
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:833
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7489
The lookup found a single &#39;raw&#39; literal operator, which expects a string literal containing the spell...
Definition: Sema.h:3074
IntToPointer - The assignment converts an int to a pointer, which we accept as an extension...
Definition: Sema.h:9363
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
Definition: Ownership.h:232
Step
Definition: OpenMPClause.h:141
IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an object with __weak qualifier...
Definition: Sema.h:9413
Enumerator value with fixed underlying type.
Definition: Sema.h:2577
Value of a non-type template parameter.
Definition: Sema.h:2578
Represents a class type in Objective C.
Definition: Type.h:5184
ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context, unsigned NumCleanupObjects, CleanupInfo ParentCleanup, Decl *ManglingContextDecl, bool IsDecltype)
Definition: Sema.h:981
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7393
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1182
A C-style cast.
Definition: Sema.h:9233
FileNullability & operator[](FileID file)
Definition: Sema.h:256
OpenMPLinearClauseKind
OpenMP attributes for &#39;linear&#39; clause.
Definition: OpenMPKinds.h:84
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
AttributeList * Attribute
Definition: Sema.h:494
IdentifierSourceLocations TypoCorrectionFailures
A cache containing identifiers for which typo correction failed and their locations, so that repeated attempts to correct an identifier in a given location are ignored if typo correction already failed for it.
Definition: Sema.h:7504
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7508
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:839
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Definition: TypeTraits.h:96
NamedDecl * Template
The template (or partial specialization) in which we are performing the instantiation, for substitutions of prior template arguments.
Definition: Sema.h:7124
static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A)
checkUnusedDeclAttributes - Check a list of attributes to see if it contains any decl attributes that...
Code completion occurs following one or more template headers within a class.
Definition: Sema.h:10126
This is not an overload because the signature exactly matches an existing declaration.
Definition: Sema.h:2485
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3289
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
CachedTokens Toks
Definition: Sema.h:10695
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
bool isVisible(const Module *M) const
Determine whether a module is visible.
Definition: Module.h:595
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
Definition: Sema.h:9381
bool isInvalid() const
Definition: Sema.h:9735
ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool)
Definition: Sema.h:3929
The fixed underlying type of an enumeration.
Definition: Sema.h:6507
bool isExternallyDeclarable() const
Determine whether this declaration can be redeclared in a different translation unit.
Definition: Decl.h:376
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3439
TemplateName getTemplateName() const
Definition: Sema.h:1779
LazyVector< VarDecl *, ExternalSemaSource, &ExternalSemaSource::ReadTentativeDefinitions, 2, 2 > TentativeDefinitionsType
Definition: Sema.h:585
Defines some OpenMP-specific enums and functions.
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:131
The type of a non-type template parameter.
Definition: Sema.h:6528
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
Diagnostic builder for CUDA errors which may or may not be deferred.
Definition: Sema.h:9903
ArrayRef< std::pair< IdentifierInfo *, SourceLocation > > ModuleIdPath
A sequence of identifier/location pairs used to describe a particular module or submodule, e.g., std.vector.
Definition: ModuleLoader.h:33
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final * state
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:13722
OverloadKind
C++ Overloading.
Definition: Sema.h:2478
Code completion occurs where only a type is permitted.
Definition: Sema.h:10143
Describes a module or submodule.
Definition: Module.h:65
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1074
ObjCMethodDecl * LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupFactoryMethodInGlobalPool - Returns the method and warns if there are multiple signatures...
Definition: Sema.h:3603
This little struct is used to capture information about structure field declarators, which is basically just a bitfield size.
Definition: DeclSpec.h:2459
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:1025
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:5994
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:107
The type of an exception.
Definition: Sema.h:6531
Code completion occurs at top-level or namespace context.
Definition: Sema.h:10109
A pair of a canonical FunctionDecl and a SourceLocation.
Definition: Sema.h:9858
We are instantiating the exception specification for a function template which was deferred until it ...
Definition: Sema.h:7102
bool isModuleVisible(const Module *M)
Definition: Sema.h:1558
SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
Definition: Sema.h:1228
OpenMPDistScheduleClauseKind
OpenMP attributes for &#39;dist_schedule&#39; clause.
Definition: OpenMPKinds.h:100
An allocator used specifically for the purpose of code completion.
unsigned TyposCorrected
The number of typos corrected by CorrectTypo.
Definition: Sema.h:7496
Represents a C++ using-declaration.
Definition: DeclCXX.h:3275
Code completion occurs within the body of a function on a recovery path, where we do not have a speci...
Definition: Sema.h:10141
llvm::SmallVector< QualType, 4 > CurrentParameterCopyTypes
Stack of types that correspond to the parameter entities that are currently being copy-initialized...
Definition: Sema.h:1155
BinaryOperatorKind
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:910
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1615
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
Look up implicit &#39;self&#39; parameter of an objective-c method.
Definition: Sema.h:3030
Represents the results of name lookup.
Definition: Lookup.h:32
PtrTy get() const
Definition: Ownership.h:162
static const std::string & getPrintable(const std::string &S)
Definition: Sema.h:1495
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:7471
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:986
static void hash_combine(std::size_t &seed, const T &v)
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
bool AllowAbstractFieldReference
A flag to indicate that we&#39;re in a context that permits abstract references to fields.
Definition: Sema.h:886
uint32_t Offset
Definition: CacheTokens.cpp:43
const FormatToken & Tok
Module * getOwningModule(Decl *Entity)
Get the module owning an entity.
Definition: Sema.h:1552
bool isObjCMethodDecl(Decl *D)
Definition: Sema.h:1998
ICEConvertDiagnoser(bool AllowScopedEnumerations, bool Suppress, bool SuppressConversion)
Definition: Sema.h:2641
Code completion occurs following one or more template headers.
Definition: Sema.h:10123
The base type of a class type.
Definition: Sema.h:6492
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
Look up all declarations in a scope with the given name, including resolved using declarations...
Definition: Sema.h:3018
Code completion occurs within an expression.
Definition: Sema.h:10128
PragmaStack(const ValueType &Default)
Definition: Sema.h:428
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:565
ObjCContainerKind
Definition: Sema.h:7813
unsigned LayoutCompatible
If true, Type should be compared with other expression&#39;s types for layout-compatibility.
Definition: Sema.h:10455
ExprResult getExpression() const
Definition: Sema.h:1774
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
void incrementMSManglingNumber() const
Definition: Sema.h:10526
llvm::DenseSet< Module * > LookupModulesCache
Cache of additional modules that should be used for name lookup within the current template instantia...
Definition: Sema.h:7183
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1122
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2760
Substitution of the deduced template argument values resulted in an error.
Definition: Sema.h:6858
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
Definition: Sema.h:7116
llvm::SmallSetVector< const NamedDecl *, 16 > NamedDeclSetType
Definition: Sema.h:551
Look up the name of an OpenMP user-defined reduction operation.
Definition: Sema.h:3032
Template argument deduction exceeded the maximum template instantiation depth (which has already been...
Definition: Sema.h:6844
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
Definition: Sema.h:7039
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9229
EnterExpressionEvaluationContext(Sema &Actions, InitListTag, bool ShouldEnter=true)
Definition: Sema.h:10667
std::pair< StringRef, QualType > CapturedParamNameType
Definition: Sema.h:3791
std::function< ExprResult(Sema &, TypoExpr *, TypoCorrection)> TypoRecoveryCallback
Definition: Sema.h:3095
LazyDeclPtr StdBadAlloc
The C++ "std::bad_alloc" class, which is defined by the C++ standard library.
Definition: Sema.h:812
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, std::vector< PartialDiagnosticAt > > CUDADeferredDiags
Diagnostics that are emitted only if we discover that the given function must be codegen&#39;ed.
Definition: Sema.h:9854
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
The type of a data member.
Definition: Sema.h:6498
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
Definition: Sema.h:2157
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:5232
void popUndelayed(DelayedDiagnosticsState state)
Undo a previous pushUndelayed().
Definition: Sema.h:698
PragmaPackDiagnoseKind
Definition: Sema.h:8253
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2710
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2083
llvm::DenseMap< Decl *, SmallVector< PartialDiagnosticAt, 1 > > SuppressedDiagnosticsMap
For each declaration that involved template argument deduction, the set of diagnostics that were supp...
Definition: Sema.h:7253
AccessResult
Definition: Sema.h:5929
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:90
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang&#39;s AST.
static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc)
Returns true if we can take the address of the function.
void incrementMSManglingNumber()
Definition: Scope.h:289
Preprocessor & PP
Definition: Sema.h:315
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:836
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
LambdaCaptureInitKind
Definition: DeclSpec.h:2510
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:7507
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3866
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:7422
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
SmallVector< LambdaExpr *, 2 > Lambdas
The lambdas that are present within this context, if it is indeed an unevaluated context.
Definition: Sema.h:959
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3002
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
Definition: Sema.h:9377
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:820
llvm::DenseMap< IdentifierInfo *, AsmLabelAttr * > ExtnameUndeclaredIdentifiers
ExtnameUndeclaredIdentifiers - Identifiers contained in #pragma redefine_extname before declared...
Definition: Sema.h:787
FullExprArg(Sema &actions)
Definition: Sema.h:3626
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:857
const LangOptions & LangOpts
Definition: Sema.h:314
static NameClassification TypeTemplate(TemplateName Name)
Definition: Sema.h:1749
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:7230
uint8_t PointerKind
Which kind of pointer declarator we saw.
Definition: Sema.h:237
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:55
TemplateNameKindForDiagnostics
Describes the detailed kind of a template name. Used in diagnostics.
Definition: Sema.h:1830
ParsingClassState PushParsingClass()
Definition: Sema.h:3935
unsigned NumCleanupObjects
The number of active cleanup objects when we entered this expression evaluation context.
Definition: Sema.h:949
llvm::SmallVector< DeleteExprLoc, 4 > DeleteLocs
Definition: Sema.h:566
A helper class for building up ExtParameterInfos.
Definition: Sema.h:7594
void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddInstanceMethodToGlobalPool - All instance methods in a translation unit are added to a global pool...
Definition: Sema.h:3580
TypeTrait
Names for traits that operate specifically on types.
Definition: TypeTraits.h:21
bool MSStructPragmaOn
Definition: Sema.h:338
We are matching the template parameter lists of two template template parameters as part of matching ...
Definition: Sema.h:6389
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1197
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:7431
Defines the clang::TemplateNameKind enum.
ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
Definition: Sema.h:7235
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1129
static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
llvm::Optional< bool > getKnownValue() const
Definition: Sema.h:9740
virtual ~TypeDiagnoser()
Definition: Sema.h:1487
We are substituting explicit template arguments provided for a function template. ...
Definition: Sema.h:7082
IdentifierInfo * IdentInfo
Definition: Sema.h:4416
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
Merge availability attributes for an implementation of a protocol requirement.
Definition: Sema.h:2399
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:955
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
A functional-style cast.
Definition: Sema.h:9235
SmallVector< CallExpr *, 8 > DelayedDecltypeCalls
If we are processing a decltype type, a set of call expressions for which we have deferred checking t...
Definition: Sema.h:975
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:588
ResultTypeCompatibilityKind
Describes the compatibility of a result type with its method.
Definition: Sema.h:8221
llvm::DenseMap< Selector, GlobalMethods > GlobalMethodPool
Definition: Sema.h:1114
static bool isEqual(const FunctionDeclAndLoc &LHS, const FunctionDeclAndLoc &RHS)
Definition: Sema.h:10722
Retains information about a captured region.
Definition: ScopeInfo.h:697
llvm::SmallPtrSet< Selector, 8 > SelectorSet
Definition: Sema.h:3398
A RAII object to enter scope of a compound statement.
Definition: Sema.h:3673
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
CastKind
CastKind - The kind of operation required for a conversion.
The return type of classify().
Definition: Expr.h:302
Template argument deduction did not deduce a value for every template parameter.
Definition: Sema.h:6847
static FunctionDeclAndLoc getTombstoneKey()
Definition: Sema.h:10713
FunctionVoidPointer - The assignment is between a function pointer and void*, which the standard does...
Definition: Sema.h:9367
llvm::FoldingSet< SpecialMemberOverloadResultEntry > SpecialMemberCache
A cache of special member function overload resolution results for C++ records.
Definition: Sema.h:1059
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2564
const Decl * PragmaAttributeCurrentTargetDecl
The declaration that is currently receiving an attribute from the #pragma attribute stack...
Definition: Sema.h:502
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
Definition: Sema.h:6371
DelayedDiagnosticsState ParsingDeclState
Definition: Sema.h:648
We are instantiating a template declaration.
Definition: Sema.h:7066
SourceLocation NameLoc
Definition: Sema.h:8049
Captures information about a #pragma weak directive.
Definition: Weak.h:25
std::function< void(const TypoCorrection &)> TypoDiagnosticGenerator
Definition: Sema.h:3093
SmallVector< PragmaAttributeEntry, 2 > PragmaAttributeStack
Definition: Sema.h:498
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10524
llvm::PointerIntPair< CXXRecordDecl *, 3, CXXSpecialMember > SpecialMemberDecl
Definition: Sema.h:1140
SourceLocation IdentifierLoc
The location of the identifier.
Definition: Sema.h:5301
Allows QualTypes to be sorted and hence used in maps and sets.
NameClassification(ParsedType Type)
Definition: Sema.h:1733
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:670
void popWithoutEmitting(DelayedDiagnosticsState state)
Leave a delayed-diagnostic state that was previously pushed.
Definition: Sema.h:684
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:39
llvm::DenseSet< FunctionDeclAndLoc > LocsWithCUDACallDiags
FunctionDecls and SourceLocations for which CheckCUDACall has emitted a (maybe deferred) "bad call" d...
Definition: Sema.h:9866
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3163
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3695
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:627
Expr - This represents one expression.
Definition: Expr.h:106
Emit no diagnostics.
Definition: Sema.h:9907
Defines the clang::LangOptions interface.
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:2990
SourceLocation End
SmallVector< Decl *, 2 > WeakTopLevelDecl
WeakTopLevelDecl - Translation-unit scoped declarations generated by #pragma weak during processing o...
Definition: Sema.h:798
DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool)
Enter a new scope.
Definition: Sema.h:674
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:104
Slot(llvm::StringRef StackSlotLabel, ValueType Value, SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
Definition: Sema.h:396
std::string Label
ModuleDeclKind
Definition: Sema.h:2052
Helper class that collects exception specifications for implicitly-declared special member functions...
Definition: Sema.h:4682
int Id
Definition: ASTDiff.cpp:191
When performing template argument deduction for a function template, there were too many call argumen...
Definition: Sema.h:6871
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:578
const FunctionProtoType * T
StateNode * Previous
Declaration of a template type parameter.
The message is an instance message.
Definition: Sema.h:8105
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:7363
We are substituting template argument determined as part of template argument deduction for either a ...
Definition: Sema.h:7089
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4705
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4851
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
LazyDeclPtr StdNamespace
The C++ "std" namespace, where the standard library resides.
Definition: Sema.h:808
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Code completion occurs within an Objective-C interface, protocol, or category.
Definition: Sema.h:10114
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
Definition: Sema.h:7199
IncompatibleVectors - The assignment is between two vector types that have the same size...
Definition: Sema.h:9396
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:781
#define bool
Definition: stdbool.h:31
OpenMPClauseKind
OpenMP clauses.
Definition: OpenMPKinds.h:33
QualType FindCompositePointerType(SourceLocation Loc, ExprResult &E1, ExprResult &E2, bool ConvertArgs=true)
Definition: Sema.h:9556
void PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, const BlockExpr *blkExpr=nullptr)
Definition: Sema.cpp:1377
PragmaStack< StringLiteral * > BSSSegStack
Definition: Sema.h:463
SourceLocation LocStart
Definition: Sema.h:4413
Initial building of a for-range statement.
Definition: Sema.h:3755
SourceLocation Begin
When performing template argument deduction for a function template, there were too few call argument...
Definition: Sema.h:6874
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
PragmaClangSectionAction
Definition: Sema.h:359
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
IncompatiblePointerDiscardsQualifiers - The assignment discards qualifiers that we don&#39;t permit to be...
Definition: Sema.h:9386
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Ref_Related - The two types are reference-related, which means that their unqualified forms (T1 and T...
Definition: Sema.h:9605
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
QualType NSNumberPointer
Pointer to NSNumber type (NSNumber *).
Definition: Sema.h:842
ReferenceCompareResult
ReferenceCompareResult - Expresses the result of comparing two types (cv1 T1 and cv2 T2) to determine...
Definition: Sema.h:9598
Defines the clang::TypeLoc interface and its subclasses.
int Depth
Definition: ASTDiff.cpp:191
bool isVisible(const NamedDecl *D)
Determine whether a declaration is visible to name lookup.
Definition: Sema.h:1561
Code completion occurs within a statement, which may also be an expression or a declaration.
Definition: Sema.h:10131
std::unique_ptr< MangleNumberingContext > MangleNumbering
The context information used to mangle lambda expressions and block literals within this context...
Definition: Sema.h:971
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:21
SmallVector< LateInstantiatedAttribute, 16 > LateInstantiatedAttrVec
Definition: Sema.h:7719
SmallVector< VTableUse, 16 > VTableUses
The list of vtables that are required but have not yet been materialized.
Definition: Sema.h:5741
An RAII helper that pops function a function scope on exit.
Definition: Sema.h:3688
StorageClass
Storage classes.
Definition: Specifiers.h:203
CleanupInfo ParentCleanup
Whether the enclosing context needed a cleanup.
Definition: Sema.h:942
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
Definition: Sema.h:10549
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:537
PragmaMSCommentKind
Definition: PragmaKinds.h:15
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:226
Partial specialization.
Definition: Sema.h:6534
NameClassification(ExprResult Expr)
Definition: Sema.h:1731
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:903
A mapping from file IDs to a record of whether we&#39;ve seen nullability information in that file...
Definition: Sema.h:245
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
ConditionKind
Definition: Sema.h:9748
bool isInvalid() const
Definition: Ownership.h:158
Preprocessor & getPreprocessor() const
Definition: Sema.h:1199
IdentifierInfo * Identifier
The identifier preceding the &#39;::&#39;.
Definition: Sema.h:5298
bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
Definition: Sema.h:1624
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
ObjCMethodDecl * ArrayWithObjectsMethod
The declaration of the arrayWithObjects:count: method.
Definition: Sema.h:866
const FunctionProtoType::ExtParameterInfo * getPointerOrNull(unsigned numParams)
Return a pointer (suitable for setting in an ExtProtoInfo) to the ExtParameterInfo array we&#39;ve built ...
Definition: Sema.h:7613
void addContextNote(SourceLocation UseLoc)
Definition: Sema.h:756
The symbol exists.
Definition: Sema.h:4452
SmallVector< attr::SubjectMatchRule, 4 > MatchRules
Definition: Sema.h:495
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
Definition: Sema.h:6861
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2682
Code completion occurs within the list of instance variables in an Objective-C interface, protocol, category, or implementation.
Definition: Sema.h:10120
OpenMPProcBindClauseKind
OpenMP attributes for &#39;proc_bind&#39; clause.
Definition: OpenMPKinds.h:51
ObjCTypeParamVariance
Describes the variance of a given generic parameter.
Definition: DeclObjC.h:551
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:167
PragmaClangSectionKind
pragma clang section kind
Definition: Sema.h:351
const SourceManager & SM
Definition: Format.cpp:1337
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an &#39;@&#39;.
Definition: TokenKinds.h:41
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
Definition: Sema.h:230
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1077
This is a legitimate overload: the existing declarations are functions or function templates with dif...
Definition: Sema.h:2481
ExprResult ActOnFinishFullExpr(Expr *Expr)
Definition: Sema.h:5244
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, FunctionDeclAndLoc > CUDAKnownEmittedFns
An inverse call graph, mapping known-emitted functions to one of their known-emitted callers (plus th...
Definition: Sema.h:9875
An abstract interface that should be implemented by external AST sources that also provide informatio...
ExprResult CorrectDelayedTyposInExpr(ExprResult ER, llvm::function_ref< ExprResult(Expr *)> Filter)
Definition: Sema.h:3266
CanonicalDeclPtr< FunctionDecl > FD
Definition: Sema.h:9859
static StringRef getPrintable(StringRef S)
Definition: Sema.h:1494
BuildForRangeKind
Definition: Sema.h:3753
DelegatingCtorDeclsType DelegatingCtorDecls
All the delegating constructors seen so far in the file, used for cycle detection at the end of the T...
Definition: Sema.h:604
A declaration qualifier.
Definition: Sema.h:6519
std::pair< const IdentifierInfo *, uint64_t > TypeTagMagicValue
A pair of ArgumentKind identifier and magic value.
Definition: Sema.h:10461
LazyVector< TypedefNameDecl *, ExternalSemaSource, &ExternalSemaSource::ReadExtVectorDecls, 2, 2 > ExtVectorDeclsType
Definition: Sema.h:541
bool hasVisibleDefinition(const NamedDecl *D)
Definition: Sema.h:1585
void ActOnStartOfCompoundStmt()
Definition: SemaStmt.cpp:340
StringLiteral * CurInitSeg
Last section used with #pragma init_seg.
Definition: Sema.h:484
CanThrowResult
Possible results from evaluation of a noexcept expression.
static unsigned getPrintable(unsigned I)
Definition: Sema.h:1491
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter...
Represents a C++ Modules TS module export declaration.
Definition: Decl.h:4036
NameClassificationKind
Describes the result of the name lookup and resolution performed by ClassifyName().
Definition: Sema.h:1710
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
We are declaring an implicit special member function.
Definition: Sema.h:7105
ARCConversionResult
Definition: Sema.h:9653
CXXSpecialMember SpecialMember
The special member being declared or defined.
Definition: Sema.h:7137
#define false
Definition: stdbool.h:33
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition: Sema.h:2997
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
Definition: Sema.h:827
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2548
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:387
PragmaSectionKind
Definition: Sema.h:8282
EnterExpressionEvaluationContext(Sema &Actions, Sema::ExpressionEvaluationContext NewContext, Sema::ReuseLambdaContextDecl_t, bool IsDecltype=false)
Definition: Sema.h:10656
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3365
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4969
SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath
A simple array of base specifiers.
Definition: Expr.h:53
Represents the parsed form of a C++ template argument.
A stack object to be created when performing template instantiation.
Definition: Sema.h:7267
TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull)
Definition: Sema.h:10446
ASTContext & getASTContext() const
Definition: Sema.h:1200
LazyDeclPtr StdAlignValT
The C++ "std::align_val_t" enum class, which is defined by the C++ standard library.
Definition: Sema.h:816
DeduceAutoResult
Result type of DeduceAutoType.
Definition: Sema.h:6965
Encodes a location in the source.
llvm::SmallPtrSet< Expr *, 2 > MaybeODRUseExprs
Store a list of either DeclRefExprs or MemberExprs that contain a reference to a variable (constant) ...
Definition: Sema.h:529
OpenMPDependClauseKind
OpenMP attributes for &#39;depend&#39; clause.
Definition: OpenMPKinds.h:76
Defines enumerations for expression traits intrinsics.
SourceLocation CurrentPragmaLocation
Definition: Sema.h:436
llvm::SmallPtrSet< Expr *, 2 > SavedMaybeODRUseExprs
Definition: Sema.h:955
ObjCPropertyQueryKind
Definition: DeclObjC.h:734
static unsigned getHashValue(const FunctionDeclAndLoc &FDL)
Definition: Sema.h:10717
static const char * getPrintable(const char *S)
Definition: Sema.h:1493
sema::TemplateDeductionInfo * DeductionInfo
The template deduction info object associated with the substitution or checking of explicit or deduce...
Definition: Sema.h:7147
static SourceRange getPrintable(const Expr *E)
Definition: Sema.h:1503
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
Definition: Sema.h:6855
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2944
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:459
IncompatiblePointer - The assignment is between two pointers types that are not compatible, but we accept them as an extension.
Definition: Sema.h:9371
SynthesisKind
The kind of template instantiation we are performing.
Definition: Sema.h:7063
DelayedDiagnosticsState ProcessingContextState
Definition: Sema.h:649
Decl * ManglingContextDecl
The declaration that provides context for lambda expressions and block literals if the normal declara...
Definition: Sema.h:964
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:121
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:824
ObjCSpecialMethodKind
Definition: Sema.h:8038
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
ParsedType getType() const
Definition: Sema.h:1769
SourceLocation CCLoc
The location of the &#39;::&#39;.
Definition: Sema.h:5304
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
Definition: Sema.h:665
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
TemplateNameKind getTemplateNameKind() const
Definition: Sema.h:1785
llvm::SmallPtrSet< const CXXRecordDecl *, 8 > RecordDeclSetTy
Definition: Sema.h:569
static T * mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range, typename T::VisibilityType value, unsigned attrSpellingListIndex)
SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE=false)
Definition: Sema.h:7439
We are checking the validity of a default template argument that has been used when naming a template...
Definition: Sema.h:7098
The declaration was invalid; do nothing.
Definition: Sema.h:6841
static DeclarationName getPrintable(DeclarationName N)
Definition: Sema.h:1499
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2299
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:51
The message is sent to &#39;super&#39;.
Definition: Sema.h:8103
static bool hasVisibleDefaultArgument(Sema &S, const ParmDecl *D, llvm::SmallVectorImpl< Module *> *Modules)
bool CollectStats
Flag indicating whether or not to collect detailed statistics.
Definition: Sema.h:322
static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC)
CheckBoolLikeConversion - Check conversion of given expression to boolean.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
SourceLocation PragmaLocation
Definition: Sema.h:367
bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
Definition: Sema.h:6011
Describes the kind of initialization being performed, along with location information for tokens rela...
PragmaStack< MSVtorDispAttr::Mode > VtorDispStack
Whether to insert vtordisps prior to virtual bases in the Microsoft C++ ABI.
Definition: Sema.h:449
A friend declaration.
Definition: Sema.h:6516
AbstractDiagSelID
Definition: Sema.h:5996
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1185
SourceLocation OptimizeOffPragmaLocation
This represents the last location of a "#pragma clang optimize off" directive if such a directive has...
Definition: Sema.h:507
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2468
CodeCompleteConsumer * CodeCompleter
Code-completion consumer.
Definition: Sema.h:325
unsigned NumTypos
The number of typos encountered during this expression evaluation context (i.e.
Definition: Sema.h:953
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:746
void SetLateTemplateParser(LateTemplateParserCB *LTP, LateTemplateParserCleanupCB *LTPCleanup, void *P)
Definition: Sema.h:634
OpaquePtr< TemplateName > TemplateTy
Definition: Sema.h:308
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
Definition: Sema.h:7170
A default argument.
Definition: Sema.h:6525
llvm::SmallSetVector< CXXRecordDecl *, 16 > AssociatedClassSet
Definition: Sema.h:2693
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:549
static NameClassification FunctionTemplate(TemplateName Name)
Definition: Sema.h:1761
The name is a dependent name, so the results will differ from one instantiation to the next...
Definition: Sema.h:4459
bool IsBuildingRecoveryCallExpr
Flag indicating if Sema is building a recovery call expression.
Definition: Sema.h:513
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema&#39;s representation of template deduction information to the form used in overload-can...
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:724
Constant expression in a noptr-new-declarator.
Definition: Sema.h:2579
ParameterABI
Kinds of parameter ABI.
Definition: Specifiers.h:299
llvm::DenseMap< ParmVarDecl *, llvm::TinyPtrVector< ParmVarDecl * > > UnparsedDefaultArgInstantiationsMap
Definition: Sema.h:1080
TentativeAnalysisScope(Sema &SemaRef)
Definition: Sema.h:7477
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1201
CUDAFunctionTarget CurrentCUDATarget()
Gets the CUDA target for the current context.
Definition: Sema.h:10001
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
SynthesizedFunctionScope(Sema &S, DeclContext *DC)
Definition: Sema.h:745
void setLastDiagnosticIgnored(bool Ignored=true)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:583
QualType NSValuePointer
Pointer to NSValue type (NSValue *).
Definition: Sema.h:845
Defines various enumerations that describe declaration and type specifiers.
A POD class for pairing a NamedDecl* with an access specifier.
The expression in a static assertion.
Definition: Sema.h:6504
Expression in a case label.
Definition: Sema.h:2576
ReuseLambdaContextDecl_t
Definition: Sema.h:3975
A class for storing results from argument-dependent lookup.
Definition: Lookup.h:790
OpaquePtr< QualType > TypeTy
Definition: Sema.h:309
static std::enable_if< IsPartialSpecialization< T >::value, Sema::TemplateDeductionResult >::type FinishTemplateArgumentDeduction(Sema &S, T *Partial, bool IsPartialOrdering, const TemplateArgumentList &TemplateArgs, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info)
Complete template argument deduction for a partial specialization.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2802
Abstract interface for a consumer of code-completion information.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Represents a template argument.
Definition: TemplateBase.h:51
ParserCompletionContext
Describes the context in which code completion occurs.
Definition: Sema.h:10107
ObjCDeclSpec DeclSpec
Definition: Sema.h:8053
TagTypeKind
The kind of a tag type.
Definition: Type.h:4686
OpenMPScheduleClauseModifier
OpenMP modifiers for &#39;schedule&#39; clause.
Definition: OpenMPKinds.h:67
Abstract base class used to perform a contextual implicit conversion from an expression to any type p...
Definition: Sema.h:2589
Dataflow Directional Tag Classes.
llvm::DenseMap< IdentifierInfo *, SrcLocSet > IdentifierSourceLocations
Definition: Sema.h:7499
LateTemplateParserCleanupCB * LateTemplateParserCleanup
Definition: Sema.h:631
SmallVector< CXXBindTemporaryExpr *, 8 > DelayedDecltypeBinds
If we are processing a decltype type, a set of temporary binding expressions for which we have deferr...
Definition: Sema.h:979
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
Definition: Sema.h:348
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
Definition: Sema.h:7224
Don&#39;t merge availability attributes at all.
Definition: Sema.h:2390
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Definition: Sema.h:7134
void recordUseOfEvaluatedWeak(const ExprT *E, bool IsRead=true)
Definition: Sema.h:1337
UnaryOperatorKind
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
const DeclContext * getCurObjCLexicalContext() const
Definition: Sema.h:10539
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2071
static ImplicitConversionSequence TryImplicitConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
TryImplicitConversion - Attempt to perform an implicit conversion from the given expression (Expr) to...
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
We are instantiating a default argument for a function.
Definition: Sema.h:7078
bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
Definition: Sema.h:1645
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:358
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2711
bool IsAllowedCUDACall(const FunctionDecl *Caller, const FunctionDecl *Callee)
Determines whether Caller may invoke Callee, based on their CUDA host/device attributes.
Definition: Sema.h:10033
static NameClassification VarTemplate(TemplateName Name)
Definition: Sema.h:1755
SourceLocation PointerEndLoc
The end location for the first pointer declarator in the file.
Definition: Sema.h:234
LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S, Decl *D)
Definition: Sema.h:7714
A decomposition declaration.
Definition: DeclCXX.h:3766
llvm::SmallSet< SourceLocation, 2 > SrcLocSet
Definition: Sema.h:7498
A non-depnedent component of the parameter did not match the corresponding component of the argument...
Definition: Sema.h:6868
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
Definition: Sema.h:882
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:576
unsigned size() const
The number of exceptions in the exception specification.
Definition: Sema.h:4715
SourceRange InstantiationRange
The source range that covers the construct that cause the instantiation, e.g., the template-id that c...
Definition: Sema.h:7152
Label name lookup.
Definition: Sema.h:2999
bool shouldDiagnoseTargetSupportFromOpenMP() const
Return true if (un)supported features for the current target should be diagnosed if OpenMP (offloadin...
Definition: Sema.h:8677
llvm::SmallPtrSet< SpecialMemberDecl, 4 > SpecialMembersBeingDeclared
The C++ special members which we are currently in the process of declaring.
Definition: Sema.h:1145
PragmaClangSection PragmaClangRodataSection
Definition: Sema.h:376
std::pair< CXXRecordDecl *, SourceLocation > VTableUse
The list of classes whose vtables have been used within this translation unit, and the source locatio...
Definition: Sema.h:5737
ExpressionEvaluationContext Context
The expression evaluation context.
Definition: Sema.h:939
EnumDecl - Represents an enum.
Definition: Decl.h:3239
IncompatibleBlockPointer - The assignment is between two block pointers types that are not compatible...
Definition: Sema.h:9404
The lookup found an overload set of literal operator templates, which expect the characters of the sp...
Definition: Sema.h:3078
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:143
IdentifierResolver IdResolver
Definition: Sema.h:800
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
Expr * get() const
Definition: Sema.h:3632
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
SpecialMemberOverloadResult(CXXMethodDecl *MD)
Definition: Sema.h:1038
Abstract interface for a module loader.
Definition: ModuleLoader.h:74
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext=true)
Definition: Sema.h:713
bool isHidden() const
Determine whether this declaration might be hidden from name lookup.
Definition: DeclBase.h:766
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:567
A dependently-generated diagnostic.
PragmaMsStackAction
Definition: Sema.h:379
Represents a pointer to an Objective C object.
Definition: Type.h:5440
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated", "unavailable", and "availability").
Definition: Sema.h:2388
PragmaClangSection PragmaClangDataSection
Definition: Sema.h:375
void LateTemplateParserCB(void *P, LateParsedTemplate &LPT)
Callback to the parser to parse templated functions when needed.
Definition: Sema.h:628
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures...
Definition: Sema.h:3595
llvm::DenseSet< QualType > InstantiatedNonDependentTypes
Non-dependent types used in templates that have already been instantiated by some template instantiat...
Definition: Sema.h:7174
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2571
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
DeclarationName VAListTagName
VAListTagName - The declaration name corresponding to __va_list_tag.
Definition: Sema.h:336
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
The template argument was specified in the code or was instantiated with some deduced template argume...
Definition: Sema.h:6295
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2121
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.h:1324
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
Definition: Sema.h:6292
ObjCLiteralKind
Definition: Sema.h:2674
ValueType CurrentValue
Definition: Sema.h:435
LocalInstantiationScope * Scope
Definition: Sema.h:7711
IntToBlockPointer - The assignment converts an int to a block pointer.
Definition: Sema.h:9400
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2172
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false)
Definition: SemaExpr.cpp:13704
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
const QualType * data() const
The set of exceptions in the exception specification.
Definition: Sema.h:4718
DeclContext * getCurLexicalContext() const
Definition: Sema.h:10535
void * OpaqueParser
Definition: Sema.h:632
UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations
A mapping from parameters with unparsed default arguments to the set of instantiations of each parame...
Definition: Sema.h:1089
OpenMPScheduleClauseKind
OpenMP attributes for &#39;schedule&#39; clause.
Definition: OpenMPKinds.h:59
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1006
llvm::StringRef getCurrentOpenCLExtension() const
Definition: Sema.h:8489
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
Definition: Sema.h:8670
static NameClassification Error()
Definition: Sema.h:1737
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
PragmaMSStructKind
Definition: PragmaKinds.h:24
OpenMPDefaultClauseKind
OpenMP attributes for &#39;default&#39; clause.
Definition: OpenMPKinds.h:43
ArrayRef< TemplateArgument > template_arguments() const
Definition: Sema.h:7140
Deduction failed; that&#39;s all we know.
Definition: Sema.h:6881
static NameClassification Unknown()
Definition: Sema.h:1741
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
Definition: Sema.h:863
SmallVector< BlockDecl *, 8 > ExprCleanupObjects
ExprCleanupObjects - This is the stack of objects requiring cleanup that are created by the current f...
Definition: Sema.h:521
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
static void LookupVisibleDecls(DeclContext *Ctx, LookupResult &Result, bool QualifiedNameLookup, bool InBaseClass, VisibleDeclConsumer &Consumer, VisibleDeclsRecord &Visited, bool IncludeDependentBases=false)
static SourceRange getPrintable(SourceLocation L)
Definition: Sema.h:1502
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
const Expr * Replacement
Definition: AttributeList.h:59
bool SavedInNonInstantiationSFINAEContext
Was the enclosing context a non-instantiation SFINAE context?
Definition: Sema.h:7113
PragmaStack< StringLiteral * > ConstSegStack
Definition: Sema.h:464
bool mightBeIntendedToBeTemplateName(ExprResult E)
Determine whether it&#39;s plausible that E was intended to be a template-name.
Definition: Sema.h:1843
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3368
ProcessingContextState ParsingClassState
Definition: Sema.h:3934
PragmaClangSection PragmaClangTextSection
Definition: Sema.h:377
ParsedType ObjectType
The type of the object, if we&#39;re parsing nested-name-specifier in a member access expression...
Definition: Sema.h:5295
void * SkippedDefinitionContext
Definition: Sema.h:2264
Describes whether we&#39;ve seen any nullability information for the given file.
Definition: Sema.h:227
QualType QIDNSCopying
id<NSCopying> type.
Definition: Sema.h:875
RedeclarationKind forRedeclarationInCurContext()
Definition: Sema.h:3052
An implicit conversion.
Definition: Sema.h:9231
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
Definition: Sema.h:7367
A template argument list.
Definition: DeclTemplate.h:210
Merge availability attributes for a redeclaration, which requires an exact match. ...
Definition: Sema.h:2393
SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override
Emits a diagnostic complaining that the expression does not have integral or enumeration type...
Definition: Sema.h:2650
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3371
llvm::DenseMap< NamedDecl *, NamedDecl * > VisibleNamespaceCache
Map from the most recent declaration of a namespace to the most recent visible declaration of that na...
Definition: Sema.h:7192
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4031
CCEKind
Contexts in which a converted constant expression is required.
Definition: Sema.h:2575
static void BuildBasePathArray(const CXXBasePath &Path, CXXCastPath &BasePathArray)
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Definition: Sema.h:307
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2387
ExprResult CorrectDelayedTyposInExpr(Expr *E, llvm::function_ref< ExprResult(Expr *)> Filter)
Definition: Sema.h:3253
Data structure used to record current or nested expression evaluation contexts.
Definition: Sema.h:937
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:488
Describes the sequence of initializations required to initialize a given object or reference with a s...
The lookup found no match but no diagnostic was issued.
Definition: Sema.h:3068
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
Code completion occurs at the beginning of the initialization statement (or expression) in a for loop...
Definition: Sema.h:10134
void LateTemplateParserCleanupCB(void *P)
Definition: Sema.h:629
SourceLocation PragmaPushLocation
Definition: Sema.h:395
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:668
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
Compatible - the types are compatible according to the standard.
Definition: Sema.h:9355
Decl * D
The template function declaration to be late parsed.
Definition: Sema.h:10697
CUDAFunctionTarget
Definition: Sema.h:9983
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1320
Look up a friend of a local class.
Definition: Sema.h:3026
void PopParsingClass(ParsingClassState state)
Definition: Sema.h:3938
A diagnostic message which has been conditionally emitted pending the complete parsing of the current...
OpenMPMapClauseKind
OpenMP mapping kind for &#39;map&#39; clause.
Definition: OpenMPKinds.h:92
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1964
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
Definition: Sema.h:342
TryCaptureKind
Definition: Sema.h:4010
llvm::DenseMap< int, SourceRange > ParsedSubjectMatchRuleSet
Selector RespondsToSelectorSel
will hold &#39;respondsToSelector:&#39;
Definition: Sema.h:878
TPOC
The context in which partial ordering of function templates occurs.
Definition: Template.h:138
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:242
Declaration of a class template.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:654
The enumerator value.
Definition: Sema.h:6510
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:104
SourceManager & getSourceManager() const
Definition: Sema.h:1198
After substituting deduced template arguments, an element of a dependent parameter type did not match...
Definition: Sema.h:6865
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1072
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all...
Definition: Sema.h:890
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
Represents a complete lambda introducer.
Definition: DeclSpec.h:2518
We are substituting prior template arguments into a new template parameter.
Definition: Sema.h:7094
a linked list of methods with the same selector name but different signatures.
std::pair< ObjCMethodList, ObjCMethodList > GlobalMethods
Definition: Sema.h:1113
The translation unit is a complete translation unit.
Definition: LangOptions.h:244
ExprResult CorrectDelayedTyposInExpr(ExprResult ER, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Definition: Sema.h:3259
ExceptionSpecificationType getExceptionSpecType() const
Get the computed exception specification type.
Definition: Sema.h:4708
A using declaration.
Definition: Sema.h:6513
Designation - Represent a full designation, which is a sequence of designators.
Definition: Designator.h:181
FPOptions FPFeatures
Definition: Sema.h:312
FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC)
Definition: Sema.h:3651
The name refers to a variable template whose specialization produces a variable.
Definition: TemplateKinds.h:33
static CXXRecordDecl * getCurrentInstantiationOf(QualType T, DeclContext *CurContext)
Find the current instantiation that associated with the given type.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
static SourceRange getPrintable(SourceRange R)
Definition: Sema.h:1501
Code completion occurs within the condition of an if, while, switch, or for statement.
Definition: Sema.h:10137
Lambda expression.
Definition: Sema.h:6543
llvm::DenseMap< CXXRecordDecl *, bool > VTablesUsed
The set of classes whose vtables have been used within this translation unit, and a bit that will be ...
Definition: Sema.h:5747
SourceManager & SourceMgr
Definition: Sema.h:319
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:17
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Contains a late templated function.
Definition: Sema.h:10694
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed...
Definition: DeclSpec.h:1202
static int getPrintable(int I)
Definition: Sema.h:1490
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
PragmaStack< unsigned > PackStack
Definition: Sema.h:453
A collection of diagnostics which were delayed.
Emit the diagnostic immediately, and, if it&#39;s a warning or error, also emit a call stack showing how ...
Definition: Sema.h:9913
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3835
#define true
Definition: stdbool.h:32
A wrapper class around a pointer that always points to its canonical declaration. ...
Definition: Redeclarable.h:352
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:316
IncompatibleObjCQualifiedId - The assignment is between a qualified id type and something else (that ...
Definition: Sema.h:9409
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
QualType NSStringPointer
Pointer to NSString type (NSString *).
Definition: Sema.h:854
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:3654
Represents C++ using-directive.
Definition: DeclCXX.h:2843
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:610
The template argument was deduced via template argument deduction.
Definition: Sema.h:6299
SourceLocation CurrentPragmaLocation
Definition: Sema.h:457
Look up of an operator name (e.g., operator+) for use with operator overloading.
Definition: Sema.h:3006
Describes an entity that is being initialized.
static QualType getPrintable(QualType T)
Definition: Sema.h:1500
ExprResult release()
Definition: Sema.h:3628
NamedDecl * Previous
Definition: Sema.h:1673
The type of an arbitrary declaration.
Definition: Sema.h:6495
AssignmentAction
Definition: Sema.h:2466
ParsedAttributes - A collection of parsed attributes.
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:97
SmallVector< Slot, 2 > Stack
Definition: Sema.h:433
brief A function argument from which we performed template argument
Definition: Sema.h:6905
This represents &#39;#pragma omp threadprivate ...&#39; directive.
Definition: DeclOpenMP.h:39
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2518
The explicitly-specified template arguments were not valid template arguments for the given template...
Definition: Sema.h:6877
The lookup resulted in an error.
Definition: Sema.h:3066
SmallVector< std::pair< CXXMethodDecl *, const FunctionProtoType * >, 2 > DelayedDefaultedMemberExceptionSpecs
All the members seen during a class definition which were both explicitly defaulted and had explicitl...
Definition: Sema.h:620
This class handles loading and caching of source files into memory.
void PrintContextStack()
Definition: Sema.h:7397
IncompatibleNestedPointerQualifiers - The assignment is between two nested pointer types...
Definition: Sema.h:9392
The symbol does not exist.
Definition: Sema.h:4455
Declaration of a template function.
Definition: DeclTemplate.h:967
llvm::DenseMap< const EnumDecl *, llvm::APInt > FlagBitsCache
A cache of the flags available in enumerations with the flag_bits attribute.
Definition: Sema.h:1063
Code completion occurs in a parenthesized expression, which might also be a type cast.
Definition: Sema.h:10146
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1341
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant()...
Definition: Expr.h:673
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:554
Attr - This represents one attribute.
Definition: Attr.h:43
IdentifierInfo * Name
Definition: Sema.h:8048
CastType
Definition: SemaCast.cpp:40
This represents the stack of attributes that were pushed by #pragma clang attribute.
Definition: Sema.h:492
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3066
ParsedType actOnLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init)
Perform initialization analysis of the init-capture and perform any implicit conversions such as an l...
Definition: Sema.h:5488
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:872
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1223
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:95
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:7462
llvm::DenseMap< ParmVarDecl *, SourceLocation > UnparsedDefaultArgLocs
Definition: Sema.h:1093
A RAII object to temporarily push a declaration context.
Definition: Sema.h:705
ValueType DefaultValue
Definition: Sema.h:434
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:141
SourceLocation CurInitSegLoc
Definition: Sema.h:485