1 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the Sema class, which performs semantic analysis and 10 // builds ASTs. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_SEMA_SEMA_H 15 #define LLVM_CLANG_SEMA_SEMA_H 16 17 #include "clang/AST/ASTConcept.h" 18 #include "clang/AST/ASTFwd.h" 19 #include "clang/AST/Attr.h" 20 #include "clang/AST/Availability.h" 21 #include "clang/AST/ComparisonCategories.h" 22 #include "clang/AST/DeclTemplate.h" 23 #include "clang/AST/DeclarationName.h" 24 #include "clang/AST/Expr.h" 25 #include "clang/AST/ExprCXX.h" 26 #include "clang/AST/ExprConcepts.h" 27 #include "clang/AST/ExprObjC.h" 28 #include "clang/AST/ExprOpenMP.h" 29 #include "clang/AST/ExternalASTSource.h" 30 #include "clang/AST/LocInfoType.h" 31 #include "clang/AST/MangleNumberingContext.h" 32 #include "clang/AST/NSAPI.h" 33 #include "clang/AST/PrettyPrinter.h" 34 #include "clang/AST/StmtCXX.h" 35 #include "clang/AST/TypeLoc.h" 36 #include "clang/AST/TypeOrdering.h" 37 #include "clang/Basic/BitmaskEnum.h" 38 #include "clang/Basic/ExpressionTraits.h" 39 #include "clang/Basic/Module.h" 40 #include "clang/Basic/OpenCLOptions.h" 41 #include "clang/Basic/OpenMPKinds.h" 42 #include "clang/Basic/PragmaKinds.h" 43 #include "clang/Basic/Specifiers.h" 44 #include "clang/Basic/TemplateKinds.h" 45 #include "clang/Basic/TypeTraits.h" 46 #include "clang/Sema/AnalysisBasedWarnings.h" 47 #include "clang/Sema/CleanupInfo.h" 48 #include "clang/Sema/DeclSpec.h" 49 #include "clang/Sema/ExternalSemaSource.h" 50 #include "clang/Sema/IdentifierResolver.h" 51 #include "clang/Sema/ObjCMethodList.h" 52 #include "clang/Sema/Ownership.h" 53 #include "clang/Sema/Scope.h" 54 #include "clang/Sema/SemaConcept.h" 55 #include "clang/Sema/TypoCorrection.h" 56 #include "clang/Sema/Weak.h" 57 #include "llvm/ADT/ArrayRef.h" 58 #include "llvm/ADT/Optional.h" 59 #include "llvm/ADT/SetVector.h" 60 #include "llvm/ADT/SmallBitVector.h" 61 #include "llvm/ADT/SmallPtrSet.h" 62 #include "llvm/ADT/SmallSet.h" 63 #include "llvm/ADT/SmallVector.h" 64 #include "llvm/ADT/TinyPtrVector.h" 65 #include "llvm/Frontend/OpenMP/OMPConstants.h" 66 #include <deque> 67 #include <memory> 68 #include <string> 69 #include <tuple> 70 #include <vector> 71 72 namespace llvm { 73 class APSInt; 74 template <typename ValueT> struct DenseMapInfo; 75 template <typename ValueT, typename ValueInfoT> class DenseSet; 76 class SmallBitVector; 77 struct InlineAsmIdentifierInfo; 78 } 79 80 namespace clang { 81 class ADLResult; 82 class ASTConsumer; 83 class ASTContext; 84 class ASTMutationListener; 85 class ASTReader; 86 class ASTWriter; 87 class ArrayType; 88 class ParsedAttr; 89 class BindingDecl; 90 class BlockDecl; 91 class CapturedDecl; 92 class CXXBasePath; 93 class CXXBasePaths; 94 class CXXBindTemporaryExpr; 95 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath; 96 class CXXConstructorDecl; 97 class CXXConversionDecl; 98 class CXXDeleteExpr; 99 class CXXDestructorDecl; 100 class CXXFieldCollector; 101 class CXXMemberCallExpr; 102 class CXXMethodDecl; 103 class CXXScopeSpec; 104 class CXXTemporary; 105 class CXXTryStmt; 106 class CallExpr; 107 class ClassTemplateDecl; 108 class ClassTemplatePartialSpecializationDecl; 109 class ClassTemplateSpecializationDecl; 110 class VarTemplatePartialSpecializationDecl; 111 class CodeCompleteConsumer; 112 class CodeCompletionAllocator; 113 class CodeCompletionTUInfo; 114 class CodeCompletionResult; 115 class CoroutineBodyStmt; 116 class Decl; 117 class DeclAccessPair; 118 class DeclContext; 119 class DeclRefExpr; 120 class DeclaratorDecl; 121 class DeducedTemplateArgument; 122 class DependentDiagnostic; 123 class DesignatedInitExpr; 124 class Designation; 125 class EnableIfAttr; 126 class EnumConstantDecl; 127 class Expr; 128 class ExtVectorType; 129 class FormatAttr; 130 class FriendDecl; 131 class FunctionDecl; 132 class FunctionProtoType; 133 class FunctionTemplateDecl; 134 class ImplicitConversionSequence; 135 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList; 136 class InitListExpr; 137 class InitializationKind; 138 class InitializationSequence; 139 class InitializedEntity; 140 class IntegerLiteral; 141 class LabelStmt; 142 class LambdaExpr; 143 class LangOptions; 144 class LocalInstantiationScope; 145 class LookupResult; 146 class MacroInfo; 147 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath; 148 class ModuleLoader; 149 class MultiLevelTemplateArgumentList; 150 class NamedDecl; 151 class ObjCCategoryDecl; 152 class ObjCCategoryImplDecl; 153 class ObjCCompatibleAliasDecl; 154 class ObjCContainerDecl; 155 class ObjCImplDecl; 156 class ObjCImplementationDecl; 157 class ObjCInterfaceDecl; 158 class ObjCIvarDecl; 159 template <class T> class ObjCList; 160 class ObjCMessageExpr; 161 class ObjCMethodDecl; 162 class ObjCPropertyDecl; 163 class ObjCProtocolDecl; 164 class OMPThreadPrivateDecl; 165 class OMPRequiresDecl; 166 class OMPDeclareReductionDecl; 167 class OMPDeclareSimdDecl; 168 class OMPClause; 169 struct OMPVarListLocTy; 170 struct OverloadCandidate; 171 enum class OverloadCandidateParamOrder : char; 172 enum OverloadCandidateRewriteKind : unsigned; 173 class OverloadCandidateSet; 174 class OverloadExpr; 175 class ParenListExpr; 176 class ParmVarDecl; 177 class Preprocessor; 178 class PseudoDestructorTypeStorage; 179 class PseudoObjectExpr; 180 class QualType; 181 class StandardConversionSequence; 182 class Stmt; 183 class StringLiteral; 184 class SwitchStmt; 185 class TemplateArgument; 186 class TemplateArgumentList; 187 class TemplateArgumentLoc; 188 class TemplateDecl; 189 class TemplateInstantiationCallback; 190 class TemplateParameterList; 191 class TemplatePartialOrderingContext; 192 class TemplateTemplateParmDecl; 193 class Token; 194 class TypeAliasDecl; 195 class TypedefDecl; 196 class TypedefNameDecl; 197 class TypeLoc; 198 class TypoCorrectionConsumer; 199 class UnqualifiedId; 200 class UnresolvedLookupExpr; 201 class UnresolvedMemberExpr; 202 class UnresolvedSetImpl; 203 class UnresolvedSetIterator; 204 class UsingDecl; 205 class UsingShadowDecl; 206 class ValueDecl; 207 class VarDecl; 208 class VarTemplateSpecializationDecl; 209 class VisibilityAttr; 210 class VisibleDeclConsumer; 211 class IndirectFieldDecl; 212 struct DeductionFailureInfo; 213 class TemplateSpecCandidateSet; 214 215 namespace sema { 216 class AccessedEntity; 217 class BlockScopeInfo; 218 class Capture; 219 class CapturedRegionScopeInfo; 220 class CapturingScopeInfo; 221 class CompoundScopeInfo; 222 class DelayedDiagnostic; 223 class DelayedDiagnosticPool; 224 class FunctionScopeInfo; 225 class LambdaScopeInfo; 226 class PossiblyUnreachableDiag; 227 class SemaPPCallbacks; 228 class TemplateDeductionInfo; 229 } 230 231 namespace threadSafety { 232 class BeforeSet; 233 void threadSafetyCleanup(BeforeSet* Cache); 234 } 235 236 // FIXME: No way to easily map from TemplateTypeParmTypes to 237 // TemplateTypeParmDecls, so we have this horrible PointerUnion. 238 typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>, 239 SourceLocation> UnexpandedParameterPack; 240 241 /// Describes whether we've seen any nullability information for the given 242 /// file. 243 struct FileNullability { 244 /// The first pointer declarator (of any pointer kind) in the file that does 245 /// not have a corresponding nullability annotation. 246 SourceLocation PointerLoc; 247 248 /// The end location for the first pointer declarator in the file. Used for 249 /// placing fix-its. 250 SourceLocation PointerEndLoc; 251 252 /// Which kind of pointer declarator we saw. 253 uint8_t PointerKind; 254 255 /// Whether we saw any type nullability annotations in the given file. 256 bool SawTypeNullability = false; 257 }; 258 259 /// A mapping from file IDs to a record of whether we've seen nullability 260 /// information in that file. 261 class FileNullabilityMap { 262 /// A mapping from file IDs to the nullability information for each file ID. 263 llvm::DenseMap<FileID, FileNullability> Map; 264 265 /// A single-element cache based on the file ID. 266 struct { 267 FileID File; 268 FileNullability Nullability; 269 } Cache; 270 271 public: 272 FileNullability &operator[](FileID file) { 273 // Check the single-element cache. 274 if (file == Cache.File) 275 return Cache.Nullability; 276 277 // It's not in the single-element cache; flush the cache if we have one. 278 if (!Cache.File.isInvalid()) { 279 Map[Cache.File] = Cache.Nullability; 280 } 281 282 // Pull this entry into the cache. 283 Cache.File = file; 284 Cache.Nullability = Map[file]; 285 return Cache.Nullability; 286 } 287 }; 288 289 /// Keeps track of expected type during expression parsing. The type is tied to 290 /// a particular token, all functions that update or consume the type take a 291 /// start location of the token they are looking at as a parameter. This allows 292 /// to avoid updating the type on hot paths in the parser. 293 class PreferredTypeBuilder { 294 public: 295 PreferredTypeBuilder() = default; PreferredTypeBuilder(QualType Type)296 explicit PreferredTypeBuilder(QualType Type) : Type(Type) {} 297 298 void enterCondition(Sema &S, SourceLocation Tok); 299 void enterReturn(Sema &S, SourceLocation Tok); 300 void enterVariableInit(SourceLocation Tok, Decl *D); 301 /// Computing a type for the function argument may require running 302 /// overloading, so we postpone its computation until it is actually needed. 303 /// 304 /// Clients should be very careful when using this funciton, as it stores a 305 /// function_ref, clients should make sure all calls to get() with the same 306 /// location happen while function_ref is alive. 307 void enterFunctionArgument(SourceLocation Tok, 308 llvm::function_ref<QualType()> ComputeType); 309 310 void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc); 311 void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind, 312 SourceLocation OpLoc); 313 void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op); 314 void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base); 315 void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS); 316 /// Handles all type casts, including C-style cast, C++ casts, etc. 317 void enterTypeCast(SourceLocation Tok, QualType CastType); 318 get(SourceLocation Tok)319 QualType get(SourceLocation Tok) const { 320 if (Tok != ExpectedLoc) 321 return QualType(); 322 if (!Type.isNull()) 323 return Type; 324 if (ComputeType) 325 return ComputeType(); 326 return QualType(); 327 } 328 329 private: 330 /// Start position of a token for which we store expected type. 331 SourceLocation ExpectedLoc; 332 /// Expected type for a token starting at ExpectedLoc. 333 QualType Type; 334 /// A function to compute expected type at ExpectedLoc. It is only considered 335 /// if Type is null. 336 llvm::function_ref<QualType()> ComputeType; 337 }; 338 339 /// Sema - This implements semantic analysis and AST building for C. 340 class Sema final { 341 Sema(const Sema &) = delete; 342 void operator=(const Sema &) = delete; 343 344 /// A key method to reduce duplicate debug info from Sema. 345 virtual void anchor(); 346 347 ///Source of additional semantic information. 348 ExternalSemaSource *ExternalSource; 349 350 ///Whether Sema has generated a multiplexer and has to delete it. 351 bool isMultiplexExternalSource; 352 353 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD); 354 355 bool isVisibleSlow(const NamedDecl *D); 356 357 /// Determine whether two declarations should be linked together, given that 358 /// the old declaration might not be visible and the new declaration might 359 /// not have external linkage. shouldLinkPossiblyHiddenDecl(const NamedDecl * Old,const NamedDecl * New)360 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old, 361 const NamedDecl *New) { 362 if (isVisible(Old)) 363 return true; 364 // See comment in below overload for why it's safe to compute the linkage 365 // of the new declaration here. 366 if (New->isExternallyDeclarable()) { 367 assert(Old->isExternallyDeclarable() && 368 "should not have found a non-externally-declarable previous decl"); 369 return true; 370 } 371 return false; 372 } 373 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New); 374 375 void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem, 376 QualType ResultTy, 377 ArrayRef<QualType> Args); 378 379 public: 380 /// The maximum alignment, same as in llvm::Value. We duplicate them here 381 /// because that allows us not to duplicate the constants in clang code, 382 /// which we must to since we can't directly use the llvm constants. 383 /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp 384 /// 385 /// This is the greatest alignment value supported by load, store, and alloca 386 /// instructions, and global values. 387 static const unsigned MaxAlignmentExponent = 29; 388 static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent; 389 390 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy; 391 typedef OpaquePtr<TemplateName> TemplateTy; 392 typedef OpaquePtr<QualType> TypeTy; 393 394 OpenCLOptions OpenCLFeatures; 395 FPOptions CurFPFeatures; 396 397 const LangOptions &LangOpts; 398 Preprocessor &PP; 399 ASTContext &Context; 400 ASTConsumer &Consumer; 401 DiagnosticsEngine &Diags; 402 SourceManager &SourceMgr; 403 404 /// Flag indicating whether or not to collect detailed statistics. 405 bool CollectStats; 406 407 /// Code-completion consumer. 408 CodeCompleteConsumer *CodeCompleter; 409 410 /// CurContext - This is the current declaration context of parsing. 411 DeclContext *CurContext; 412 413 /// Generally null except when we temporarily switch decl contexts, 414 /// like in \see ActOnObjCTemporaryExitContainerContext. 415 DeclContext *OriginalLexicalContext; 416 417 /// VAListTagName - The declaration name corresponding to __va_list_tag. 418 /// This is used as part of a hack to omit that class from ADL results. 419 DeclarationName VAListTagName; 420 421 bool MSStructPragmaOn; // True when \#pragma ms_struct on 422 423 /// Controls member pointer representation format under the MS ABI. 424 LangOptions::PragmaMSPointersToMembersKind 425 MSPointerToMemberRepresentationMethod; 426 427 /// Stack of active SEH __finally scopes. Can be empty. 428 SmallVector<Scope*, 2> CurrentSEHFinally; 429 430 /// Source location for newly created implicit MSInheritanceAttrs 431 SourceLocation ImplicitMSInheritanceAttrLoc; 432 433 /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by 434 /// `TransformTypos` in order to keep track of any TypoExprs that are created 435 /// recursively during typo correction and wipe them away if the correction 436 /// fails. 437 llvm::SmallVector<TypoExpr *, 2> TypoExprs; 438 439 /// pragma clang section kind 440 enum PragmaClangSectionKind { 441 PCSK_Invalid = 0, 442 PCSK_BSS = 1, 443 PCSK_Data = 2, 444 PCSK_Rodata = 3, 445 PCSK_Text = 4, 446 PCSK_Relro = 5 447 }; 448 449 enum PragmaClangSectionAction { 450 PCSA_Set = 0, 451 PCSA_Clear = 1 452 }; 453 454 struct PragmaClangSection { 455 std::string SectionName; 456 bool Valid = false; 457 SourceLocation PragmaLocation; 458 }; 459 460 PragmaClangSection PragmaClangBSSSection; 461 PragmaClangSection PragmaClangDataSection; 462 PragmaClangSection PragmaClangRodataSection; 463 PragmaClangSection PragmaClangRelroSection; 464 PragmaClangSection PragmaClangTextSection; 465 466 enum PragmaMsStackAction { 467 PSK_Reset = 0x0, // #pragma () 468 PSK_Set = 0x1, // #pragma (value) 469 PSK_Push = 0x2, // #pragma (push[, id]) 470 PSK_Pop = 0x4, // #pragma (pop[, id]) 471 PSK_Show = 0x8, // #pragma (show) -- only for "pack"! 472 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value) 473 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value) 474 }; 475 476 // #pragma pack and align. 477 class AlignPackInfo { 478 public: 479 // `Native` represents default align mode, which may vary based on the 480 // platform. 481 enum Mode : unsigned char { Native, Natural, Packed, Mac68k }; 482 483 // #pragma pack info constructor AlignPackInfo(AlignPackInfo::Mode M,unsigned Num,bool IsXL)484 AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL) 485 : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) { 486 assert(Num == PackNumber && "The pack number has been truncated."); 487 } 488 489 // #pragma align info constructor AlignPackInfo(AlignPackInfo::Mode M,bool IsXL)490 AlignPackInfo(AlignPackInfo::Mode M, bool IsXL) 491 : PackAttr(false), AlignMode(M), 492 PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {} 493 AlignPackInfo(bool IsXL)494 explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {} 495 AlignPackInfo()496 AlignPackInfo() : AlignPackInfo(Native, false) {} 497 498 // When a AlignPackInfo itself cannot be used, this returns an 32-bit 499 // integer encoding for it. This should only be passed to 500 // AlignPackInfo::getFromRawEncoding, it should not be inspected directly. getRawEncoding(const AlignPackInfo & Info)501 static uint32_t getRawEncoding(const AlignPackInfo &Info) { 502 std::uint32_t Encoding{}; 503 if (Info.IsXLStack()) 504 Encoding |= IsXLMask; 505 506 Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1; 507 508 if (Info.IsPackAttr()) 509 Encoding |= PackAttrMask; 510 511 Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4; 512 513 return Encoding; 514 } 515 getFromRawEncoding(unsigned Encoding)516 static AlignPackInfo getFromRawEncoding(unsigned Encoding) { 517 bool IsXL = static_cast<bool>(Encoding & IsXLMask); 518 AlignPackInfo::Mode M = 519 static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1); 520 int PackNumber = (Encoding & PackNumMask) >> 4; 521 522 if (Encoding & PackAttrMask) 523 return AlignPackInfo(M, PackNumber, IsXL); 524 525 return AlignPackInfo(M, IsXL); 526 } 527 IsPackAttr()528 bool IsPackAttr() const { return PackAttr; } 529 IsAlignAttr()530 bool IsAlignAttr() const { return !PackAttr; } 531 getAlignMode()532 Mode getAlignMode() const { return AlignMode; } 533 getPackNumber()534 unsigned getPackNumber() const { return PackNumber; } 535 IsPackSet()536 bool IsPackSet() const { 537 // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack 538 // attriute on a decl. 539 return PackNumber != UninitPackVal && PackNumber != 0; 540 } 541 IsXLStack()542 bool IsXLStack() const { return XLStack; } 543 544 bool operator==(const AlignPackInfo &Info) const { 545 return std::tie(AlignMode, PackNumber, PackAttr, XLStack) == 546 std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr, 547 Info.XLStack); 548 } 549 550 bool operator!=(const AlignPackInfo &Info) const { 551 return !(*this == Info); 552 } 553 554 private: 555 /// \brief True if this is a pragma pack attribute, 556 /// not a pragma align attribute. 557 bool PackAttr; 558 559 /// \brief The alignment mode that is in effect. 560 Mode AlignMode; 561 562 /// \brief The pack number of the stack. 563 unsigned char PackNumber; 564 565 /// \brief True if it is a XL #pragma align/pack stack. 566 bool XLStack; 567 568 /// \brief Uninitialized pack value. 569 static constexpr unsigned char UninitPackVal = -1; 570 571 // Masks to encode and decode an AlignPackInfo. 572 static constexpr uint32_t IsXLMask{0x0000'0001}; 573 static constexpr uint32_t AlignModeMask{0x0000'0006}; 574 static constexpr uint32_t PackAttrMask{0x00000'0008}; 575 static constexpr uint32_t PackNumMask{0x0000'01F0}; 576 }; 577 578 template<typename ValueType> 579 struct PragmaStack { 580 struct Slot { 581 llvm::StringRef StackSlotLabel; 582 ValueType Value; 583 SourceLocation PragmaLocation; 584 SourceLocation PragmaPushLocation; SlotPragmaStack::Slot585 Slot(llvm::StringRef StackSlotLabel, ValueType Value, 586 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation) 587 : StackSlotLabel(StackSlotLabel), Value(Value), 588 PragmaLocation(PragmaLocation), 589 PragmaPushLocation(PragmaPushLocation) {} 590 }; 591 ActPragmaStack592 void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, 593 llvm::StringRef StackSlotLabel, ValueType Value) { 594 if (Action == PSK_Reset) { 595 CurrentValue = DefaultValue; 596 CurrentPragmaLocation = PragmaLocation; 597 return; 598 } 599 if (Action & PSK_Push) 600 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, 601 PragmaLocation); 602 else if (Action & PSK_Pop) { 603 if (!StackSlotLabel.empty()) { 604 // If we've got a label, try to find it and jump there. 605 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { 606 return x.StackSlotLabel == StackSlotLabel; 607 }); 608 // If we found the label so pop from there. 609 if (I != Stack.rend()) { 610 CurrentValue = I->Value; 611 CurrentPragmaLocation = I->PragmaLocation; 612 Stack.erase(std::prev(I.base()), Stack.end()); 613 } 614 } else if (!Stack.empty()) { 615 // We do not have a label, just pop the last entry. 616 CurrentValue = Stack.back().Value; 617 CurrentPragmaLocation = Stack.back().PragmaLocation; 618 Stack.pop_back(); 619 } 620 } 621 if (Action & PSK_Set) { 622 CurrentValue = Value; 623 CurrentPragmaLocation = PragmaLocation; 624 } 625 } 626 627 // MSVC seems to add artificial slots to #pragma stacks on entering a C++ 628 // method body to restore the stacks on exit, so it works like this: 629 // 630 // struct S { 631 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>) 632 // void Method {} 633 // #pragma <name>(pop, InternalPragmaSlot) 634 // }; 635 // 636 // It works even with #pragma vtordisp, although MSVC doesn't support 637 // #pragma vtordisp(push [, id], n) 638 // syntax. 639 // 640 // Push / pop a named sentinel slot. SentinelActionPragmaStack641 void SentinelAction(PragmaMsStackAction Action, StringRef Label) { 642 assert((Action == PSK_Push || Action == PSK_Pop) && 643 "Can only push / pop #pragma stack sentinels!"); 644 Act(CurrentPragmaLocation, Action, Label, CurrentValue); 645 } 646 647 // Constructors. PragmaStackPragmaStack648 explicit PragmaStack(const ValueType &Default) 649 : DefaultValue(Default), CurrentValue(Default) {} 650 hasValuePragmaStack651 bool hasValue() const { return CurrentValue != DefaultValue; } 652 653 SmallVector<Slot, 2> Stack; 654 ValueType DefaultValue; // Value used for PSK_Reset action. 655 ValueType CurrentValue; 656 SourceLocation CurrentPragmaLocation; 657 }; 658 // FIXME: We should serialize / deserialize these if they occur in a PCH (but 659 // we shouldn't do so if they're in a module). 660 661 /// Whether to insert vtordisps prior to virtual bases in the Microsoft 662 /// C++ ABI. Possible values are 0, 1, and 2, which mean: 663 /// 664 /// 0: Suppress all vtordisps 665 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial 666 /// structors 667 /// 2: Always insert vtordisps to support RTTI on partially constructed 668 /// objects 669 PragmaStack<MSVtorDispMode> VtorDispStack; 670 PragmaStack<AlignPackInfo> AlignPackStack; 671 // The current #pragma align/pack values and locations at each #include. 672 struct AlignPackIncludeState { 673 AlignPackInfo CurrentValue; 674 SourceLocation CurrentPragmaLocation; 675 bool HasNonDefaultValue, ShouldWarnOnInclude; 676 }; 677 SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack; 678 // Segment #pragmas. 679 PragmaStack<StringLiteral *> DataSegStack; 680 PragmaStack<StringLiteral *> BSSSegStack; 681 PragmaStack<StringLiteral *> ConstSegStack; 682 PragmaStack<StringLiteral *> CodeSegStack; 683 684 // This stack tracks the current state of Sema.CurFPFeatures. 685 PragmaStack<FPOptionsOverride> FpPragmaStack; CurFPFeatureOverrides()686 FPOptionsOverride CurFPFeatureOverrides() { 687 FPOptionsOverride result; 688 if (!FpPragmaStack.hasValue()) { 689 result = FPOptionsOverride(); 690 } else { 691 result = FpPragmaStack.CurrentValue; 692 } 693 return result; 694 } 695 696 // RAII object to push / pop sentinel slots for all MS #pragma stacks. 697 // Actions should be performed only if we enter / exit a C++ method body. 698 class PragmaStackSentinelRAII { 699 public: 700 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct); 701 ~PragmaStackSentinelRAII(); 702 703 private: 704 Sema &S; 705 StringRef SlotLabel; 706 bool ShouldAct; 707 }; 708 709 /// A mapping that describes the nullability we've seen in each header file. 710 FileNullabilityMap NullabilityMap; 711 712 /// Last section used with #pragma init_seg. 713 StringLiteral *CurInitSeg; 714 SourceLocation CurInitSegLoc; 715 716 /// VisContext - Manages the stack for \#pragma GCC visibility. 717 void *VisContext; // Really a "PragmaVisStack*" 718 719 /// This an attribute introduced by \#pragma clang attribute. 720 struct PragmaAttributeEntry { 721 SourceLocation Loc; 722 ParsedAttr *Attribute; 723 SmallVector<attr::SubjectMatchRule, 4> MatchRules; 724 bool IsUsed; 725 }; 726 727 /// A push'd group of PragmaAttributeEntries. 728 struct PragmaAttributeGroup { 729 /// The location of the push attribute. 730 SourceLocation Loc; 731 /// The namespace of this push group. 732 const IdentifierInfo *Namespace; 733 SmallVector<PragmaAttributeEntry, 2> Entries; 734 }; 735 736 SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack; 737 738 /// The declaration that is currently receiving an attribute from the 739 /// #pragma attribute stack. 740 const Decl *PragmaAttributeCurrentTargetDecl; 741 742 /// This represents the last location of a "#pragma clang optimize off" 743 /// directive if such a directive has not been closed by an "on" yet. If 744 /// optimizations are currently "on", this is set to an invalid location. 745 SourceLocation OptimizeOffPragmaLocation; 746 747 /// Flag indicating if Sema is building a recovery call expression. 748 /// 749 /// This flag is used to avoid building recovery call expressions 750 /// if Sema is already doing so, which would cause infinite recursions. 751 bool IsBuildingRecoveryCallExpr; 752 753 /// Used to control the generation of ExprWithCleanups. 754 CleanupInfo Cleanup; 755 756 /// ExprCleanupObjects - This is the stack of objects requiring 757 /// cleanup that are created by the current full expression. 758 SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects; 759 760 /// Store a set of either DeclRefExprs or MemberExprs that contain a reference 761 /// to a variable (constant) that may or may not be odr-used in this Expr, and 762 /// we won't know until all lvalue-to-rvalue and discarded value conversions 763 /// have been applied to all subexpressions of the enclosing full expression. 764 /// This is cleared at the end of each full expression. 765 using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>, 766 llvm::SmallPtrSet<Expr *, 4>>; 767 MaybeODRUseExprSet MaybeODRUseExprs; 768 769 std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope; 770 771 /// Stack containing information about each of the nested 772 /// function, block, and method scopes that are currently active. 773 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes; 774 775 /// The index of the first FunctionScope that corresponds to the current 776 /// context. 777 unsigned FunctionScopesStart = 0; 778 getFunctionScopes()779 ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const { 780 return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart, 781 FunctionScopes.end()); 782 } 783 784 /// Stack containing information needed when in C++2a an 'auto' is encountered 785 /// in a function declaration parameter type specifier in order to invent a 786 /// corresponding template parameter in the enclosing abbreviated function 787 /// template. This information is also present in LambdaScopeInfo, stored in 788 /// the FunctionScopes stack. 789 SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos; 790 791 /// The index of the first InventedParameterInfo that refers to the current 792 /// context. 793 unsigned InventedParameterInfosStart = 0; 794 getInventedParameterInfos()795 ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const { 796 return llvm::makeArrayRef(InventedParameterInfos.begin() + 797 InventedParameterInfosStart, 798 InventedParameterInfos.end()); 799 } 800 801 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource, 802 &ExternalSemaSource::ReadExtVectorDecls, 2, 2> 803 ExtVectorDeclsType; 804 805 /// ExtVectorDecls - This is a list all the extended vector types. This allows 806 /// us to associate a raw vector type with one of the ext_vector type names. 807 /// This is only necessary for issuing pretty diagnostics. 808 ExtVectorDeclsType ExtVectorDecls; 809 810 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes. 811 std::unique_ptr<CXXFieldCollector> FieldCollector; 812 813 typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType; 814 815 /// Set containing all declared private fields that are not used. 816 NamedDeclSetType UnusedPrivateFields; 817 818 /// Set containing all typedefs that are likely unused. 819 llvm::SmallSetVector<const TypedefNameDecl *, 4> 820 UnusedLocalTypedefNameCandidates; 821 822 /// Delete-expressions to be analyzed at the end of translation unit 823 /// 824 /// This list contains class members, and locations of delete-expressions 825 /// that could not be proven as to whether they mismatch with new-expression 826 /// used in initializer of the field. 827 typedef std::pair<SourceLocation, bool> DeleteExprLoc; 828 typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs; 829 llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs; 830 831 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy; 832 833 /// PureVirtualClassDiagSet - a set of class declarations which we have 834 /// emitted a list of pure virtual functions. Used to prevent emitting the 835 /// same list more than once. 836 std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet; 837 838 /// ParsingInitForAutoVars - a set of declarations with auto types for which 839 /// we are currently parsing the initializer. 840 llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars; 841 842 /// Look for a locally scoped extern "C" declaration by the given name. 843 NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name); 844 845 typedef LazyVector<VarDecl *, ExternalSemaSource, 846 &ExternalSemaSource::ReadTentativeDefinitions, 2, 2> 847 TentativeDefinitionsType; 848 849 /// All the tentative definitions encountered in the TU. 850 TentativeDefinitionsType TentativeDefinitions; 851 852 /// All the external declarations encoutered and used in the TU. 853 SmallVector<VarDecl *, 4> ExternalDeclarations; 854 855 typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource, 856 &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2> 857 UnusedFileScopedDeclsType; 858 859 /// The set of file scoped decls seen so far that have not been used 860 /// and must warn if not used. Only contains the first declaration. 861 UnusedFileScopedDeclsType UnusedFileScopedDecls; 862 863 typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource, 864 &ExternalSemaSource::ReadDelegatingConstructors, 2, 2> 865 DelegatingCtorDeclsType; 866 867 /// All the delegating constructors seen so far in the file, used for 868 /// cycle detection at the end of the TU. 869 DelegatingCtorDeclsType DelegatingCtorDecls; 870 871 /// All the overriding functions seen during a class definition 872 /// that had their exception spec checks delayed, plus the overridden 873 /// function. 874 SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2> 875 DelayedOverridingExceptionSpecChecks; 876 877 /// All the function redeclarations seen during a class definition that had 878 /// their exception spec checks delayed, plus the prior declaration they 879 /// should be checked against. Except during error recovery, the new decl 880 /// should always be a friend declaration, as that's the only valid way to 881 /// redeclare a special member before its class is complete. 882 SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2> 883 DelayedEquivalentExceptionSpecChecks; 884 885 typedef llvm::MapVector<const FunctionDecl *, 886 std::unique_ptr<LateParsedTemplate>> 887 LateParsedTemplateMapT; 888 LateParsedTemplateMapT LateParsedTemplateMap; 889 890 /// Callback to the parser to parse templated functions when needed. 891 typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT); 892 typedef void LateTemplateParserCleanupCB(void *P); 893 LateTemplateParserCB *LateTemplateParser; 894 LateTemplateParserCleanupCB *LateTemplateParserCleanup; 895 void *OpaqueParser; 896 SetLateTemplateParser(LateTemplateParserCB * LTP,LateTemplateParserCleanupCB * LTPCleanup,void * P)897 void SetLateTemplateParser(LateTemplateParserCB *LTP, 898 LateTemplateParserCleanupCB *LTPCleanup, 899 void *P) { 900 LateTemplateParser = LTP; 901 LateTemplateParserCleanup = LTPCleanup; 902 OpaqueParser = P; 903 } 904 905 class DelayedDiagnostics; 906 907 class DelayedDiagnosticsState { 908 sema::DelayedDiagnosticPool *SavedPool; 909 friend class Sema::DelayedDiagnostics; 910 }; 911 typedef DelayedDiagnosticsState ParsingDeclState; 912 typedef DelayedDiagnosticsState ProcessingContextState; 913 914 /// A class which encapsulates the logic for delaying diagnostics 915 /// during parsing and other processing. 916 class DelayedDiagnostics { 917 /// The current pool of diagnostics into which delayed 918 /// diagnostics should go. 919 sema::DelayedDiagnosticPool *CurPool; 920 921 public: DelayedDiagnostics()922 DelayedDiagnostics() : CurPool(nullptr) {} 923 924 /// Adds a delayed diagnostic. 925 void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h 926 927 /// Determines whether diagnostics should be delayed. shouldDelayDiagnostics()928 bool shouldDelayDiagnostics() { return CurPool != nullptr; } 929 930 /// Returns the current delayed-diagnostics pool. getCurrentPool()931 sema::DelayedDiagnosticPool *getCurrentPool() const { 932 return CurPool; 933 } 934 935 /// Enter a new scope. Access and deprecation diagnostics will be 936 /// collected in this pool. push(sema::DelayedDiagnosticPool & pool)937 DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) { 938 DelayedDiagnosticsState state; 939 state.SavedPool = CurPool; 940 CurPool = &pool; 941 return state; 942 } 943 944 /// Leave a delayed-diagnostic state that was previously pushed. 945 /// Do not emit any of the diagnostics. This is performed as part 946 /// of the bookkeeping of popping a pool "properly". popWithoutEmitting(DelayedDiagnosticsState state)947 void popWithoutEmitting(DelayedDiagnosticsState state) { 948 CurPool = state.SavedPool; 949 } 950 951 /// Enter a new scope where access and deprecation diagnostics are 952 /// not delayed. pushUndelayed()953 DelayedDiagnosticsState pushUndelayed() { 954 DelayedDiagnosticsState state; 955 state.SavedPool = CurPool; 956 CurPool = nullptr; 957 return state; 958 } 959 960 /// Undo a previous pushUndelayed(). popUndelayed(DelayedDiagnosticsState state)961 void popUndelayed(DelayedDiagnosticsState state) { 962 assert(CurPool == nullptr); 963 CurPool = state.SavedPool; 964 } 965 } DelayedDiagnostics; 966 967 /// A RAII object to temporarily push a declaration context. 968 class ContextRAII { 969 private: 970 Sema &S; 971 DeclContext *SavedContext; 972 ProcessingContextState SavedContextState; 973 QualType SavedCXXThisTypeOverride; 974 unsigned SavedFunctionScopesStart; 975 unsigned SavedInventedParameterInfosStart; 976 977 public: 978 ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true) S(S)979 : S(S), SavedContext(S.CurContext), 980 SavedContextState(S.DelayedDiagnostics.pushUndelayed()), 981 SavedCXXThisTypeOverride(S.CXXThisTypeOverride), 982 SavedFunctionScopesStart(S.FunctionScopesStart), 983 SavedInventedParameterInfosStart(S.InventedParameterInfosStart) 984 { 985 assert(ContextToPush && "pushing null context"); 986 S.CurContext = ContextToPush; 987 if (NewThisContext) 988 S.CXXThisTypeOverride = QualType(); 989 // Any saved FunctionScopes do not refer to this context. 990 S.FunctionScopesStart = S.FunctionScopes.size(); 991 S.InventedParameterInfosStart = S.InventedParameterInfos.size(); 992 } 993 pop()994 void pop() { 995 if (!SavedContext) return; 996 S.CurContext = SavedContext; 997 S.DelayedDiagnostics.popUndelayed(SavedContextState); 998 S.CXXThisTypeOverride = SavedCXXThisTypeOverride; 999 S.FunctionScopesStart = SavedFunctionScopesStart; 1000 S.InventedParameterInfosStart = SavedInventedParameterInfosStart; 1001 SavedContext = nullptr; 1002 } 1003 ~ContextRAII()1004 ~ContextRAII() { 1005 pop(); 1006 } 1007 }; 1008 1009 /// Whether the AST is currently being rebuilt to correct immediate 1010 /// invocations. Immediate invocation candidates and references to consteval 1011 /// functions aren't tracked when this is set. 1012 bool RebuildingImmediateInvocation = false; 1013 1014 /// Used to change context to isConstantEvaluated without pushing a heavy 1015 /// ExpressionEvaluationContextRecord object. 1016 bool isConstantEvaluatedOverride; 1017 isConstantEvaluated()1018 bool isConstantEvaluated() { 1019 return ExprEvalContexts.back().isConstantEvaluated() || 1020 isConstantEvaluatedOverride; 1021 } 1022 1023 /// RAII object to handle the state changes required to synthesize 1024 /// a function body. 1025 class SynthesizedFunctionScope { 1026 Sema &S; 1027 Sema::ContextRAII SavedContext; 1028 bool PushedCodeSynthesisContext = false; 1029 1030 public: SynthesizedFunctionScope(Sema & S,DeclContext * DC)1031 SynthesizedFunctionScope(Sema &S, DeclContext *DC) 1032 : S(S), SavedContext(S, DC) { 1033 S.PushFunctionScope(); 1034 S.PushExpressionEvaluationContext( 1035 Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 1036 if (auto *FD = dyn_cast<FunctionDecl>(DC)) 1037 FD->setWillHaveBody(true); 1038 else 1039 assert(isa<ObjCMethodDecl>(DC)); 1040 } 1041 addContextNote(SourceLocation UseLoc)1042 void addContextNote(SourceLocation UseLoc) { 1043 assert(!PushedCodeSynthesisContext); 1044 1045 Sema::CodeSynthesisContext Ctx; 1046 Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction; 1047 Ctx.PointOfInstantiation = UseLoc; 1048 Ctx.Entity = cast<Decl>(S.CurContext); 1049 S.pushCodeSynthesisContext(Ctx); 1050 1051 PushedCodeSynthesisContext = true; 1052 } 1053 ~SynthesizedFunctionScope()1054 ~SynthesizedFunctionScope() { 1055 if (PushedCodeSynthesisContext) 1056 S.popCodeSynthesisContext(); 1057 if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext)) 1058 FD->setWillHaveBody(false); 1059 S.PopExpressionEvaluationContext(); 1060 S.PopFunctionScopeInfo(); 1061 } 1062 }; 1063 1064 /// WeakUndeclaredIdentifiers - Identifiers contained in 1065 /// \#pragma weak before declared. rare. may alias another 1066 /// identifier, declared or undeclared 1067 llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers; 1068 1069 /// ExtnameUndeclaredIdentifiers - Identifiers contained in 1070 /// \#pragma redefine_extname before declared. Used in Solaris system headers 1071 /// to define functions that occur in multiple standards to call the version 1072 /// in the currently selected standard. 1073 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers; 1074 1075 1076 /// Load weak undeclared identifiers from the external source. 1077 void LoadExternalWeakUndeclaredIdentifiers(); 1078 1079 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by 1080 /// \#pragma weak during processing of other Decls. 1081 /// I couldn't figure out a clean way to generate these in-line, so 1082 /// we store them here and handle separately -- which is a hack. 1083 /// It would be best to refactor this. 1084 SmallVector<Decl*,2> WeakTopLevelDecl; 1085 1086 IdentifierResolver IdResolver; 1087 1088 /// Translation Unit Scope - useful to Objective-C actions that need 1089 /// to lookup file scope declarations in the "ordinary" C decl namespace. 1090 /// For example, user-defined classes, built-in "id" type, etc. 1091 Scope *TUScope; 1092 1093 /// The C++ "std" namespace, where the standard library resides. 1094 LazyDeclPtr StdNamespace; 1095 1096 /// The C++ "std::bad_alloc" class, which is defined by the C++ 1097 /// standard library. 1098 LazyDeclPtr StdBadAlloc; 1099 1100 /// The C++ "std::align_val_t" enum class, which is defined by the C++ 1101 /// standard library. 1102 LazyDeclPtr StdAlignValT; 1103 1104 /// The C++ "std::experimental" namespace, where the experimental parts 1105 /// of the standard library resides. 1106 NamespaceDecl *StdExperimentalNamespaceCache; 1107 1108 /// The C++ "std::initializer_list" template, which is defined in 1109 /// \<initializer_list>. 1110 ClassTemplateDecl *StdInitializerList; 1111 1112 /// The C++ "std::coroutine_traits" template, which is defined in 1113 /// \<coroutine_traits> 1114 ClassTemplateDecl *StdCoroutineTraitsCache; 1115 1116 /// The C++ "type_info" declaration, which is defined in \<typeinfo>. 1117 RecordDecl *CXXTypeInfoDecl; 1118 1119 /// The MSVC "_GUID" struct, which is defined in MSVC header files. 1120 RecordDecl *MSVCGuidDecl; 1121 1122 /// Caches identifiers/selectors for NSFoundation APIs. 1123 std::unique_ptr<NSAPI> NSAPIObj; 1124 1125 /// The declaration of the Objective-C NSNumber class. 1126 ObjCInterfaceDecl *NSNumberDecl; 1127 1128 /// The declaration of the Objective-C NSValue class. 1129 ObjCInterfaceDecl *NSValueDecl; 1130 1131 /// Pointer to NSNumber type (NSNumber *). 1132 QualType NSNumberPointer; 1133 1134 /// Pointer to NSValue type (NSValue *). 1135 QualType NSValuePointer; 1136 1137 /// The Objective-C NSNumber methods used to create NSNumber literals. 1138 ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]; 1139 1140 /// The declaration of the Objective-C NSString class. 1141 ObjCInterfaceDecl *NSStringDecl; 1142 1143 /// Pointer to NSString type (NSString *). 1144 QualType NSStringPointer; 1145 1146 /// The declaration of the stringWithUTF8String: method. 1147 ObjCMethodDecl *StringWithUTF8StringMethod; 1148 1149 /// The declaration of the valueWithBytes:objCType: method. 1150 ObjCMethodDecl *ValueWithBytesObjCTypeMethod; 1151 1152 /// The declaration of the Objective-C NSArray class. 1153 ObjCInterfaceDecl *NSArrayDecl; 1154 1155 /// The declaration of the arrayWithObjects:count: method. 1156 ObjCMethodDecl *ArrayWithObjectsMethod; 1157 1158 /// The declaration of the Objective-C NSDictionary class. 1159 ObjCInterfaceDecl *NSDictionaryDecl; 1160 1161 /// The declaration of the dictionaryWithObjects:forKeys:count: method. 1162 ObjCMethodDecl *DictionaryWithObjectsMethod; 1163 1164 /// id<NSCopying> type. 1165 QualType QIDNSCopying; 1166 1167 /// will hold 'respondsToSelector:' 1168 Selector RespondsToSelectorSel; 1169 1170 /// A flag to remember whether the implicit forms of operator new and delete 1171 /// have been declared. 1172 bool GlobalNewDeleteDeclared; 1173 1174 /// Describes how the expressions currently being parsed are 1175 /// evaluated at run-time, if at all. 1176 enum class ExpressionEvaluationContext { 1177 /// The current expression and its subexpressions occur within an 1178 /// unevaluated operand (C++11 [expr]p7), such as the subexpression of 1179 /// \c sizeof, where the type of the expression may be significant but 1180 /// no code will be generated to evaluate the value of the expression at 1181 /// run time. 1182 Unevaluated, 1183 1184 /// The current expression occurs within a braced-init-list within 1185 /// an unevaluated operand. This is mostly like a regular unevaluated 1186 /// context, except that we still instantiate constexpr functions that are 1187 /// referenced here so that we can perform narrowing checks correctly. 1188 UnevaluatedList, 1189 1190 /// The current expression occurs within a discarded statement. 1191 /// This behaves largely similarly to an unevaluated operand in preventing 1192 /// definitions from being required, but not in other ways. 1193 DiscardedStatement, 1194 1195 /// The current expression occurs within an unevaluated 1196 /// operand that unconditionally permits abstract references to 1197 /// fields, such as a SIZE operator in MS-style inline assembly. 1198 UnevaluatedAbstract, 1199 1200 /// The current context is "potentially evaluated" in C++11 terms, 1201 /// but the expression is evaluated at compile-time (like the values of 1202 /// cases in a switch statement). 1203 ConstantEvaluated, 1204 1205 /// The current expression is potentially evaluated at run time, 1206 /// which means that code may be generated to evaluate the value of the 1207 /// expression at run time. 1208 PotentiallyEvaluated, 1209 1210 /// The current expression is potentially evaluated, but any 1211 /// declarations referenced inside that expression are only used if 1212 /// in fact the current expression is used. 1213 /// 1214 /// This value is used when parsing default function arguments, for which 1215 /// we would like to provide diagnostics (e.g., passing non-POD arguments 1216 /// through varargs) but do not want to mark declarations as "referenced" 1217 /// until the default argument is used. 1218 PotentiallyEvaluatedIfUsed 1219 }; 1220 1221 using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>; 1222 1223 /// Data structure used to record current or nested 1224 /// expression evaluation contexts. 1225 struct ExpressionEvaluationContextRecord { 1226 /// The expression evaluation context. 1227 ExpressionEvaluationContext Context; 1228 1229 /// Whether the enclosing context needed a cleanup. 1230 CleanupInfo ParentCleanup; 1231 1232 /// The number of active cleanup objects when we entered 1233 /// this expression evaluation context. 1234 unsigned NumCleanupObjects; 1235 1236 /// The number of typos encountered during this expression evaluation 1237 /// context (i.e. the number of TypoExprs created). 1238 unsigned NumTypos; 1239 1240 MaybeODRUseExprSet SavedMaybeODRUseExprs; 1241 1242 /// The lambdas that are present within this context, if it 1243 /// is indeed an unevaluated context. 1244 SmallVector<LambdaExpr *, 2> Lambdas; 1245 1246 /// The declaration that provides context for lambda expressions 1247 /// and block literals if the normal declaration context does not 1248 /// suffice, e.g., in a default function argument. 1249 Decl *ManglingContextDecl; 1250 1251 /// If we are processing a decltype type, a set of call expressions 1252 /// for which we have deferred checking the completeness of the return type. 1253 SmallVector<CallExpr *, 8> DelayedDecltypeCalls; 1254 1255 /// If we are processing a decltype type, a set of temporary binding 1256 /// expressions for which we have deferred checking the destructor. 1257 SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds; 1258 1259 llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs; 1260 1261 /// Expressions appearing as the LHS of a volatile assignment in this 1262 /// context. We produce a warning for these when popping the context if 1263 /// they are not discarded-value expressions nor unevaluated operands. 1264 SmallVector<Expr*, 2> VolatileAssignmentLHSs; 1265 1266 /// Set of candidates for starting an immediate invocation. 1267 llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates; 1268 1269 /// Set of DeclRefExprs referencing a consteval function when used in a 1270 /// context not already known to be immediately invoked. 1271 llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval; 1272 1273 /// \brief Describes whether we are in an expression constext which we have 1274 /// to handle differently. 1275 enum ExpressionKind { 1276 EK_Decltype, EK_TemplateArgument, EK_Other 1277 } ExprContext; 1278 ExpressionEvaluationContextRecordExpressionEvaluationContextRecord1279 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context, 1280 unsigned NumCleanupObjects, 1281 CleanupInfo ParentCleanup, 1282 Decl *ManglingContextDecl, 1283 ExpressionKind ExprContext) 1284 : Context(Context), ParentCleanup(ParentCleanup), 1285 NumCleanupObjects(NumCleanupObjects), NumTypos(0), 1286 ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {} 1287 isUnevaluatedExpressionEvaluationContextRecord1288 bool isUnevaluated() const { 1289 return Context == ExpressionEvaluationContext::Unevaluated || 1290 Context == ExpressionEvaluationContext::UnevaluatedAbstract || 1291 Context == ExpressionEvaluationContext::UnevaluatedList; 1292 } isConstantEvaluatedExpressionEvaluationContextRecord1293 bool isConstantEvaluated() const { 1294 return Context == ExpressionEvaluationContext::ConstantEvaluated; 1295 } 1296 }; 1297 1298 /// A stack of expression evaluation contexts. 1299 SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts; 1300 1301 /// Emit a warning for all pending noderef expressions that we recorded. 1302 void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec); 1303 1304 /// Compute the mangling number context for a lambda expression or 1305 /// block literal. Also return the extra mangling decl if any. 1306 /// 1307 /// \param DC - The DeclContext containing the lambda expression or 1308 /// block literal. 1309 std::tuple<MangleNumberingContext *, Decl *> 1310 getCurrentMangleNumberContext(const DeclContext *DC); 1311 1312 1313 /// SpecialMemberOverloadResult - The overloading result for a special member 1314 /// function. 1315 /// 1316 /// This is basically a wrapper around PointerIntPair. The lowest bits of the 1317 /// integer are used to determine whether overload resolution succeeded. 1318 class SpecialMemberOverloadResult { 1319 public: 1320 enum Kind { 1321 NoMemberOrDeleted, 1322 Ambiguous, 1323 Success 1324 }; 1325 1326 private: 1327 llvm::PointerIntPair<CXXMethodDecl*, 2> Pair; 1328 1329 public: SpecialMemberOverloadResult()1330 SpecialMemberOverloadResult() : Pair() {} SpecialMemberOverloadResult(CXXMethodDecl * MD)1331 SpecialMemberOverloadResult(CXXMethodDecl *MD) 1332 : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {} 1333 getMethod()1334 CXXMethodDecl *getMethod() const { return Pair.getPointer(); } setMethod(CXXMethodDecl * MD)1335 void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); } 1336 getKind()1337 Kind getKind() const { return static_cast<Kind>(Pair.getInt()); } setKind(Kind K)1338 void setKind(Kind K) { Pair.setInt(K); } 1339 }; 1340 1341 class SpecialMemberOverloadResultEntry 1342 : public llvm::FastFoldingSetNode, 1343 public SpecialMemberOverloadResult { 1344 public: SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID & ID)1345 SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID) 1346 : FastFoldingSetNode(ID) 1347 {} 1348 }; 1349 1350 /// A cache of special member function overload resolution results 1351 /// for C++ records. 1352 llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache; 1353 1354 /// A cache of the flags available in enumerations with the flag_bits 1355 /// attribute. 1356 mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache; 1357 1358 /// The kind of translation unit we are processing. 1359 /// 1360 /// When we're processing a complete translation unit, Sema will perform 1361 /// end-of-translation-unit semantic tasks (such as creating 1362 /// initializers for tentative definitions in C) once parsing has 1363 /// completed. Modules and precompiled headers perform different kinds of 1364 /// checks. 1365 TranslationUnitKind TUKind; 1366 1367 llvm::BumpPtrAllocator BumpAlloc; 1368 1369 /// The number of SFINAE diagnostics that have been trapped. 1370 unsigned NumSFINAEErrors; 1371 1372 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>> 1373 UnparsedDefaultArgInstantiationsMap; 1374 1375 /// A mapping from parameters with unparsed default arguments to the 1376 /// set of instantiations of each parameter. 1377 /// 1378 /// This mapping is a temporary data structure used when parsing 1379 /// nested class templates or nested classes of class templates, 1380 /// where we might end up instantiating an inner class before the 1381 /// default arguments of its methods have been parsed. 1382 UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations; 1383 1384 // Contains the locations of the beginning of unparsed default 1385 // argument locations. 1386 llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs; 1387 1388 /// UndefinedInternals - all the used, undefined objects which require a 1389 /// definition in this translation unit. 1390 llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed; 1391 1392 /// Determine if VD, which must be a variable or function, is an external 1393 /// symbol that nonetheless can't be referenced from outside this translation 1394 /// unit because its type has no linkage and it's not extern "C". 1395 bool isExternalWithNoLinkageType(ValueDecl *VD); 1396 1397 /// Obtain a sorted list of functions that are undefined but ODR-used. 1398 void getUndefinedButUsed( 1399 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined); 1400 1401 /// Retrieves list of suspicious delete-expressions that will be checked at 1402 /// the end of translation unit. 1403 const llvm::MapVector<FieldDecl *, DeleteLocs> & 1404 getMismatchingDeleteExpressions() const; 1405 1406 typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods; 1407 typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool; 1408 1409 /// Method Pool - allows efficient lookup when typechecking messages to "id". 1410 /// We need to maintain a list, since selectors can have differing signatures 1411 /// across classes. In Cocoa, this happens to be extremely uncommon (only 1% 1412 /// of selectors are "overloaded"). 1413 /// At the head of the list it is recorded whether there were 0, 1, or >= 2 1414 /// methods inside categories with a particular selector. 1415 GlobalMethodPool MethodPool; 1416 1417 /// Method selectors used in a \@selector expression. Used for implementation 1418 /// of -Wselector. 1419 llvm::MapVector<Selector, SourceLocation> ReferencedSelectors; 1420 1421 /// List of SourceLocations where 'self' is implicitly retained inside a 1422 /// block. 1423 llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1> 1424 ImplicitlyRetainedSelfLocs; 1425 1426 /// Kinds of C++ special members. 1427 enum CXXSpecialMember { 1428 CXXDefaultConstructor, 1429 CXXCopyConstructor, 1430 CXXMoveConstructor, 1431 CXXCopyAssignment, 1432 CXXMoveAssignment, 1433 CXXDestructor, 1434 CXXInvalid 1435 }; 1436 1437 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember> 1438 SpecialMemberDecl; 1439 1440 /// The C++ special members which we are currently in the process of 1441 /// declaring. If this process recursively triggers the declaration of the 1442 /// same special member, we should act as if it is not yet declared. 1443 llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared; 1444 1445 /// Kinds of defaulted comparison operator functions. 1446 enum class DefaultedComparisonKind : unsigned char { 1447 /// This is not a defaultable comparison operator. 1448 None, 1449 /// This is an operator== that should be implemented as a series of 1450 /// subobject comparisons. 1451 Equal, 1452 /// This is an operator<=> that should be implemented as a series of 1453 /// subobject comparisons. 1454 ThreeWay, 1455 /// This is an operator!= that should be implemented as a rewrite in terms 1456 /// of a == comparison. 1457 NotEqual, 1458 /// This is an <, <=, >, or >= that should be implemented as a rewrite in 1459 /// terms of a <=> comparison. 1460 Relational, 1461 }; 1462 1463 /// The function definitions which were renamed as part of typo-correction 1464 /// to match their respective declarations. We want to keep track of them 1465 /// to ensure that we don't emit a "redefinition" error if we encounter a 1466 /// correctly named definition after the renamed definition. 1467 llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions; 1468 1469 /// Stack of types that correspond to the parameter entities that are 1470 /// currently being copy-initialized. Can be empty. 1471 llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes; 1472 1473 void ReadMethodPool(Selector Sel); 1474 void updateOutOfDateSelector(Selector Sel); 1475 1476 /// Private Helper predicate to check for 'self'. 1477 bool isSelfExpr(Expr *RExpr); 1478 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method); 1479 1480 /// Cause the active diagnostic on the DiagosticsEngine to be 1481 /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and 1482 /// should not be used elsewhere. 1483 void EmitCurrentDiagnostic(unsigned DiagID); 1484 1485 /// Records and restores the CurFPFeatures state on entry/exit of compound 1486 /// statements. 1487 class FPFeaturesStateRAII { 1488 public: FPFeaturesStateRAII(Sema & S)1489 FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) { 1490 OldOverrides = S.FpPragmaStack.CurrentValue; 1491 } ~FPFeaturesStateRAII()1492 ~FPFeaturesStateRAII() { 1493 S.CurFPFeatures = OldFPFeaturesState; 1494 S.FpPragmaStack.CurrentValue = OldOverrides; 1495 } getOverrides()1496 FPOptionsOverride getOverrides() { return OldOverrides; } 1497 1498 private: 1499 Sema& S; 1500 FPOptions OldFPFeaturesState; 1501 FPOptionsOverride OldOverrides; 1502 }; 1503 1504 void addImplicitTypedef(StringRef Name, QualType T); 1505 1506 bool WarnedStackExhausted = false; 1507 1508 public: 1509 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 1510 TranslationUnitKind TUKind = TU_Complete, 1511 CodeCompleteConsumer *CompletionConsumer = nullptr); 1512 ~Sema(); 1513 1514 /// Perform initialization that occurs after the parser has been 1515 /// initialized but before it parses anything. 1516 void Initialize(); 1517 getLangOpts()1518 const LangOptions &getLangOpts() const { return LangOpts; } getOpenCLOptions()1519 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; } getCurFPFeatures()1520 FPOptions &getCurFPFeatures() { return CurFPFeatures; } 1521 getDiagnostics()1522 DiagnosticsEngine &getDiagnostics() const { return Diags; } getSourceManager()1523 SourceManager &getSourceManager() const { return SourceMgr; } getPreprocessor()1524 Preprocessor &getPreprocessor() const { return PP; } getASTContext()1525 ASTContext &getASTContext() const { return Context; } getASTConsumer()1526 ASTConsumer &getASTConsumer() const { return Consumer; } 1527 ASTMutationListener *getASTMutationListener() const; getExternalSource()1528 ExternalSemaSource* getExternalSource() const { return ExternalSource; } 1529 1530 ///Registers an external source. If an external source already exists, 1531 /// creates a multiplex external source and appends to it. 1532 /// 1533 ///\param[in] E - A non-null external sema source. 1534 /// 1535 void addExternalSource(ExternalSemaSource *E); 1536 1537 void PrintStats() const; 1538 1539 /// Warn that the stack is nearly exhausted. 1540 void warnStackExhausted(SourceLocation Loc); 1541 1542 /// Run some code with "sufficient" stack space. (Currently, at least 256K is 1543 /// guaranteed). Produces a warning if we're low on stack space and allocates 1544 /// more in that case. Use this in code that may recurse deeply (for example, 1545 /// in template instantiation) to avoid stack overflow. 1546 void runWithSufficientStackSpace(SourceLocation Loc, 1547 llvm::function_ref<void()> Fn); 1548 1549 /// Helper class that creates diagnostics with optional 1550 /// template instantiation stacks. 1551 /// 1552 /// This class provides a wrapper around the basic DiagnosticBuilder 1553 /// class that emits diagnostics. ImmediateDiagBuilder is 1554 /// responsible for emitting the diagnostic (as DiagnosticBuilder 1555 /// does) and, if the diagnostic comes from inside a template 1556 /// instantiation, printing the template instantiation stack as 1557 /// well. 1558 class ImmediateDiagBuilder : public DiagnosticBuilder { 1559 Sema &SemaRef; 1560 unsigned DiagID; 1561 1562 public: ImmediateDiagBuilder(DiagnosticBuilder & DB,Sema & SemaRef,unsigned DiagID)1563 ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID) 1564 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {} ImmediateDiagBuilder(DiagnosticBuilder && DB,Sema & SemaRef,unsigned DiagID)1565 ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID) 1566 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {} 1567 1568 // This is a cunning lie. DiagnosticBuilder actually performs move 1569 // construction in its copy constructor (but due to varied uses, it's not 1570 // possible to conveniently express this as actual move construction). So 1571 // the default copy ctor here is fine, because the base class disables the 1572 // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op 1573 // in that case anwyay. 1574 ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default; 1575 ~ImmediateDiagBuilder()1576 ~ImmediateDiagBuilder() { 1577 // If we aren't active, there is nothing to do. 1578 if (!isActive()) return; 1579 1580 // Otherwise, we need to emit the diagnostic. First clear the diagnostic 1581 // builder itself so it won't emit the diagnostic in its own destructor. 1582 // 1583 // This seems wasteful, in that as written the DiagnosticBuilder dtor will 1584 // do its own needless checks to see if the diagnostic needs to be 1585 // emitted. However, because we take care to ensure that the builder 1586 // objects never escape, a sufficiently smart compiler will be able to 1587 // eliminate that code. 1588 Clear(); 1589 1590 // Dispatch to Sema to emit the diagnostic. 1591 SemaRef.EmitCurrentDiagnostic(DiagID); 1592 } 1593 1594 /// Teach operator<< to produce an object of the correct type. 1595 template <typename T> 1596 friend const ImmediateDiagBuilder & 1597 operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { 1598 const DiagnosticBuilder &BaseDiag = Diag; 1599 BaseDiag << Value; 1600 return Diag; 1601 } 1602 1603 // It is necessary to limit this to rvalue reference to avoid calling this 1604 // function with a bitfield lvalue argument since non-const reference to 1605 // bitfield is not allowed. 1606 template <typename T, typename = typename std::enable_if< 1607 !std::is_lvalue_reference<T>::value>::type> 1608 const ImmediateDiagBuilder &operator<<(T &&V) const { 1609 const DiagnosticBuilder &BaseDiag = *this; 1610 BaseDiag << std::move(V); 1611 return *this; 1612 } 1613 }; 1614 1615 /// A generic diagnostic builder for errors which may or may not be deferred. 1616 /// 1617 /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch) 1618 /// which are not allowed to appear inside __device__ functions and are 1619 /// allowed to appear in __host__ __device__ functions only if the host+device 1620 /// function is never codegen'ed. 1621 /// 1622 /// To handle this, we use the notion of "deferred diagnostics", where we 1623 /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed. 1624 /// 1625 /// This class lets you emit either a regular diagnostic, a deferred 1626 /// diagnostic, or no diagnostic at all, according to an argument you pass to 1627 /// its constructor, thus simplifying the process of creating these "maybe 1628 /// deferred" diagnostics. 1629 class SemaDiagnosticBuilder { 1630 public: 1631 enum Kind { 1632 /// Emit no diagnostics. 1633 K_Nop, 1634 /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()). 1635 K_Immediate, 1636 /// Emit the diagnostic immediately, and, if it's a warning or error, also 1637 /// emit a call stack showing how this function can be reached by an a 1638 /// priori known-emitted function. 1639 K_ImmediateWithCallStack, 1640 /// Create a deferred diagnostic, which is emitted only if the function 1641 /// it's attached to is codegen'ed. Also emit a call stack as with 1642 /// K_ImmediateWithCallStack. 1643 K_Deferred 1644 }; 1645 1646 SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID, 1647 FunctionDecl *Fn, Sema &S); 1648 SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D); 1649 SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default; 1650 ~SemaDiagnosticBuilder(); 1651 isImmediate()1652 bool isImmediate() const { return ImmediateDiag.hasValue(); } 1653 1654 /// Convertible to bool: True if we immediately emitted an error, false if 1655 /// we didn't emit an error or we created a deferred error. 1656 /// 1657 /// Example usage: 1658 /// 1659 /// if (SemaDiagnosticBuilder(...) << foo << bar) 1660 /// return ExprError(); 1661 /// 1662 /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably 1663 /// want to use these instead of creating a SemaDiagnosticBuilder yourself. 1664 operator bool() const { return isImmediate(); } 1665 1666 template <typename T> 1667 friend const SemaDiagnosticBuilder & 1668 operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { 1669 if (Diag.ImmediateDiag.hasValue()) 1670 *Diag.ImmediateDiag << Value; 1671 else if (Diag.PartialDiagId.hasValue()) 1672 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second 1673 << Value; 1674 return Diag; 1675 } 1676 1677 // It is necessary to limit this to rvalue reference to avoid calling this 1678 // function with a bitfield lvalue argument since non-const reference to 1679 // bitfield is not allowed. 1680 template <typename T, typename = typename std::enable_if< 1681 !std::is_lvalue_reference<T>::value>::type> 1682 const SemaDiagnosticBuilder &operator<<(T &&V) const { 1683 if (ImmediateDiag.hasValue()) 1684 *ImmediateDiag << std::move(V); 1685 else if (PartialDiagId.hasValue()) 1686 S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V); 1687 return *this; 1688 } 1689 1690 friend const SemaDiagnosticBuilder & 1691 operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) { 1692 if (Diag.ImmediateDiag.hasValue()) 1693 PD.Emit(*Diag.ImmediateDiag); 1694 else if (Diag.PartialDiagId.hasValue()) 1695 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD; 1696 return Diag; 1697 } 1698 AddFixItHint(const FixItHint & Hint)1699 void AddFixItHint(const FixItHint &Hint) const { 1700 if (ImmediateDiag.hasValue()) 1701 ImmediateDiag->AddFixItHint(Hint); 1702 else if (PartialDiagId.hasValue()) 1703 S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint); 1704 } 1705 ExprError(const SemaDiagnosticBuilder &)1706 friend ExprResult ExprError(const SemaDiagnosticBuilder &) { 1707 return ExprError(); 1708 } StmtError(const SemaDiagnosticBuilder &)1709 friend StmtResult StmtError(const SemaDiagnosticBuilder &) { 1710 return StmtError(); 1711 } ExprResult()1712 operator ExprResult() const { return ExprError(); } StmtResult()1713 operator StmtResult() const { return StmtError(); } TypeResult()1714 operator TypeResult() const { return TypeError(); } DeclResult()1715 operator DeclResult() const { return DeclResult(true); } MemInitResult()1716 operator MemInitResult() const { return MemInitResult(true); } 1717 1718 private: 1719 Sema &S; 1720 SourceLocation Loc; 1721 unsigned DiagID; 1722 FunctionDecl *Fn; 1723 bool ShowCallStack; 1724 1725 // Invariant: At most one of these Optionals has a value. 1726 // FIXME: Switch these to a Variant once that exists. 1727 llvm::Optional<ImmediateDiagBuilder> ImmediateDiag; 1728 llvm::Optional<unsigned> PartialDiagId; 1729 }; 1730 1731 /// Is the last error level diagnostic immediate. This is used to determined 1732 /// whether the next info diagnostic should be immediate. 1733 bool IsLastErrorImmediate = true; 1734 1735 /// Emit a diagnostic. 1736 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, 1737 bool DeferHint = false); 1738 1739 /// Emit a partial diagnostic. 1740 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD, 1741 bool DeferHint = false); 1742 1743 /// Build a partial diagnostic. 1744 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h 1745 1746 /// Whether uncompilable error has occurred. This includes error happens 1747 /// in deferred diagnostics. 1748 bool hasUncompilableErrorOccurred() const; 1749 1750 bool findMacroSpelling(SourceLocation &loc, StringRef name); 1751 1752 /// Get a string to suggest for zero-initialization of a type. 1753 std::string 1754 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const; 1755 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const; 1756 1757 /// Calls \c Lexer::getLocForEndOfToken() 1758 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0); 1759 1760 /// Retrieve the module loader associated with the preprocessor. 1761 ModuleLoader &getModuleLoader() const; 1762 1763 /// Invent a new identifier for parameters of abbreviated templates. 1764 IdentifierInfo * 1765 InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName, 1766 unsigned Index); 1767 1768 void emitAndClearUnusedLocalTypedefWarnings(); 1769 1770 private: 1771 /// Function or variable declarations to be checked for whether the deferred 1772 /// diagnostics should be emitted. 1773 SmallVector<Decl *, 4> DeclsToCheckForDeferredDiags; 1774 1775 public: 1776 // Emit all deferred diagnostics. 1777 void emitDeferredDiags(); 1778 1779 enum TUFragmentKind { 1780 /// The global module fragment, between 'module;' and a module-declaration. 1781 Global, 1782 /// A normal translation unit fragment. For a non-module unit, this is the 1783 /// entire translation unit. Otherwise, it runs from the module-declaration 1784 /// to the private-module-fragment (if any) or the end of the TU (if not). 1785 Normal, 1786 /// The private module fragment, between 'module :private;' and the end of 1787 /// the translation unit. 1788 Private 1789 }; 1790 1791 void ActOnStartOfTranslationUnit(); 1792 void ActOnEndOfTranslationUnit(); 1793 void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind); 1794 1795 void CheckDelegatingCtorCycles(); 1796 1797 Scope *getScopeForContext(DeclContext *Ctx); 1798 1799 void PushFunctionScope(); 1800 void PushBlockScope(Scope *BlockScope, BlockDecl *Block); 1801 sema::LambdaScopeInfo *PushLambdaScope(); 1802 1803 /// This is used to inform Sema what the current TemplateParameterDepth 1804 /// is during Parsing. Currently it is used to pass on the depth 1805 /// when parsing generic lambda 'auto' parameters. 1806 void RecordParsingTemplateParameterDepth(unsigned Depth); 1807 1808 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, 1809 RecordDecl *RD, CapturedRegionKind K, 1810 unsigned OpenMPCaptureLevel = 0); 1811 1812 /// Custom deleter to allow FunctionScopeInfos to be kept alive for a short 1813 /// time after they've been popped. 1814 class PoppedFunctionScopeDeleter { 1815 Sema *Self; 1816 1817 public: PoppedFunctionScopeDeleter(Sema * Self)1818 explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {} 1819 void operator()(sema::FunctionScopeInfo *Scope) const; 1820 }; 1821 1822 using PoppedFunctionScopePtr = 1823 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>; 1824 1825 PoppedFunctionScopePtr 1826 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr, 1827 const Decl *D = nullptr, 1828 QualType BlockType = QualType()); 1829 getCurFunction()1830 sema::FunctionScopeInfo *getCurFunction() const { 1831 return FunctionScopes.empty() ? nullptr : FunctionScopes.back(); 1832 } 1833 1834 sema::FunctionScopeInfo *getEnclosingFunction() const; 1835 1836 void setFunctionHasBranchIntoScope(); 1837 void setFunctionHasBranchProtectedScope(); 1838 void setFunctionHasIndirectGoto(); 1839 1840 void PushCompoundScope(bool IsStmtExpr); 1841 void PopCompoundScope(); 1842 1843 sema::CompoundScopeInfo &getCurCompoundScope() const; 1844 1845 bool hasAnyUnrecoverableErrorsInThisFunction() const; 1846 1847 /// Retrieve the current block, if any. 1848 sema::BlockScopeInfo *getCurBlock(); 1849 1850 /// Get the innermost lambda enclosing the current location, if any. This 1851 /// looks through intervening non-lambda scopes such as local functions and 1852 /// blocks. 1853 sema::LambdaScopeInfo *getEnclosingLambda() const; 1854 1855 /// Retrieve the current lambda scope info, if any. 1856 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most 1857 /// lambda scope info ignoring all inner capturing scopes that are not 1858 /// lambda scopes. 1859 sema::LambdaScopeInfo * 1860 getCurLambda(bool IgnoreNonLambdaCapturingScope = false); 1861 1862 /// Retrieve the current generic lambda info, if any. 1863 sema::LambdaScopeInfo *getCurGenericLambda(); 1864 1865 /// Retrieve the current captured region, if any. 1866 sema::CapturedRegionScopeInfo *getCurCapturedRegion(); 1867 1868 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls WeakTopLevelDecls()1869 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; } 1870 1871 /// Called before parsing a function declarator belonging to a function 1872 /// declaration. 1873 void ActOnStartFunctionDeclarationDeclarator(Declarator &D, 1874 unsigned TemplateParameterDepth); 1875 1876 /// Called after parsing a function declarator belonging to a function 1877 /// declaration. 1878 void ActOnFinishFunctionDeclarationDeclarator(Declarator &D); 1879 1880 void ActOnComment(SourceRange Comment); 1881 1882 //===--------------------------------------------------------------------===// 1883 // Type Analysis / Processing: SemaType.cpp. 1884 // 1885 1886 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, 1887 const DeclSpec *DS = nullptr); 1888 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA, 1889 const DeclSpec *DS = nullptr); 1890 QualType BuildPointerType(QualType T, 1891 SourceLocation Loc, DeclarationName Entity); 1892 QualType BuildReferenceType(QualType T, bool LValueRef, 1893 SourceLocation Loc, DeclarationName Entity); 1894 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, 1895 Expr *ArraySize, unsigned Quals, 1896 SourceRange Brackets, DeclarationName Entity); 1897 QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc); 1898 QualType BuildExtVectorType(QualType T, Expr *ArraySize, 1899 SourceLocation AttrLoc); 1900 QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns, 1901 SourceLocation AttrLoc); 1902 1903 QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, 1904 SourceLocation AttrLoc); 1905 1906 /// Same as above, but constructs the AddressSpace index if not provided. 1907 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace, 1908 SourceLocation AttrLoc); 1909 1910 bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc); 1911 1912 bool CheckFunctionReturnType(QualType T, SourceLocation Loc); 1913 1914 /// Build a function type. 1915 /// 1916 /// This routine checks the function type according to C++ rules and 1917 /// under the assumption that the result type and parameter types have 1918 /// just been instantiated from a template. It therefore duplicates 1919 /// some of the behavior of GetTypeForDeclarator, but in a much 1920 /// simpler form that is only suitable for this narrow use case. 1921 /// 1922 /// \param T The return type of the function. 1923 /// 1924 /// \param ParamTypes The parameter types of the function. This array 1925 /// will be modified to account for adjustments to the types of the 1926 /// function parameters. 1927 /// 1928 /// \param Loc The location of the entity whose type involves this 1929 /// function type or, if there is no such entity, the location of the 1930 /// type that will have function type. 1931 /// 1932 /// \param Entity The name of the entity that involves the function 1933 /// type, if known. 1934 /// 1935 /// \param EPI Extra information about the function type. Usually this will 1936 /// be taken from an existing function with the same prototype. 1937 /// 1938 /// \returns A suitable function type, if there are no errors. The 1939 /// unqualified type will always be a FunctionProtoType. 1940 /// Otherwise, returns a NULL type. 1941 QualType BuildFunctionType(QualType T, 1942 MutableArrayRef<QualType> ParamTypes, 1943 SourceLocation Loc, DeclarationName Entity, 1944 const FunctionProtoType::ExtProtoInfo &EPI); 1945 1946 QualType BuildMemberPointerType(QualType T, QualType Class, 1947 SourceLocation Loc, 1948 DeclarationName Entity); 1949 QualType BuildBlockPointerType(QualType T, 1950 SourceLocation Loc, DeclarationName Entity); 1951 QualType BuildParenType(QualType T); 1952 QualType BuildAtomicType(QualType T, SourceLocation Loc); 1953 QualType BuildReadPipeType(QualType T, 1954 SourceLocation Loc); 1955 QualType BuildWritePipeType(QualType T, 1956 SourceLocation Loc); 1957 QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc); 1958 1959 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S); 1960 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy); 1961 1962 /// Package the given type and TSI into a ParsedType. 1963 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo); 1964 DeclarationNameInfo GetNameForDeclarator(Declarator &D); 1965 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name); 1966 static QualType GetTypeFromParser(ParsedType Ty, 1967 TypeSourceInfo **TInfo = nullptr); 1968 CanThrowResult canThrow(const Stmt *E); 1969 /// Determine whether the callee of a particular function call can throw. 1970 /// E, D and Loc are all optional. 1971 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D, 1972 SourceLocation Loc = SourceLocation()); 1973 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc, 1974 const FunctionProtoType *FPT); 1975 void UpdateExceptionSpec(FunctionDecl *FD, 1976 const FunctionProtoType::ExceptionSpecInfo &ESI); 1977 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range); 1978 bool CheckDistantExceptionSpec(QualType T); 1979 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New); 1980 bool CheckEquivalentExceptionSpec( 1981 const FunctionProtoType *Old, SourceLocation OldLoc, 1982 const FunctionProtoType *New, SourceLocation NewLoc); 1983 bool CheckEquivalentExceptionSpec( 1984 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, 1985 const FunctionProtoType *Old, SourceLocation OldLoc, 1986 const FunctionProtoType *New, SourceLocation NewLoc); 1987 bool handlerCanCatch(QualType HandlerType, QualType ExceptionType); 1988 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, 1989 const PartialDiagnostic &NestedDiagID, 1990 const PartialDiagnostic &NoteID, 1991 const PartialDiagnostic &NoThrowDiagID, 1992 const FunctionProtoType *Superset, 1993 SourceLocation SuperLoc, 1994 const FunctionProtoType *Subset, 1995 SourceLocation SubLoc); 1996 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID, 1997 const PartialDiagnostic &NoteID, 1998 const FunctionProtoType *Target, 1999 SourceLocation TargetLoc, 2000 const FunctionProtoType *Source, 2001 SourceLocation SourceLoc); 2002 2003 TypeResult ActOnTypeName(Scope *S, Declarator &D); 2004 2005 /// The parser has parsed the context-sensitive type 'instancetype' 2006 /// in an Objective-C message declaration. Return the appropriate type. 2007 ParsedType ActOnObjCInstanceType(SourceLocation Loc); 2008 2009 /// Abstract class used to diagnose incomplete types. 2010 struct TypeDiagnoser { TypeDiagnoserTypeDiagnoser2011 TypeDiagnoser() {} 2012 2013 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0; ~TypeDiagnoserTypeDiagnoser2014 virtual ~TypeDiagnoser() {} 2015 }; 2016 getPrintable(int I)2017 static int getPrintable(int I) { return I; } getPrintable(unsigned I)2018 static unsigned getPrintable(unsigned I) { return I; } getPrintable(bool B)2019 static bool getPrintable(bool B) { return B; } getPrintable(const char * S)2020 static const char * getPrintable(const char *S) { return S; } getPrintable(StringRef S)2021 static StringRef getPrintable(StringRef S) { return S; } getPrintable(const std::string & S)2022 static const std::string &getPrintable(const std::string &S) { return S; } getPrintable(const IdentifierInfo * II)2023 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) { 2024 return II; 2025 } getPrintable(DeclarationName N)2026 static DeclarationName getPrintable(DeclarationName N) { return N; } getPrintable(QualType T)2027 static QualType getPrintable(QualType T) { return T; } getPrintable(SourceRange R)2028 static SourceRange getPrintable(SourceRange R) { return R; } getPrintable(SourceLocation L)2029 static SourceRange getPrintable(SourceLocation L) { return L; } getPrintable(const Expr * E)2030 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); } getPrintable(TypeLoc TL)2031 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();} 2032 2033 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser { 2034 protected: 2035 unsigned DiagID; 2036 std::tuple<const Ts &...> Args; 2037 2038 template <std::size_t... Is> emit(const SemaDiagnosticBuilder & DB,std::index_sequence<Is...>)2039 void emit(const SemaDiagnosticBuilder &DB, 2040 std::index_sequence<Is...>) const { 2041 // Apply all tuple elements to the builder in order. 2042 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...}; 2043 (void)Dummy; 2044 } 2045 2046 public: BoundTypeDiagnoser(unsigned DiagID,const Ts &...Args)2047 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args) 2048 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) { 2049 assert(DiagID != 0 && "no diagnostic for type diagnoser"); 2050 } 2051 diagnose(Sema & S,SourceLocation Loc,QualType T)2052 void diagnose(Sema &S, SourceLocation Loc, QualType T) override { 2053 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID); 2054 emit(DB, std::index_sequence_for<Ts...>()); 2055 DB << T; 2056 } 2057 }; 2058 2059 /// Do a check to make sure \p Name looks like a legal argument for the 2060 /// swift_name attribute applied to decl \p D. Raise a diagnostic if the name 2061 /// is invalid for the given declaration. 2062 /// 2063 /// \p AL is used to provide caret diagnostics in case of a malformed name. 2064 /// 2065 /// \returns true if the name is a valid swift name for \p D, false otherwise. 2066 bool DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, 2067 const ParsedAttr &AL, bool IsAsync); 2068 2069 /// A derivative of BoundTypeDiagnoser for which the diagnostic's type 2070 /// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless. 2071 /// For example, a diagnostic with no other parameters would generally have 2072 /// the form "...%select{incomplete|sizeless}0 type %1...". 2073 template <typename... Ts> 2074 class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> { 2075 public: SizelessTypeDiagnoser(unsigned DiagID,const Ts &...Args)2076 SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args) 2077 : BoundTypeDiagnoser<Ts...>(DiagID, Args...) {} 2078 diagnose(Sema & S,SourceLocation Loc,QualType T)2079 void diagnose(Sema &S, SourceLocation Loc, QualType T) override { 2080 const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID); 2081 this->emit(DB, std::index_sequence_for<Ts...>()); 2082 DB << T->isSizelessType() << T; 2083 } 2084 }; 2085 2086 enum class CompleteTypeKind { 2087 /// Apply the normal rules for complete types. In particular, 2088 /// treat all sizeless types as incomplete. 2089 Normal, 2090 2091 /// Relax the normal rules for complete types so that they include 2092 /// sizeless built-in types. 2093 AcceptSizeless, 2094 2095 // FIXME: Eventually we should flip the default to Normal and opt in 2096 // to AcceptSizeless rather than opt out of it. 2097 Default = AcceptSizeless 2098 }; 2099 2100 private: 2101 /// Methods for marking which expressions involve dereferencing a pointer 2102 /// marked with the 'noderef' attribute. Expressions are checked bottom up as 2103 /// they are parsed, meaning that a noderef pointer may not be accessed. For 2104 /// example, in `&*p` where `p` is a noderef pointer, we will first parse the 2105 /// `*p`, but need to check that `address of` is called on it. This requires 2106 /// keeping a container of all pending expressions and checking if the address 2107 /// of them are eventually taken. 2108 void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E); 2109 void CheckAddressOfNoDeref(const Expr *E); 2110 void CheckMemberAccessOfNoDeref(const MemberExpr *E); 2111 2112 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T, 2113 CompleteTypeKind Kind, TypeDiagnoser *Diagnoser); 2114 2115 struct ModuleScope { 2116 SourceLocation BeginLoc; 2117 clang::Module *Module = nullptr; 2118 bool ModuleInterface = false; 2119 bool ImplicitGlobalModuleFragment = false; 2120 VisibleModuleSet OuterVisibleModules; 2121 }; 2122 /// The modules we're currently parsing. 2123 llvm::SmallVector<ModuleScope, 16> ModuleScopes; 2124 2125 /// Namespace definitions that we will export when they finish. 2126 llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces; 2127 2128 /// Get the module whose scope we are currently within. getCurrentModule()2129 Module *getCurrentModule() const { 2130 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module; 2131 } 2132 2133 VisibleModuleSet VisibleModules; 2134 2135 public: 2136 /// Get the module owning an entity. getOwningModule(const Decl * Entity)2137 Module *getOwningModule(const Decl *Entity) { 2138 return Entity->getOwningModule(); 2139 } 2140 2141 /// Make a merged definition of an existing hidden definition \p ND 2142 /// visible at the specified location. 2143 void makeMergedDefinitionVisible(NamedDecl *ND); 2144 2145 bool isModuleVisible(const Module *M, bool ModulePrivate = false); 2146 2147 // When loading a non-modular PCH files, this is used to restore module 2148 // visibility. makeModuleVisible(Module * Mod,SourceLocation ImportLoc)2149 void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) { 2150 VisibleModules.setVisible(Mod, ImportLoc); 2151 } 2152 2153 /// Determine whether a declaration is visible to name lookup. isVisible(const NamedDecl * D)2154 bool isVisible(const NamedDecl *D) { 2155 return D->isUnconditionallyVisible() || isVisibleSlow(D); 2156 } 2157 2158 /// Determine whether any declaration of an entity is visible. 2159 bool 2160 hasVisibleDeclaration(const NamedDecl *D, 2161 llvm::SmallVectorImpl<Module *> *Modules = nullptr) { 2162 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules); 2163 } 2164 bool hasVisibleDeclarationSlow(const NamedDecl *D, 2165 llvm::SmallVectorImpl<Module *> *Modules); 2166 2167 bool hasVisibleMergedDefinition(NamedDecl *Def); 2168 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def); 2169 2170 /// Determine if \p D and \p Suggested have a structurally compatible 2171 /// layout as described in C11 6.2.7/1. 2172 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested); 2173 2174 /// Determine if \p D has a visible definition. If not, suggest a declaration 2175 /// that should be made visible to expose the definition. 2176 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, 2177 bool OnlyNeedComplete = false); hasVisibleDefinition(const NamedDecl * D)2178 bool hasVisibleDefinition(const NamedDecl *D) { 2179 NamedDecl *Hidden; 2180 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden); 2181 } 2182 2183 /// Determine if the template parameter \p D has a visible default argument. 2184 bool 2185 hasVisibleDefaultArgument(const NamedDecl *D, 2186 llvm::SmallVectorImpl<Module *> *Modules = nullptr); 2187 2188 /// Determine if there is a visible declaration of \p D that is an explicit 2189 /// specialization declaration for a specialization of a template. (For a 2190 /// member specialization, use hasVisibleMemberSpecialization.) 2191 bool hasVisibleExplicitSpecialization( 2192 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr); 2193 2194 /// Determine if there is a visible declaration of \p D that is a member 2195 /// specialization declaration (as opposed to an instantiated declaration). 2196 bool hasVisibleMemberSpecialization( 2197 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr); 2198 2199 /// Determine if \p A and \p B are equivalent internal linkage declarations 2200 /// from different modules, and thus an ambiguity error can be downgraded to 2201 /// an extension warning. 2202 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, 2203 const NamedDecl *B); 2204 void diagnoseEquivalentInternalLinkageDeclarations( 2205 SourceLocation Loc, const NamedDecl *D, 2206 ArrayRef<const NamedDecl *> Equiv); 2207 2208 bool isUsualDeallocationFunction(const CXXMethodDecl *FD); 2209 2210 bool isCompleteType(SourceLocation Loc, QualType T, 2211 CompleteTypeKind Kind = CompleteTypeKind::Default) { 2212 return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr); 2213 } 2214 bool RequireCompleteType(SourceLocation Loc, QualType T, 2215 CompleteTypeKind Kind, TypeDiagnoser &Diagnoser); 2216 bool RequireCompleteType(SourceLocation Loc, QualType T, 2217 CompleteTypeKind Kind, unsigned DiagID); 2218 RequireCompleteType(SourceLocation Loc,QualType T,TypeDiagnoser & Diagnoser)2219 bool RequireCompleteType(SourceLocation Loc, QualType T, 2220 TypeDiagnoser &Diagnoser) { 2221 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser); 2222 } RequireCompleteType(SourceLocation Loc,QualType T,unsigned DiagID)2223 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) { 2224 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID); 2225 } 2226 2227 template <typename... Ts> RequireCompleteType(SourceLocation Loc,QualType T,unsigned DiagID,const Ts &...Args)2228 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID, 2229 const Ts &...Args) { 2230 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2231 return RequireCompleteType(Loc, T, Diagnoser); 2232 } 2233 2234 template <typename... Ts> RequireCompleteSizedType(SourceLocation Loc,QualType T,unsigned DiagID,const Ts &...Args)2235 bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, 2236 const Ts &... Args) { 2237 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2238 return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser); 2239 } 2240 2241 /// Get the type of expression E, triggering instantiation to complete the 2242 /// type if necessary -- that is, if the expression refers to a templated 2243 /// static data member of incomplete array type. 2244 /// 2245 /// May still return an incomplete type if instantiation was not possible or 2246 /// if the type is incomplete for a different reason. Use 2247 /// RequireCompleteExprType instead if a diagnostic is expected for an 2248 /// incomplete expression type. 2249 QualType getCompletedType(Expr *E); 2250 2251 void completeExprArrayBound(Expr *E); 2252 bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, 2253 TypeDiagnoser &Diagnoser); 2254 bool RequireCompleteExprType(Expr *E, unsigned DiagID); 2255 2256 template <typename... Ts> RequireCompleteExprType(Expr * E,unsigned DiagID,const Ts &...Args)2257 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) { 2258 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2259 return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser); 2260 } 2261 2262 template <typename... Ts> RequireCompleteSizedExprType(Expr * E,unsigned DiagID,const Ts &...Args)2263 bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID, 2264 const Ts &... Args) { 2265 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2266 return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser); 2267 } 2268 2269 bool RequireLiteralType(SourceLocation Loc, QualType T, 2270 TypeDiagnoser &Diagnoser); 2271 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID); 2272 2273 template <typename... Ts> RequireLiteralType(SourceLocation Loc,QualType T,unsigned DiagID,const Ts &...Args)2274 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID, 2275 const Ts &...Args) { 2276 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2277 return RequireLiteralType(Loc, T, Diagnoser); 2278 } 2279 2280 QualType getElaboratedType(ElaboratedTypeKeyword Keyword, 2281 const CXXScopeSpec &SS, QualType T, 2282 TagDecl *OwnedTagDecl = nullptr); 2283 2284 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc); 2285 /// If AsUnevaluated is false, E is treated as though it were an evaluated 2286 /// context, such as when building a type for decltype(auto). 2287 QualType BuildDecltypeType(Expr *E, SourceLocation Loc, 2288 bool AsUnevaluated = true); 2289 QualType BuildUnaryTransformType(QualType BaseType, 2290 UnaryTransformType::UTTKind UKind, 2291 SourceLocation Loc); 2292 2293 //===--------------------------------------------------------------------===// 2294 // Symbol table / Decl tracking callbacks: SemaDecl.cpp. 2295 // 2296 2297 struct SkipBodyInfo { SkipBodyInfoSkipBodyInfo2298 SkipBodyInfo() 2299 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr), 2300 New(nullptr) {} 2301 bool ShouldSkip; 2302 bool CheckSameAsPrevious; 2303 NamedDecl *Previous; 2304 NamedDecl *New; 2305 }; 2306 2307 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr); 2308 2309 void DiagnoseUseOfUnimplementedSelectors(); 2310 2311 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const; 2312 2313 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 2314 Scope *S, CXXScopeSpec *SS = nullptr, 2315 bool isClassName = false, bool HasTrailingDot = false, 2316 ParsedType ObjectType = nullptr, 2317 bool IsCtorOrDtorName = false, 2318 bool WantNontrivialTypeSourceInfo = false, 2319 bool IsClassTemplateDeductionContext = true, 2320 IdentifierInfo **CorrectedII = nullptr); 2321 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S); 2322 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S); 2323 void DiagnoseUnknownTypeName(IdentifierInfo *&II, 2324 SourceLocation IILoc, 2325 Scope *S, 2326 CXXScopeSpec *SS, 2327 ParsedType &SuggestedType, 2328 bool IsTemplateName = false); 2329 2330 /// Attempt to behave like MSVC in situations where lookup of an unqualified 2331 /// type name has failed in a dependent context. In these situations, we 2332 /// automatically form a DependentTypeName that will retry lookup in a related 2333 /// scope during instantiation. 2334 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, 2335 SourceLocation NameLoc, 2336 bool IsTemplateTypeArg); 2337 2338 /// Describes the result of the name lookup and resolution performed 2339 /// by \c ClassifyName(). 2340 enum NameClassificationKind { 2341 /// This name is not a type or template in this context, but might be 2342 /// something else. 2343 NC_Unknown, 2344 /// Classification failed; an error has been produced. 2345 NC_Error, 2346 /// The name has been typo-corrected to a keyword. 2347 NC_Keyword, 2348 /// The name was classified as a type. 2349 NC_Type, 2350 /// The name was classified as a specific non-type, non-template 2351 /// declaration. ActOnNameClassifiedAsNonType should be called to 2352 /// convert the declaration to an expression. 2353 NC_NonType, 2354 /// The name was classified as an ADL-only function name. 2355 /// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the 2356 /// result to an expression. 2357 NC_UndeclaredNonType, 2358 /// The name denotes a member of a dependent type that could not be 2359 /// resolved. ActOnNameClassifiedAsDependentNonType should be called to 2360 /// convert the result to an expression. 2361 NC_DependentNonType, 2362 /// The name was classified as an overload set, and an expression 2363 /// representing that overload set has been formed. 2364 /// ActOnNameClassifiedAsOverloadSet should be called to form a suitable 2365 /// expression referencing the overload set. 2366 NC_OverloadSet, 2367 /// The name was classified as a template whose specializations are types. 2368 NC_TypeTemplate, 2369 /// The name was classified as a variable template name. 2370 NC_VarTemplate, 2371 /// The name was classified as a function template name. 2372 NC_FunctionTemplate, 2373 /// The name was classified as an ADL-only function template name. 2374 NC_UndeclaredTemplate, 2375 /// The name was classified as a concept name. 2376 NC_Concept, 2377 }; 2378 2379 class NameClassification { 2380 NameClassificationKind Kind; 2381 union { 2382 ExprResult Expr; 2383 NamedDecl *NonTypeDecl; 2384 TemplateName Template; 2385 ParsedType Type; 2386 }; 2387 NameClassification(NameClassificationKind Kind)2388 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {} 2389 2390 public: NameClassification(ParsedType Type)2391 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {} 2392 NameClassification(const IdentifierInfo * Keyword)2393 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {} 2394 Error()2395 static NameClassification Error() { 2396 return NameClassification(NC_Error); 2397 } 2398 Unknown()2399 static NameClassification Unknown() { 2400 return NameClassification(NC_Unknown); 2401 } 2402 OverloadSet(ExprResult E)2403 static NameClassification OverloadSet(ExprResult E) { 2404 NameClassification Result(NC_OverloadSet); 2405 Result.Expr = E; 2406 return Result; 2407 } 2408 NonType(NamedDecl * D)2409 static NameClassification NonType(NamedDecl *D) { 2410 NameClassification Result(NC_NonType); 2411 Result.NonTypeDecl = D; 2412 return Result; 2413 } 2414 UndeclaredNonType()2415 static NameClassification UndeclaredNonType() { 2416 return NameClassification(NC_UndeclaredNonType); 2417 } 2418 DependentNonType()2419 static NameClassification DependentNonType() { 2420 return NameClassification(NC_DependentNonType); 2421 } 2422 TypeTemplate(TemplateName Name)2423 static NameClassification TypeTemplate(TemplateName Name) { 2424 NameClassification Result(NC_TypeTemplate); 2425 Result.Template = Name; 2426 return Result; 2427 } 2428 VarTemplate(TemplateName Name)2429 static NameClassification VarTemplate(TemplateName Name) { 2430 NameClassification Result(NC_VarTemplate); 2431 Result.Template = Name; 2432 return Result; 2433 } 2434 FunctionTemplate(TemplateName Name)2435 static NameClassification FunctionTemplate(TemplateName Name) { 2436 NameClassification Result(NC_FunctionTemplate); 2437 Result.Template = Name; 2438 return Result; 2439 } 2440 Concept(TemplateName Name)2441 static NameClassification Concept(TemplateName Name) { 2442 NameClassification Result(NC_Concept); 2443 Result.Template = Name; 2444 return Result; 2445 } 2446 UndeclaredTemplate(TemplateName Name)2447 static NameClassification UndeclaredTemplate(TemplateName Name) { 2448 NameClassification Result(NC_UndeclaredTemplate); 2449 Result.Template = Name; 2450 return Result; 2451 } 2452 getKind()2453 NameClassificationKind getKind() const { return Kind; } 2454 getExpression()2455 ExprResult getExpression() const { 2456 assert(Kind == NC_OverloadSet); 2457 return Expr; 2458 } 2459 getType()2460 ParsedType getType() const { 2461 assert(Kind == NC_Type); 2462 return Type; 2463 } 2464 getNonTypeDecl()2465 NamedDecl *getNonTypeDecl() const { 2466 assert(Kind == NC_NonType); 2467 return NonTypeDecl; 2468 } 2469 getTemplateName()2470 TemplateName getTemplateName() const { 2471 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || 2472 Kind == NC_VarTemplate || Kind == NC_Concept || 2473 Kind == NC_UndeclaredTemplate); 2474 return Template; 2475 } 2476 getTemplateNameKind()2477 TemplateNameKind getTemplateNameKind() const { 2478 switch (Kind) { 2479 case NC_TypeTemplate: 2480 return TNK_Type_template; 2481 case NC_FunctionTemplate: 2482 return TNK_Function_template; 2483 case NC_VarTemplate: 2484 return TNK_Var_template; 2485 case NC_Concept: 2486 return TNK_Concept_template; 2487 case NC_UndeclaredTemplate: 2488 return TNK_Undeclared_template; 2489 default: 2490 llvm_unreachable("unsupported name classification."); 2491 } 2492 } 2493 }; 2494 2495 /// Perform name lookup on the given name, classifying it based on 2496 /// the results of name lookup and the following token. 2497 /// 2498 /// This routine is used by the parser to resolve identifiers and help direct 2499 /// parsing. When the identifier cannot be found, this routine will attempt 2500 /// to correct the typo and classify based on the resulting name. 2501 /// 2502 /// \param S The scope in which we're performing name lookup. 2503 /// 2504 /// \param SS The nested-name-specifier that precedes the name. 2505 /// 2506 /// \param Name The identifier. If typo correction finds an alternative name, 2507 /// this pointer parameter will be updated accordingly. 2508 /// 2509 /// \param NameLoc The location of the identifier. 2510 /// 2511 /// \param NextToken The token following the identifier. Used to help 2512 /// disambiguate the name. 2513 /// 2514 /// \param CCC The correction callback, if typo correction is desired. 2515 NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, 2516 IdentifierInfo *&Name, SourceLocation NameLoc, 2517 const Token &NextToken, 2518 CorrectionCandidateCallback *CCC = nullptr); 2519 2520 /// Act on the result of classifying a name as an undeclared (ADL-only) 2521 /// non-type declaration. 2522 ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, 2523 SourceLocation NameLoc); 2524 /// Act on the result of classifying a name as an undeclared member of a 2525 /// dependent base class. 2526 ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, 2527 IdentifierInfo *Name, 2528 SourceLocation NameLoc, 2529 bool IsAddressOfOperand); 2530 /// Act on the result of classifying a name as a specific non-type 2531 /// declaration. 2532 ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, 2533 NamedDecl *Found, 2534 SourceLocation NameLoc, 2535 const Token &NextToken); 2536 /// Act on the result of classifying a name as an overload set. 2537 ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet); 2538 2539 /// Describes the detailed kind of a template name. Used in diagnostics. 2540 enum class TemplateNameKindForDiagnostics { 2541 ClassTemplate, 2542 FunctionTemplate, 2543 VarTemplate, 2544 AliasTemplate, 2545 TemplateTemplateParam, 2546 Concept, 2547 DependentTemplate 2548 }; 2549 TemplateNameKindForDiagnostics 2550 getTemplateNameKindForDiagnostics(TemplateName Name); 2551 2552 /// Determine whether it's plausible that E was intended to be a 2553 /// template-name. mightBeIntendedToBeTemplateName(ExprResult E,bool & Dependent)2554 bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) { 2555 if (!getLangOpts().CPlusPlus || E.isInvalid()) 2556 return false; 2557 Dependent = false; 2558 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get())) 2559 return !DRE->hasExplicitTemplateArgs(); 2560 if (auto *ME = dyn_cast<MemberExpr>(E.get())) 2561 return !ME->hasExplicitTemplateArgs(); 2562 Dependent = true; 2563 if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get())) 2564 return !DSDRE->hasExplicitTemplateArgs(); 2565 if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get())) 2566 return !DSME->hasExplicitTemplateArgs(); 2567 // Any additional cases recognized here should also be handled by 2568 // diagnoseExprIntendedAsTemplateName. 2569 return false; 2570 } 2571 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, 2572 SourceLocation Less, 2573 SourceLocation Greater); 2574 2575 Decl *ActOnDeclarator(Scope *S, Declarator &D); 2576 2577 NamedDecl *HandleDeclarator(Scope *S, Declarator &D, 2578 MultiTemplateParamsArg TemplateParameterLists); 2579 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S); 2580 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info); 2581 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 2582 DeclarationName Name, SourceLocation Loc, 2583 bool IsTemplateId); 2584 void 2585 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, 2586 SourceLocation FallbackLoc, 2587 SourceLocation ConstQualLoc = SourceLocation(), 2588 SourceLocation VolatileQualLoc = SourceLocation(), 2589 SourceLocation RestrictQualLoc = SourceLocation(), 2590 SourceLocation AtomicQualLoc = SourceLocation(), 2591 SourceLocation UnalignedQualLoc = SourceLocation()); 2592 2593 static bool adjustContextForLocalExternDecl(DeclContext *&DC); 2594 void DiagnoseFunctionSpecifiers(const DeclSpec &DS); 2595 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D, 2596 const LookupResult &R); 2597 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R); 2598 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, 2599 const LookupResult &R); 2600 void CheckShadow(Scope *S, VarDecl *D); 2601 2602 /// Warn if 'E', which is an expression that is about to be modified, refers 2603 /// to a shadowing declaration. 2604 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc); 2605 2606 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI); 2607 2608 private: 2609 /// Map of current shadowing declarations to shadowed declarations. Warn if 2610 /// it looks like the user is trying to modify the shadowing declaration. 2611 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls; 2612 2613 public: 2614 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange); 2615 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope); 2616 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, 2617 TypedefNameDecl *NewTD); 2618 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D); 2619 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 2620 TypeSourceInfo *TInfo, 2621 LookupResult &Previous); 2622 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D, 2623 LookupResult &Previous, bool &Redeclaration); 2624 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 2625 TypeSourceInfo *TInfo, 2626 LookupResult &Previous, 2627 MultiTemplateParamsArg TemplateParamLists, 2628 bool &AddToScope, 2629 ArrayRef<BindingDecl *> Bindings = None); 2630 NamedDecl * 2631 ActOnDecompositionDeclarator(Scope *S, Declarator &D, 2632 MultiTemplateParamsArg TemplateParamLists); 2633 // Returns true if the variable declaration is a redeclaration 2634 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous); 2635 void CheckVariableDeclarationType(VarDecl *NewVD); 2636 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, 2637 Expr *Init); 2638 void CheckCompleteVariableDeclaration(VarDecl *VD); 2639 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD); 2640 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D); 2641 2642 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC, 2643 TypeSourceInfo *TInfo, 2644 LookupResult &Previous, 2645 MultiTemplateParamsArg TemplateParamLists, 2646 bool &AddToScope); 2647 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD); 2648 2649 enum class CheckConstexprKind { 2650 /// Diagnose issues that are non-constant or that are extensions. 2651 Diagnose, 2652 /// Identify whether this function satisfies the formal rules for constexpr 2653 /// functions in the current lanugage mode (with no extensions). 2654 CheckValid 2655 }; 2656 2657 bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, 2658 CheckConstexprKind Kind); 2659 2660 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD); 2661 void FindHiddenVirtualMethods(CXXMethodDecl *MD, 2662 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods); 2663 void NoteHiddenVirtualMethods(CXXMethodDecl *MD, 2664 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods); 2665 // Returns true if the function declaration is a redeclaration 2666 bool CheckFunctionDeclaration(Scope *S, 2667 FunctionDecl *NewFD, LookupResult &Previous, 2668 bool IsMemberSpecialization); 2669 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl); 2670 bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, 2671 QualType NewT, QualType OldT); 2672 void CheckMain(FunctionDecl *FD, const DeclSpec &D); 2673 void CheckMSVCRTEntryPoint(FunctionDecl *FD); 2674 Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, 2675 bool IsDefinition); 2676 void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D); 2677 Decl *ActOnParamDeclarator(Scope *S, Declarator &D); 2678 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC, 2679 SourceLocation Loc, 2680 QualType T); 2681 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc, 2682 SourceLocation NameLoc, IdentifierInfo *Name, 2683 QualType T, TypeSourceInfo *TSInfo, 2684 StorageClass SC); 2685 void ActOnParamDefaultArgument(Decl *param, 2686 SourceLocation EqualLoc, 2687 Expr *defarg); 2688 void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, 2689 SourceLocation ArgLoc); 2690 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc); 2691 ExprResult ConvertParamDefaultArgument(const ParmVarDecl *Param, 2692 Expr *DefaultArg, 2693 SourceLocation EqualLoc); 2694 void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, 2695 SourceLocation EqualLoc); 2696 2697 // Contexts where using non-trivial C union types can be disallowed. This is 2698 // passed to err_non_trivial_c_union_in_invalid_context. 2699 enum NonTrivialCUnionContext { 2700 // Function parameter. 2701 NTCUC_FunctionParam, 2702 // Function return. 2703 NTCUC_FunctionReturn, 2704 // Default-initialized object. 2705 NTCUC_DefaultInitializedObject, 2706 // Variable with automatic storage duration. 2707 NTCUC_AutoVar, 2708 // Initializer expression that might copy from another object. 2709 NTCUC_CopyInit, 2710 // Assignment. 2711 NTCUC_Assignment, 2712 // Compound literal. 2713 NTCUC_CompoundLiteral, 2714 // Block capture. 2715 NTCUC_BlockCapture, 2716 // lvalue-to-rvalue conversion of volatile type. 2717 NTCUC_LValueToRValueVolatile, 2718 }; 2719 2720 /// Emit diagnostics if the initializer or any of its explicit or 2721 /// implicitly-generated subexpressions require copying or 2722 /// default-initializing a type that is or contains a C union type that is 2723 /// non-trivial to copy or default-initialize. 2724 void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc); 2725 2726 // These flags are passed to checkNonTrivialCUnion. 2727 enum NonTrivialCUnionKind { 2728 NTCUK_Init = 0x1, 2729 NTCUK_Destruct = 0x2, 2730 NTCUK_Copy = 0x4, 2731 }; 2732 2733 /// Emit diagnostics if a non-trivial C union type or a struct that contains 2734 /// a non-trivial C union is used in an invalid context. 2735 void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, 2736 NonTrivialCUnionContext UseContext, 2737 unsigned NonTrivialKind); 2738 2739 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit); 2740 void ActOnUninitializedDecl(Decl *dcl); 2741 void ActOnInitializerError(Decl *Dcl); 2742 2743 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc); 2744 void ActOnCXXForRangeDecl(Decl *D); 2745 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, 2746 IdentifierInfo *Ident, 2747 ParsedAttributes &Attrs, 2748 SourceLocation AttrEnd); 2749 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc); 2750 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc); 2751 void CheckStaticLocalForDllExport(VarDecl *VD); 2752 void FinalizeDeclaration(Decl *D); 2753 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 2754 ArrayRef<Decl *> Group); 2755 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group); 2756 2757 /// Should be called on all declarations that might have attached 2758 /// documentation comments. 2759 void ActOnDocumentableDecl(Decl *D); 2760 void ActOnDocumentableDecls(ArrayRef<Decl *> Group); 2761 2762 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 2763 SourceLocation LocAfterDecls); 2764 void CheckForFunctionRedefinition( 2765 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr, 2766 SkipBodyInfo *SkipBody = nullptr); 2767 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D, 2768 MultiTemplateParamsArg TemplateParamLists, 2769 SkipBodyInfo *SkipBody = nullptr); 2770 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D, 2771 SkipBodyInfo *SkipBody = nullptr); 2772 void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D); 2773 ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr); 2774 ExprResult ActOnRequiresClause(ExprResult ConstraintExpr); 2775 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D); isObjCMethodDecl(Decl * D)2776 bool isObjCMethodDecl(Decl *D) { 2777 return D && isa<ObjCMethodDecl>(D); 2778 } 2779 2780 /// Determine whether we can delay parsing the body of a function or 2781 /// function template until it is used, assuming we don't care about emitting 2782 /// code for that function. 2783 /// 2784 /// This will be \c false if we may need the body of the function in the 2785 /// middle of parsing an expression (where it's impractical to switch to 2786 /// parsing a different function), for instance, if it's constexpr in C++11 2787 /// or has an 'auto' return type in C++14. These cases are essentially bugs. 2788 bool canDelayFunctionBody(const Declarator &D); 2789 2790 /// Determine whether we can skip parsing the body of a function 2791 /// definition, assuming we don't care about analyzing its body or emitting 2792 /// code for that function. 2793 /// 2794 /// This will be \c false only if we may need the body of the function in 2795 /// order to parse the rest of the program (for instance, if it is 2796 /// \c constexpr in C++11 or has an 'auto' return type in C++14). 2797 bool canSkipFunctionBody(Decl *D); 2798 2799 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope); 2800 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body); 2801 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation); 2802 Decl *ActOnSkippedFunctionBody(Decl *Decl); 2803 void ActOnFinishInlineFunctionDef(FunctionDecl *D); 2804 2805 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an 2806 /// attribute for which parsing is delayed. 2807 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs); 2808 2809 /// Diagnose any unused parameters in the given sequence of 2810 /// ParmVarDecl pointers. 2811 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters); 2812 2813 /// Diagnose whether the size of parameters or return value of a 2814 /// function or obj-c method definition is pass-by-value and larger than a 2815 /// specified threshold. 2816 void 2817 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters, 2818 QualType ReturnTy, NamedDecl *D); 2819 2820 void DiagnoseInvalidJumps(Stmt *Body); 2821 Decl *ActOnFileScopeAsmDecl(Expr *expr, 2822 SourceLocation AsmLoc, 2823 SourceLocation RParenLoc); 2824 2825 /// Handle a C++11 empty-declaration and attribute-declaration. 2826 Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, 2827 SourceLocation SemiLoc); 2828 2829 enum class ModuleDeclKind { 2830 Interface, ///< 'export module X;' 2831 Implementation, ///< 'module X;' 2832 }; 2833 2834 /// The parser has processed a module-declaration that begins the definition 2835 /// of a module interface or implementation. 2836 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc, 2837 SourceLocation ModuleLoc, ModuleDeclKind MDK, 2838 ModuleIdPath Path, bool IsFirstDecl); 2839 2840 /// The parser has processed a global-module-fragment declaration that begins 2841 /// the definition of the global module fragment of the current module unit. 2842 /// \param ModuleLoc The location of the 'module' keyword. 2843 DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc); 2844 2845 /// The parser has processed a private-module-fragment declaration that begins 2846 /// the definition of the private module fragment of the current module unit. 2847 /// \param ModuleLoc The location of the 'module' keyword. 2848 /// \param PrivateLoc The location of the 'private' keyword. 2849 DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, 2850 SourceLocation PrivateLoc); 2851 2852 /// The parser has processed a module import declaration. 2853 /// 2854 /// \param StartLoc The location of the first token in the declaration. This 2855 /// could be the location of an '@', 'export', or 'import'. 2856 /// \param ExportLoc The location of the 'export' keyword, if any. 2857 /// \param ImportLoc The location of the 'import' keyword. 2858 /// \param Path The module access path. 2859 DeclResult ActOnModuleImport(SourceLocation StartLoc, 2860 SourceLocation ExportLoc, 2861 SourceLocation ImportLoc, ModuleIdPath Path); 2862 DeclResult ActOnModuleImport(SourceLocation StartLoc, 2863 SourceLocation ExportLoc, 2864 SourceLocation ImportLoc, Module *M, 2865 ModuleIdPath Path = {}); 2866 2867 /// The parser has processed a module import translated from a 2868 /// #include or similar preprocessing directive. 2869 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod); 2870 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod); 2871 2872 /// The parsed has entered a submodule. 2873 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod); 2874 /// The parser has left a submodule. 2875 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod); 2876 2877 /// Create an implicit import of the given module at the given 2878 /// source location, for error recovery, if possible. 2879 /// 2880 /// This routine is typically used when an entity found by name lookup 2881 /// is actually hidden within a module that we know about but the user 2882 /// has forgotten to import. 2883 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, 2884 Module *Mod); 2885 2886 /// Kinds of missing import. Note, the values of these enumerators correspond 2887 /// to %select values in diagnostics. 2888 enum class MissingImportKind { 2889 Declaration, 2890 Definition, 2891 DefaultArgument, 2892 ExplicitSpecialization, 2893 PartialSpecialization 2894 }; 2895 2896 /// Diagnose that the specified declaration needs to be visible but 2897 /// isn't, and suggest a module import that would resolve the problem. 2898 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, 2899 MissingImportKind MIK, bool Recover = true); 2900 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, 2901 SourceLocation DeclLoc, ArrayRef<Module *> Modules, 2902 MissingImportKind MIK, bool Recover); 2903 2904 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, 2905 SourceLocation LBraceLoc); 2906 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl, 2907 SourceLocation RBraceLoc); 2908 2909 /// We've found a use of a templated declaration that would trigger an 2910 /// implicit instantiation. Check that any relevant explicit specializations 2911 /// and partial specializations are visible, and diagnose if not. 2912 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec); 2913 2914 /// Retrieve a suitable printing policy for diagnostics. getPrintingPolicy()2915 PrintingPolicy getPrintingPolicy() const { 2916 return getPrintingPolicy(Context, PP); 2917 } 2918 2919 /// Retrieve a suitable printing policy for diagnostics. 2920 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx, 2921 const Preprocessor &PP); 2922 2923 /// Scope actions. 2924 void ActOnPopScope(SourceLocation Loc, Scope *S); 2925 void ActOnTranslationUnitScope(Scope *S); 2926 2927 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, 2928 RecordDecl *&AnonRecord); 2929 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, 2930 MultiTemplateParamsArg TemplateParams, 2931 bool IsExplicitInstantiation, 2932 RecordDecl *&AnonRecord); 2933 2934 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 2935 AccessSpecifier AS, 2936 RecordDecl *Record, 2937 const PrintingPolicy &Policy); 2938 2939 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 2940 RecordDecl *Record); 2941 2942 /// Common ways to introduce type names without a tag for use in diagnostics. 2943 /// Keep in sync with err_tag_reference_non_tag. 2944 enum NonTagKind { 2945 NTK_NonStruct, 2946 NTK_NonClass, 2947 NTK_NonUnion, 2948 NTK_NonEnum, 2949 NTK_Typedef, 2950 NTK_TypeAlias, 2951 NTK_Template, 2952 NTK_TypeAliasTemplate, 2953 NTK_TemplateTemplateArgument, 2954 }; 2955 2956 /// Given a non-tag type declaration, returns an enum useful for indicating 2957 /// what kind of non-tag type this is. 2958 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK); 2959 2960 bool isAcceptableTagRedeclaration(const TagDecl *Previous, 2961 TagTypeKind NewTag, bool isDefinition, 2962 SourceLocation NewTagLoc, 2963 const IdentifierInfo *Name); 2964 2965 enum TagUseKind { 2966 TUK_Reference, // Reference to a tag: 'struct foo *X;' 2967 TUK_Declaration, // Fwd decl of a tag: 'struct foo;' 2968 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;' 2969 TUK_Friend // Friend declaration: 'friend struct foo;' 2970 }; 2971 2972 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 2973 SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, 2974 SourceLocation NameLoc, const ParsedAttributesView &Attr, 2975 AccessSpecifier AS, SourceLocation ModulePrivateLoc, 2976 MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, 2977 bool &IsDependent, SourceLocation ScopedEnumKWLoc, 2978 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, 2979 bool IsTypeSpecifier, bool IsTemplateParamOrArg, 2980 SkipBodyInfo *SkipBody = nullptr); 2981 2982 Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, 2983 unsigned TagSpec, SourceLocation TagLoc, 2984 CXXScopeSpec &SS, IdentifierInfo *Name, 2985 SourceLocation NameLoc, 2986 const ParsedAttributesView &Attr, 2987 MultiTemplateParamsArg TempParamLists); 2988 2989 TypeResult ActOnDependentTag(Scope *S, 2990 unsigned TagSpec, 2991 TagUseKind TUK, 2992 const CXXScopeSpec &SS, 2993 IdentifierInfo *Name, 2994 SourceLocation TagLoc, 2995 SourceLocation NameLoc); 2996 2997 void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, 2998 IdentifierInfo *ClassName, 2999 SmallVectorImpl<Decl *> &Decls); 3000 Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 3001 Declarator &D, Expr *BitfieldWidth); 3002 3003 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, 3004 Declarator &D, Expr *BitfieldWidth, 3005 InClassInitStyle InitStyle, 3006 AccessSpecifier AS); 3007 MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD, 3008 SourceLocation DeclStart, Declarator &D, 3009 Expr *BitfieldWidth, 3010 InClassInitStyle InitStyle, 3011 AccessSpecifier AS, 3012 const ParsedAttr &MSPropertyAttr); 3013 3014 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T, 3015 TypeSourceInfo *TInfo, 3016 RecordDecl *Record, SourceLocation Loc, 3017 bool Mutable, Expr *BitfieldWidth, 3018 InClassInitStyle InitStyle, 3019 SourceLocation TSSL, 3020 AccessSpecifier AS, NamedDecl *PrevDecl, 3021 Declarator *D = nullptr); 3022 3023 bool CheckNontrivialField(FieldDecl *FD); 3024 void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM); 3025 3026 enum TrivialABIHandling { 3027 /// The triviality of a method unaffected by "trivial_abi". 3028 TAH_IgnoreTrivialABI, 3029 3030 /// The triviality of a method affected by "trivial_abi". 3031 TAH_ConsiderTrivialABI 3032 }; 3033 3034 bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, 3035 TrivialABIHandling TAH = TAH_IgnoreTrivialABI, 3036 bool Diagnose = false); 3037 3038 /// For a defaulted function, the kind of defaulted function that it is. 3039 class DefaultedFunctionKind { 3040 CXXSpecialMember SpecialMember : 8; 3041 DefaultedComparisonKind Comparison : 8; 3042 3043 public: DefaultedFunctionKind()3044 DefaultedFunctionKind() 3045 : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) { 3046 } DefaultedFunctionKind(CXXSpecialMember CSM)3047 DefaultedFunctionKind(CXXSpecialMember CSM) 3048 : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {} DefaultedFunctionKind(DefaultedComparisonKind Comp)3049 DefaultedFunctionKind(DefaultedComparisonKind Comp) 3050 : SpecialMember(CXXInvalid), Comparison(Comp) {} 3051 isSpecialMember()3052 bool isSpecialMember() const { return SpecialMember != CXXInvalid; } isComparison()3053 bool isComparison() const { 3054 return Comparison != DefaultedComparisonKind::None; 3055 } 3056 3057 explicit operator bool() const { 3058 return isSpecialMember() || isComparison(); 3059 } 3060 asSpecialMember()3061 CXXSpecialMember asSpecialMember() const { return SpecialMember; } asComparison()3062 DefaultedComparisonKind asComparison() const { return Comparison; } 3063 3064 /// Get the index of this function kind for use in diagnostics. getDiagnosticIndex()3065 unsigned getDiagnosticIndex() const { 3066 static_assert(CXXInvalid > CXXDestructor, 3067 "invalid should have highest index"); 3068 static_assert((unsigned)DefaultedComparisonKind::None == 0, 3069 "none should be equal to zero"); 3070 return SpecialMember + (unsigned)Comparison; 3071 } 3072 }; 3073 3074 DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD); 3075 getSpecialMember(const CXXMethodDecl * MD)3076 CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) { 3077 return getDefaultedFunctionKind(MD).asSpecialMember(); 3078 } getDefaultedComparisonKind(const FunctionDecl * FD)3079 DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) { 3080 return getDefaultedFunctionKind(FD).asComparison(); 3081 } 3082 3083 void ActOnLastBitfield(SourceLocation DeclStart, 3084 SmallVectorImpl<Decl *> &AllIvarDecls); 3085 Decl *ActOnIvar(Scope *S, SourceLocation DeclStart, 3086 Declarator &D, Expr *BitfieldWidth, 3087 tok::ObjCKeywordKind visibility); 3088 3089 // This is used for both record definitions and ObjC interface declarations. 3090 void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, 3091 ArrayRef<Decl *> Fields, SourceLocation LBrac, 3092 SourceLocation RBrac, const ParsedAttributesView &AttrList); 3093 3094 /// ActOnTagStartDefinition - Invoked when we have entered the 3095 /// scope of a tag's definition (e.g., for an enumeration, class, 3096 /// struct, or union). 3097 void ActOnTagStartDefinition(Scope *S, Decl *TagDecl); 3098 3099 /// Perform ODR-like check for C/ObjC when merging tag types from modules. 3100 /// Differently from C++, actually parse the body and reject / error out 3101 /// in case of a structural mismatch. 3102 bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev, 3103 SkipBodyInfo &SkipBody); 3104 3105 typedef void *SkippedDefinitionContext; 3106 3107 /// Invoked when we enter a tag definition that we're skipping. 3108 SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD); 3109 3110 Decl *ActOnObjCContainerStartDefinition(Decl *IDecl); 3111 3112 /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a 3113 /// C++ record definition's base-specifiers clause and are starting its 3114 /// member declarations. 3115 void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, 3116 SourceLocation FinalLoc, 3117 bool IsFinalSpelledSealed, 3118 SourceLocation LBraceLoc); 3119 3120 /// ActOnTagFinishDefinition - Invoked once we have finished parsing 3121 /// the definition of a tag (enumeration, class, struct, or union). 3122 void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, 3123 SourceRange BraceRange); 3124 3125 void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context); 3126 3127 void ActOnObjCContainerFinishDefinition(); 3128 3129 /// Invoked when we must temporarily exit the objective-c container 3130 /// scope for parsing/looking-up C constructs. 3131 /// 3132 /// Must be followed by a call to \see ActOnObjCReenterContainerContext 3133 void ActOnObjCTemporaryExitContainerContext(DeclContext *DC); 3134 void ActOnObjCReenterContainerContext(DeclContext *DC); 3135 3136 /// ActOnTagDefinitionError - Invoked when there was an unrecoverable 3137 /// error parsing the definition of a tag. 3138 void ActOnTagDefinitionError(Scope *S, Decl *TagDecl); 3139 3140 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum, 3141 EnumConstantDecl *LastEnumConst, 3142 SourceLocation IdLoc, 3143 IdentifierInfo *Id, 3144 Expr *val); 3145 bool CheckEnumUnderlyingType(TypeSourceInfo *TI); 3146 bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 3147 QualType EnumUnderlyingTy, bool IsFixed, 3148 const EnumDecl *Prev); 3149 3150 /// Determine whether the body of an anonymous enumeration should be skipped. 3151 /// \param II The name of the first enumerator. 3152 SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, 3153 SourceLocation IILoc); 3154 3155 Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, 3156 SourceLocation IdLoc, IdentifierInfo *Id, 3157 const ParsedAttributesView &Attrs, 3158 SourceLocation EqualLoc, Expr *Val); 3159 void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, 3160 Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S, 3161 const ParsedAttributesView &Attr); 3162 3163 /// Set the current declaration context until it gets popped. 3164 void PushDeclContext(Scope *S, DeclContext *DC); 3165 void PopDeclContext(); 3166 3167 /// EnterDeclaratorContext - Used when we must lookup names in the context 3168 /// of a declarator's nested name specifier. 3169 void EnterDeclaratorContext(Scope *S, DeclContext *DC); 3170 void ExitDeclaratorContext(Scope *S); 3171 3172 /// Enter a template parameter scope, after it's been associated with a particular 3173 /// DeclContext. Causes lookup within the scope to chain through enclosing contexts 3174 /// in the correct order. 3175 void EnterTemplatedContext(Scope *S, DeclContext *DC); 3176 3177 /// Push the parameters of D, which must be a function, into scope. 3178 void ActOnReenterFunctionContext(Scope* S, Decl* D); 3179 void ActOnExitFunctionContext(); 3180 3181 DeclContext *getFunctionLevelDeclContext(); 3182 3183 /// getCurFunctionDecl - If inside of a function body, this returns a pointer 3184 /// to the function decl for the function being parsed. If we're currently 3185 /// in a 'block', this returns the containing context. 3186 FunctionDecl *getCurFunctionDecl(); 3187 3188 /// getCurMethodDecl - If inside of a method body, this returns a pointer to 3189 /// the method decl for the method being parsed. If we're currently 3190 /// in a 'block', this returns the containing context. 3191 ObjCMethodDecl *getCurMethodDecl(); 3192 3193 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method 3194 /// or C function we're in, otherwise return null. If we're currently 3195 /// in a 'block', this returns the containing context. 3196 NamedDecl *getCurFunctionOrMethodDecl(); 3197 3198 /// Add this decl to the scope shadowed decl chains. 3199 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true); 3200 3201 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true 3202 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns 3203 /// true if 'D' belongs to the given declaration context. 3204 /// 3205 /// \param AllowInlineNamespace If \c true, allow the declaration to be in the 3206 /// enclosing namespace set of the context, rather than contained 3207 /// directly within it. 3208 bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr, 3209 bool AllowInlineNamespace = false); 3210 3211 /// Finds the scope corresponding to the given decl context, if it 3212 /// happens to be an enclosing scope. Otherwise return NULL. 3213 static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC); 3214 3215 /// Subroutines of ActOnDeclarator(). 3216 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 3217 TypeSourceInfo *TInfo); 3218 bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New); 3219 3220 /// Describes the kind of merge to perform for availability 3221 /// attributes (including "deprecated", "unavailable", and "availability"). 3222 enum AvailabilityMergeKind { 3223 /// Don't merge availability attributes at all. 3224 AMK_None, 3225 /// Merge availability attributes for a redeclaration, which requires 3226 /// an exact match. 3227 AMK_Redeclaration, 3228 /// Merge availability attributes for an override, which requires 3229 /// an exact match or a weakening of constraints. 3230 AMK_Override, 3231 /// Merge availability attributes for an implementation of 3232 /// a protocol requirement. 3233 AMK_ProtocolImplementation, 3234 }; 3235 3236 /// Describes the kind of priority given to an availability attribute. 3237 /// 3238 /// The sum of priorities deteremines the final priority of the attribute. 3239 /// The final priority determines how the attribute will be merged. 3240 /// An attribute with a lower priority will always remove higher priority 3241 /// attributes for the specified platform when it is being applied. An 3242 /// attribute with a higher priority will not be applied if the declaration 3243 /// already has an availability attribute with a lower priority for the 3244 /// specified platform. The final prirority values are not expected to match 3245 /// the values in this enumeration, but instead should be treated as a plain 3246 /// integer value. This enumeration just names the priority weights that are 3247 /// used to calculate that final vaue. 3248 enum AvailabilityPriority : int { 3249 /// The availability attribute was specified explicitly next to the 3250 /// declaration. 3251 AP_Explicit = 0, 3252 3253 /// The availability attribute was applied using '#pragma clang attribute'. 3254 AP_PragmaClangAttribute = 1, 3255 3256 /// The availability attribute for a specific platform was inferred from 3257 /// an availability attribute for another platform. 3258 AP_InferredFromOtherPlatform = 2 3259 }; 3260 3261 /// Attribute merging methods. Return true if a new attribute was added. 3262 AvailabilityAttr * 3263 mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, 3264 IdentifierInfo *Platform, bool Implicit, 3265 VersionTuple Introduced, VersionTuple Deprecated, 3266 VersionTuple Obsoleted, bool IsUnavailable, 3267 StringRef Message, bool IsStrict, StringRef Replacement, 3268 AvailabilityMergeKind AMK, int Priority); 3269 TypeVisibilityAttr * 3270 mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, 3271 TypeVisibilityAttr::VisibilityType Vis); 3272 VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, 3273 VisibilityAttr::VisibilityType Vis); 3274 UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, 3275 StringRef UuidAsWritten, MSGuidDecl *GuidDecl); 3276 DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI); 3277 DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI); 3278 MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D, 3279 const AttributeCommonInfo &CI, 3280 bool BestCase, 3281 MSInheritanceModel Model); 3282 FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, 3283 IdentifierInfo *Format, int FormatIdx, 3284 int FirstArg); 3285 SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, 3286 StringRef Name); 3287 CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, 3288 StringRef Name); 3289 AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D, 3290 const AttributeCommonInfo &CI, 3291 const IdentifierInfo *Ident); 3292 MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI); 3293 NoSpeculativeLoadHardeningAttr * 3294 mergeNoSpeculativeLoadHardeningAttr(Decl *D, 3295 const NoSpeculativeLoadHardeningAttr &AL); 3296 SpeculativeLoadHardeningAttr * 3297 mergeSpeculativeLoadHardeningAttr(Decl *D, 3298 const SpeculativeLoadHardeningAttr &AL); 3299 SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, 3300 StringRef Name); 3301 OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D, 3302 const AttributeCommonInfo &CI); 3303 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL); 3304 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, 3305 const InternalLinkageAttr &AL); 3306 CommonAttr *mergeCommonAttr(Decl *D, const ParsedAttr &AL); 3307 CommonAttr *mergeCommonAttr(Decl *D, const CommonAttr &AL); 3308 WebAssemblyImportNameAttr *mergeImportNameAttr( 3309 Decl *D, const WebAssemblyImportNameAttr &AL); 3310 WebAssemblyImportModuleAttr *mergeImportModuleAttr( 3311 Decl *D, const WebAssemblyImportModuleAttr &AL); 3312 EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL); 3313 EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D, 3314 const EnforceTCBLeafAttr &AL); 3315 3316 void mergeDeclAttributes(NamedDecl *New, Decl *Old, 3317 AvailabilityMergeKind AMK = AMK_Redeclaration); 3318 void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, 3319 LookupResult &OldDecls); 3320 bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, 3321 bool MergeTypeWithOld); 3322 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 3323 Scope *S, bool MergeTypeWithOld); 3324 void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old); 3325 void MergeVarDecl(VarDecl *New, LookupResult &Previous); 3326 void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld); 3327 void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old); 3328 bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn); 3329 void notePreviousDefinition(const NamedDecl *Old, SourceLocation New); 3330 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S); 3331 3332 // AssignmentAction - This is used by all the assignment diagnostic functions 3333 // to represent what is actually causing the operation 3334 enum AssignmentAction { 3335 AA_Assigning, 3336 AA_Passing, 3337 AA_Returning, 3338 AA_Converting, 3339 AA_Initializing, 3340 AA_Sending, 3341 AA_Casting, 3342 AA_Passing_CFAudited 3343 }; 3344 3345 /// C++ Overloading. 3346 enum OverloadKind { 3347 /// This is a legitimate overload: the existing declarations are 3348 /// functions or function templates with different signatures. 3349 Ovl_Overload, 3350 3351 /// This is not an overload because the signature exactly matches 3352 /// an existing declaration. 3353 Ovl_Match, 3354 3355 /// This is not an overload because the lookup results contain a 3356 /// non-function. 3357 Ovl_NonFunction 3358 }; 3359 OverloadKind CheckOverload(Scope *S, 3360 FunctionDecl *New, 3361 const LookupResult &OldDecls, 3362 NamedDecl *&OldDecl, 3363 bool IsForUsingDecl); 3364 bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, 3365 bool ConsiderCudaAttrs = true, 3366 bool ConsiderRequiresClauses = true); 3367 3368 enum class AllowedExplicit { 3369 /// Allow no explicit functions to be used. 3370 None, 3371 /// Allow explicit conversion functions but not explicit constructors. 3372 Conversions, 3373 /// Allow both explicit conversion functions and explicit constructors. 3374 All 3375 }; 3376 3377 ImplicitConversionSequence 3378 TryImplicitConversion(Expr *From, QualType ToType, 3379 bool SuppressUserConversions, 3380 AllowedExplicit AllowExplicit, 3381 bool InOverloadResolution, 3382 bool CStyle, 3383 bool AllowObjCWritebackConversion); 3384 3385 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType); 3386 bool IsFloatingPointPromotion(QualType FromType, QualType ToType); 3387 bool IsComplexPromotion(QualType FromType, QualType ToType); 3388 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType, 3389 bool InOverloadResolution, 3390 QualType& ConvertedType, bool &IncompatibleObjC); 3391 bool isObjCPointerConversion(QualType FromType, QualType ToType, 3392 QualType& ConvertedType, bool &IncompatibleObjC); 3393 bool isObjCWritebackConversion(QualType FromType, QualType ToType, 3394 QualType &ConvertedType); 3395 bool IsBlockPointerConversion(QualType FromType, QualType ToType, 3396 QualType& ConvertedType); 3397 bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType, 3398 const FunctionProtoType *NewType, 3399 unsigned *ArgPos = nullptr); 3400 void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, 3401 QualType FromType, QualType ToType); 3402 3403 void maybeExtendBlockObject(ExprResult &E); 3404 CastKind PrepareCastToObjCObjectPointer(ExprResult &E); 3405 bool CheckPointerConversion(Expr *From, QualType ToType, 3406 CastKind &Kind, 3407 CXXCastPath& BasePath, 3408 bool IgnoreBaseAccess, 3409 bool Diagnose = true); 3410 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType, 3411 bool InOverloadResolution, 3412 QualType &ConvertedType); 3413 bool CheckMemberPointerConversion(Expr *From, QualType ToType, 3414 CastKind &Kind, 3415 CXXCastPath &BasePath, 3416 bool IgnoreBaseAccess); 3417 bool IsQualificationConversion(QualType FromType, QualType ToType, 3418 bool CStyle, bool &ObjCLifetimeConversion); 3419 bool IsFunctionConversion(QualType FromType, QualType ToType, 3420 QualType &ResultTy); 3421 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType); 3422 bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg); 3423 3424 ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, 3425 const VarDecl *NRVOCandidate, 3426 QualType ResultType, 3427 Expr *Value, 3428 bool AllowNRVO = true); 3429 3430 bool CanPerformAggregateInitializationForOverloadResolution( 3431 const InitializedEntity &Entity, InitListExpr *From); 3432 3433 bool IsStringInit(Expr *Init, const ArrayType *AT); 3434 3435 bool CanPerformCopyInitialization(const InitializedEntity &Entity, 3436 ExprResult Init); 3437 ExprResult PerformCopyInitialization(const InitializedEntity &Entity, 3438 SourceLocation EqualLoc, 3439 ExprResult Init, 3440 bool TopLevelOfInitList = false, 3441 bool AllowExplicit = false); 3442 ExprResult PerformObjectArgumentInitialization(Expr *From, 3443 NestedNameSpecifier *Qualifier, 3444 NamedDecl *FoundDecl, 3445 CXXMethodDecl *Method); 3446 3447 /// Check that the lifetime of the initializer (and its subobjects) is 3448 /// sufficient for initializing the entity, and perform lifetime extension 3449 /// (when permitted) if not. 3450 void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init); 3451 3452 ExprResult PerformContextuallyConvertToBool(Expr *From); 3453 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From); 3454 3455 /// Contexts in which a converted constant expression is required. 3456 enum CCEKind { 3457 CCEK_CaseValue, ///< Expression in a case label. 3458 CCEK_Enumerator, ///< Enumerator value with fixed underlying type. 3459 CCEK_TemplateArg, ///< Value of a non-type template parameter. 3460 CCEK_ArrayBound, ///< Array bound in array declarator or new-expression. 3461 CCEK_ConstexprIf, ///< Condition in a constexpr if statement. 3462 CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier. 3463 }; 3464 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, 3465 llvm::APSInt &Value, CCEKind CCE); 3466 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, 3467 APValue &Value, CCEKind CCE, 3468 NamedDecl *Dest = nullptr); 3469 3470 /// Abstract base class used to perform a contextual implicit 3471 /// conversion from an expression to any type passing a filter. 3472 class ContextualImplicitConverter { 3473 public: 3474 bool Suppress; 3475 bool SuppressConversion; 3476 3477 ContextualImplicitConverter(bool Suppress = false, 3478 bool SuppressConversion = false) Suppress(Suppress)3479 : Suppress(Suppress), SuppressConversion(SuppressConversion) {} 3480 3481 /// Determine whether the specified type is a valid destination type 3482 /// for this conversion. 3483 virtual bool match(QualType T) = 0; 3484 3485 /// Emits a diagnostic complaining that the expression does not have 3486 /// integral or enumeration type. 3487 virtual SemaDiagnosticBuilder 3488 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0; 3489 3490 /// Emits a diagnostic when the expression has incomplete class type. 3491 virtual SemaDiagnosticBuilder 3492 diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0; 3493 3494 /// Emits a diagnostic when the only matching conversion function 3495 /// is explicit. 3496 virtual SemaDiagnosticBuilder diagnoseExplicitConv( 3497 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0; 3498 3499 /// Emits a note for the explicit conversion function. 3500 virtual SemaDiagnosticBuilder 3501 noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0; 3502 3503 /// Emits a diagnostic when there are multiple possible conversion 3504 /// functions. 3505 virtual SemaDiagnosticBuilder 3506 diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0; 3507 3508 /// Emits a note for one of the candidate conversions. 3509 virtual SemaDiagnosticBuilder 3510 noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0; 3511 3512 /// Emits a diagnostic when we picked a conversion function 3513 /// (for cases when we are not allowed to pick a conversion function). 3514 virtual SemaDiagnosticBuilder diagnoseConversion( 3515 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0; 3516 ~ContextualImplicitConverter()3517 virtual ~ContextualImplicitConverter() {} 3518 }; 3519 3520 class ICEConvertDiagnoser : public ContextualImplicitConverter { 3521 bool AllowScopedEnumerations; 3522 3523 public: ICEConvertDiagnoser(bool AllowScopedEnumerations,bool Suppress,bool SuppressConversion)3524 ICEConvertDiagnoser(bool AllowScopedEnumerations, 3525 bool Suppress, bool SuppressConversion) 3526 : ContextualImplicitConverter(Suppress, SuppressConversion), 3527 AllowScopedEnumerations(AllowScopedEnumerations) {} 3528 3529 /// Match an integral or (possibly scoped) enumeration type. 3530 bool match(QualType T) override; 3531 3532 SemaDiagnosticBuilder diagnoseNoMatch(Sema & S,SourceLocation Loc,QualType T)3533 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override { 3534 return diagnoseNotInt(S, Loc, T); 3535 } 3536 3537 /// Emits a diagnostic complaining that the expression does not have 3538 /// integral or enumeration type. 3539 virtual SemaDiagnosticBuilder 3540 diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0; 3541 }; 3542 3543 /// Perform a contextual implicit conversion. 3544 ExprResult PerformContextualImplicitConversion( 3545 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter); 3546 3547 3548 enum ObjCSubscriptKind { 3549 OS_Array, 3550 OS_Dictionary, 3551 OS_Error 3552 }; 3553 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE); 3554 3555 // Note that LK_String is intentionally after the other literals, as 3556 // this is used for diagnostics logic. 3557 enum ObjCLiteralKind { 3558 LK_Array, 3559 LK_Dictionary, 3560 LK_Numeric, 3561 LK_Boxed, 3562 LK_String, 3563 LK_Block, 3564 LK_None 3565 }; 3566 ObjCLiteralKind CheckLiteralKind(Expr *FromE); 3567 3568 ExprResult PerformObjectMemberConversion(Expr *From, 3569 NestedNameSpecifier *Qualifier, 3570 NamedDecl *FoundDecl, 3571 NamedDecl *Member); 3572 3573 // Members have to be NamespaceDecl* or TranslationUnitDecl*. 3574 // TODO: make this is a typesafe union. 3575 typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet; 3576 typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet; 3577 3578 using ADLCallKind = CallExpr::ADLCallKind; 3579 3580 void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, 3581 ArrayRef<Expr *> Args, 3582 OverloadCandidateSet &CandidateSet, 3583 bool SuppressUserConversions = false, 3584 bool PartialOverloading = false, 3585 bool AllowExplicit = true, 3586 bool AllowExplicitConversion = false, 3587 ADLCallKind IsADLCandidate = ADLCallKind::NotADL, 3588 ConversionSequenceList EarlyConversions = None, 3589 OverloadCandidateParamOrder PO = {}); 3590 void AddFunctionCandidates(const UnresolvedSetImpl &Functions, 3591 ArrayRef<Expr *> Args, 3592 OverloadCandidateSet &CandidateSet, 3593 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr, 3594 bool SuppressUserConversions = false, 3595 bool PartialOverloading = false, 3596 bool FirstArgumentIsBase = false); 3597 void AddMethodCandidate(DeclAccessPair FoundDecl, 3598 QualType ObjectType, 3599 Expr::Classification ObjectClassification, 3600 ArrayRef<Expr *> Args, 3601 OverloadCandidateSet& CandidateSet, 3602 bool SuppressUserConversion = false, 3603 OverloadCandidateParamOrder PO = {}); 3604 void AddMethodCandidate(CXXMethodDecl *Method, 3605 DeclAccessPair FoundDecl, 3606 CXXRecordDecl *ActingContext, QualType ObjectType, 3607 Expr::Classification ObjectClassification, 3608 ArrayRef<Expr *> Args, 3609 OverloadCandidateSet& CandidateSet, 3610 bool SuppressUserConversions = false, 3611 bool PartialOverloading = false, 3612 ConversionSequenceList EarlyConversions = None, 3613 OverloadCandidateParamOrder PO = {}); 3614 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, 3615 DeclAccessPair FoundDecl, 3616 CXXRecordDecl *ActingContext, 3617 TemplateArgumentListInfo *ExplicitTemplateArgs, 3618 QualType ObjectType, 3619 Expr::Classification ObjectClassification, 3620 ArrayRef<Expr *> Args, 3621 OverloadCandidateSet& CandidateSet, 3622 bool SuppressUserConversions = false, 3623 bool PartialOverloading = false, 3624 OverloadCandidateParamOrder PO = {}); 3625 void AddTemplateOverloadCandidate( 3626 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, 3627 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, 3628 OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false, 3629 bool PartialOverloading = false, bool AllowExplicit = true, 3630 ADLCallKind IsADLCandidate = ADLCallKind::NotADL, 3631 OverloadCandidateParamOrder PO = {}); 3632 bool CheckNonDependentConversions( 3633 FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes, 3634 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet, 3635 ConversionSequenceList &Conversions, bool SuppressUserConversions, 3636 CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(), 3637 Expr::Classification ObjectClassification = {}, 3638 OverloadCandidateParamOrder PO = {}); 3639 void AddConversionCandidate( 3640 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, 3641 CXXRecordDecl *ActingContext, Expr *From, QualType ToType, 3642 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, 3643 bool AllowExplicit, bool AllowResultConversion = true); 3644 void AddTemplateConversionCandidate( 3645 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, 3646 CXXRecordDecl *ActingContext, Expr *From, QualType ToType, 3647 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, 3648 bool AllowExplicit, bool AllowResultConversion = true); 3649 void AddSurrogateCandidate(CXXConversionDecl *Conversion, 3650 DeclAccessPair FoundDecl, 3651 CXXRecordDecl *ActingContext, 3652 const FunctionProtoType *Proto, 3653 Expr *Object, ArrayRef<Expr *> Args, 3654 OverloadCandidateSet& CandidateSet); 3655 void AddNonMemberOperatorCandidates( 3656 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args, 3657 OverloadCandidateSet &CandidateSet, 3658 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr); 3659 void AddMemberOperatorCandidates(OverloadedOperatorKind Op, 3660 SourceLocation OpLoc, ArrayRef<Expr *> Args, 3661 OverloadCandidateSet &CandidateSet, 3662 OverloadCandidateParamOrder PO = {}); 3663 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args, 3664 OverloadCandidateSet& CandidateSet, 3665 bool IsAssignmentOperator = false, 3666 unsigned NumContextualBoolArguments = 0); 3667 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, 3668 SourceLocation OpLoc, ArrayRef<Expr *> Args, 3669 OverloadCandidateSet& CandidateSet); 3670 void AddArgumentDependentLookupCandidates(DeclarationName Name, 3671 SourceLocation Loc, 3672 ArrayRef<Expr *> Args, 3673 TemplateArgumentListInfo *ExplicitTemplateArgs, 3674 OverloadCandidateSet& CandidateSet, 3675 bool PartialOverloading = false); 3676 3677 // Emit as a 'note' the specific overload candidate 3678 void NoteOverloadCandidate( 3679 NamedDecl *Found, FunctionDecl *Fn, 3680 OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(), 3681 QualType DestType = QualType(), bool TakingAddress = false); 3682 3683 // Emit as a series of 'note's all template and non-templates identified by 3684 // the expression Expr 3685 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(), 3686 bool TakingAddress = false); 3687 3688 /// Check the enable_if expressions on the given function. Returns the first 3689 /// failing attribute, or NULL if they were all successful. 3690 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc, 3691 ArrayRef<Expr *> Args, 3692 bool MissingImplicitThis = false); 3693 3694 /// Find the failed Boolean condition within a given Boolean 3695 /// constant expression, and describe it with a string. 3696 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond); 3697 3698 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any 3699 /// non-ArgDependent DiagnoseIfAttrs. 3700 /// 3701 /// Argument-dependent diagnose_if attributes should be checked each time a 3702 /// function is used as a direct callee of a function call. 3703 /// 3704 /// Returns true if any errors were emitted. 3705 bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, 3706 const Expr *ThisArg, 3707 ArrayRef<const Expr *> Args, 3708 SourceLocation Loc); 3709 3710 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any 3711 /// ArgDependent DiagnoseIfAttrs. 3712 /// 3713 /// Argument-independent diagnose_if attributes should be checked on every use 3714 /// of a function. 3715 /// 3716 /// Returns true if any errors were emitted. 3717 bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, 3718 SourceLocation Loc); 3719 3720 /// Returns whether the given function's address can be taken or not, 3721 /// optionally emitting a diagnostic if the address can't be taken. 3722 /// 3723 /// Returns false if taking the address of the function is illegal. 3724 bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, 3725 bool Complain = false, 3726 SourceLocation Loc = SourceLocation()); 3727 3728 // [PossiblyAFunctionType] --> [Return] 3729 // NonFunctionType --> NonFunctionType 3730 // R (A) --> R(A) 3731 // R (*)(A) --> R (A) 3732 // R (&)(A) --> R (A) 3733 // R (S::*)(A) --> R (A) 3734 QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType); 3735 3736 FunctionDecl * 3737 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, 3738 QualType TargetType, 3739 bool Complain, 3740 DeclAccessPair &Found, 3741 bool *pHadMultipleCandidates = nullptr); 3742 3743 FunctionDecl * 3744 resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult); 3745 3746 bool resolveAndFixAddressOfSingleOverloadCandidate( 3747 ExprResult &SrcExpr, bool DoFunctionPointerConversion = false); 3748 3749 FunctionDecl * 3750 ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, 3751 bool Complain = false, 3752 DeclAccessPair *Found = nullptr); 3753 3754 bool ResolveAndFixSingleFunctionTemplateSpecialization( 3755 ExprResult &SrcExpr, 3756 bool DoFunctionPointerConverion = false, 3757 bool Complain = false, 3758 SourceRange OpRangeForComplaining = SourceRange(), 3759 QualType DestTypeForComplaining = QualType(), 3760 unsigned DiagIDForComplaining = 0); 3761 3762 3763 Expr *FixOverloadedFunctionReference(Expr *E, 3764 DeclAccessPair FoundDecl, 3765 FunctionDecl *Fn); 3766 ExprResult FixOverloadedFunctionReference(ExprResult, 3767 DeclAccessPair FoundDecl, 3768 FunctionDecl *Fn); 3769 3770 void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, 3771 ArrayRef<Expr *> Args, 3772 OverloadCandidateSet &CandidateSet, 3773 bool PartialOverloading = false); 3774 void AddOverloadedCallCandidates( 3775 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs, 3776 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet); 3777 3778 // An enum used to represent the different possible results of building a 3779 // range-based for loop. 3780 enum ForRangeStatus { 3781 FRS_Success, 3782 FRS_NoViableFunction, 3783 FRS_DiagnosticIssued 3784 }; 3785 3786 ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, 3787 SourceLocation RangeLoc, 3788 const DeclarationNameInfo &NameInfo, 3789 LookupResult &MemberLookup, 3790 OverloadCandidateSet *CandidateSet, 3791 Expr *Range, ExprResult *CallExpr); 3792 3793 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, 3794 UnresolvedLookupExpr *ULE, 3795 SourceLocation LParenLoc, 3796 MultiExprArg Args, 3797 SourceLocation RParenLoc, 3798 Expr *ExecConfig, 3799 bool AllowTypoCorrection=true, 3800 bool CalleesAddressIsTaken=false); 3801 3802 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, 3803 MultiExprArg Args, SourceLocation RParenLoc, 3804 OverloadCandidateSet *CandidateSet, 3805 ExprResult *Result); 3806 3807 ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass, 3808 NestedNameSpecifierLoc NNSLoc, 3809 DeclarationNameInfo DNI, 3810 const UnresolvedSetImpl &Fns, 3811 bool PerformADL = true); 3812 3813 ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, 3814 UnaryOperatorKind Opc, 3815 const UnresolvedSetImpl &Fns, 3816 Expr *input, bool RequiresADL = true); 3817 3818 void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, 3819 OverloadedOperatorKind Op, 3820 const UnresolvedSetImpl &Fns, 3821 ArrayRef<Expr *> Args, bool RequiresADL = true); 3822 ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, 3823 BinaryOperatorKind Opc, 3824 const UnresolvedSetImpl &Fns, 3825 Expr *LHS, Expr *RHS, 3826 bool RequiresADL = true, 3827 bool AllowRewrittenCandidates = true, 3828 FunctionDecl *DefaultedFn = nullptr); 3829 ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc, 3830 const UnresolvedSetImpl &Fns, 3831 Expr *LHS, Expr *RHS, 3832 FunctionDecl *DefaultedFn); 3833 3834 ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, 3835 SourceLocation RLoc, 3836 Expr *Base,Expr *Idx); 3837 3838 ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, 3839 SourceLocation LParenLoc, 3840 MultiExprArg Args, 3841 SourceLocation RParenLoc, 3842 bool AllowRecovery = false); 3843 ExprResult 3844 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, 3845 MultiExprArg Args, 3846 SourceLocation RParenLoc); 3847 3848 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, 3849 SourceLocation OpLoc, 3850 bool *NoArrowOperatorFound = nullptr); 3851 3852 /// CheckCallReturnType - Checks that a call expression's return type is 3853 /// complete. Returns true on failure. The location passed in is the location 3854 /// that best represents the call. 3855 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, 3856 CallExpr *CE, FunctionDecl *FD); 3857 3858 /// Helpers for dealing with blocks and functions. 3859 bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters, 3860 bool CheckParameterNames); 3861 void CheckCXXDefaultArguments(FunctionDecl *FD); 3862 void CheckExtraCXXDefaultArguments(Declarator &D); 3863 Scope *getNonFieldDeclScope(Scope *S); 3864 3865 /// \name Name lookup 3866 /// 3867 /// These routines provide name lookup that is used during semantic 3868 /// analysis to resolve the various kinds of names (identifiers, 3869 /// overloaded operator names, constructor names, etc.) into zero or 3870 /// more declarations within a particular scope. The major entry 3871 /// points are LookupName, which performs unqualified name lookup, 3872 /// and LookupQualifiedName, which performs qualified name lookup. 3873 /// 3874 /// All name lookup is performed based on some specific criteria, 3875 /// which specify what names will be visible to name lookup and how 3876 /// far name lookup should work. These criteria are important both 3877 /// for capturing language semantics (certain lookups will ignore 3878 /// certain names, for example) and for performance, since name 3879 /// lookup is often a bottleneck in the compilation of C++. Name 3880 /// lookup criteria is specified via the LookupCriteria enumeration. 3881 /// 3882 /// The results of name lookup can vary based on the kind of name 3883 /// lookup performed, the current language, and the translation 3884 /// unit. In C, for example, name lookup will either return nothing 3885 /// (no entity found) or a single declaration. In C++, name lookup 3886 /// can additionally refer to a set of overloaded functions or 3887 /// result in an ambiguity. All of the possible results of name 3888 /// lookup are captured by the LookupResult class, which provides 3889 /// the ability to distinguish among them. 3890 //@{ 3891 3892 /// Describes the kind of name lookup to perform. 3893 enum LookupNameKind { 3894 /// Ordinary name lookup, which finds ordinary names (functions, 3895 /// variables, typedefs, etc.) in C and most kinds of names 3896 /// (functions, variables, members, types, etc.) in C++. 3897 LookupOrdinaryName = 0, 3898 /// Tag name lookup, which finds the names of enums, classes, 3899 /// structs, and unions. 3900 LookupTagName, 3901 /// Label name lookup. 3902 LookupLabel, 3903 /// Member name lookup, which finds the names of 3904 /// class/struct/union members. 3905 LookupMemberName, 3906 /// Look up of an operator name (e.g., operator+) for use with 3907 /// operator overloading. This lookup is similar to ordinary name 3908 /// lookup, but will ignore any declarations that are class members. 3909 LookupOperatorName, 3910 /// Look up a name following ~ in a destructor name. This is an ordinary 3911 /// lookup, but prefers tags to typedefs. 3912 LookupDestructorName, 3913 /// Look up of a name that precedes the '::' scope resolution 3914 /// operator in C++. This lookup completely ignores operator, object, 3915 /// function, and enumerator names (C++ [basic.lookup.qual]p1). 3916 LookupNestedNameSpecifierName, 3917 /// Look up a namespace name within a C++ using directive or 3918 /// namespace alias definition, ignoring non-namespace names (C++ 3919 /// [basic.lookup.udir]p1). 3920 LookupNamespaceName, 3921 /// Look up all declarations in a scope with the given name, 3922 /// including resolved using declarations. This is appropriate 3923 /// for checking redeclarations for a using declaration. 3924 LookupUsingDeclName, 3925 /// Look up an ordinary name that is going to be redeclared as a 3926 /// name with linkage. This lookup ignores any declarations that 3927 /// are outside of the current scope unless they have linkage. See 3928 /// C99 6.2.2p4-5 and C++ [basic.link]p6. 3929 LookupRedeclarationWithLinkage, 3930 /// Look up a friend of a local class. This lookup does not look 3931 /// outside the innermost non-class scope. See C++11 [class.friend]p11. 3932 LookupLocalFriendName, 3933 /// Look up the name of an Objective-C protocol. 3934 LookupObjCProtocolName, 3935 /// Look up implicit 'self' parameter of an objective-c method. 3936 LookupObjCImplicitSelfParam, 3937 /// Look up the name of an OpenMP user-defined reduction operation. 3938 LookupOMPReductionName, 3939 /// Look up the name of an OpenMP user-defined mapper. 3940 LookupOMPMapperName, 3941 /// Look up any declaration with any name. 3942 LookupAnyName 3943 }; 3944 3945 /// Specifies whether (or how) name lookup is being performed for a 3946 /// redeclaration (vs. a reference). 3947 enum RedeclarationKind { 3948 /// The lookup is a reference to this name that is not for the 3949 /// purpose of redeclaring the name. 3950 NotForRedeclaration = 0, 3951 /// The lookup results will be used for redeclaration of a name, 3952 /// if an entity by that name already exists and is visible. 3953 ForVisibleRedeclaration, 3954 /// The lookup results will be used for redeclaration of a name 3955 /// with external linkage; non-visible lookup results with external linkage 3956 /// may also be found. 3957 ForExternalRedeclaration 3958 }; 3959 forRedeclarationInCurContext()3960 RedeclarationKind forRedeclarationInCurContext() { 3961 // A declaration with an owning module for linkage can never link against 3962 // anything that is not visible. We don't need to check linkage here; if 3963 // the context has internal linkage, redeclaration lookup won't find things 3964 // from other TUs, and we can't safely compute linkage yet in general. 3965 if (cast<Decl>(CurContext) 3966 ->getOwningModuleForLinkage(/*IgnoreLinkage*/true)) 3967 return ForVisibleRedeclaration; 3968 return ForExternalRedeclaration; 3969 } 3970 3971 /// The possible outcomes of name lookup for a literal operator. 3972 enum LiteralOperatorLookupResult { 3973 /// The lookup resulted in an error. 3974 LOLR_Error, 3975 /// The lookup found no match but no diagnostic was issued. 3976 LOLR_ErrorNoDiagnostic, 3977 /// The lookup found a single 'cooked' literal operator, which 3978 /// expects a normal literal to be built and passed to it. 3979 LOLR_Cooked, 3980 /// The lookup found a single 'raw' literal operator, which expects 3981 /// a string literal containing the spelling of the literal token. 3982 LOLR_Raw, 3983 /// The lookup found an overload set of literal operator templates, 3984 /// which expect the characters of the spelling of the literal token to be 3985 /// passed as a non-type template argument pack. 3986 LOLR_Template, 3987 /// The lookup found an overload set of literal operator templates, 3988 /// which expect the character type and characters of the spelling of the 3989 /// string literal token to be passed as template arguments. 3990 LOLR_StringTemplatePack, 3991 }; 3992 3993 SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, 3994 CXXSpecialMember SM, 3995 bool ConstArg, 3996 bool VolatileArg, 3997 bool RValueThis, 3998 bool ConstThis, 3999 bool VolatileThis); 4000 4001 typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator; 4002 typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)> 4003 TypoRecoveryCallback; 4004 4005 private: 4006 bool CppLookupName(LookupResult &R, Scope *S); 4007 4008 struct TypoExprState { 4009 std::unique_ptr<TypoCorrectionConsumer> Consumer; 4010 TypoDiagnosticGenerator DiagHandler; 4011 TypoRecoveryCallback RecoveryHandler; 4012 TypoExprState(); 4013 TypoExprState(TypoExprState &&other) noexcept; 4014 TypoExprState &operator=(TypoExprState &&other) noexcept; 4015 }; 4016 4017 /// The set of unhandled TypoExprs and their associated state. 4018 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos; 4019 4020 /// Creates a new TypoExpr AST node. 4021 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC, 4022 TypoDiagnosticGenerator TDG, 4023 TypoRecoveryCallback TRC, SourceLocation TypoLoc); 4024 4025 // The set of known/encountered (unique, canonicalized) NamespaceDecls. 4026 // 4027 // The boolean value will be true to indicate that the namespace was loaded 4028 // from an AST/PCH file, or false otherwise. 4029 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces; 4030 4031 /// Whether we have already loaded known namespaces from an extenal 4032 /// source. 4033 bool LoadedExternalKnownNamespaces; 4034 4035 /// Helper for CorrectTypo and CorrectTypoDelayed used to create and 4036 /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction 4037 /// should be skipped entirely. 4038 std::unique_ptr<TypoCorrectionConsumer> 4039 makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo, 4040 Sema::LookupNameKind LookupKind, Scope *S, 4041 CXXScopeSpec *SS, 4042 CorrectionCandidateCallback &CCC, 4043 DeclContext *MemberContext, bool EnteringContext, 4044 const ObjCObjectPointerType *OPT, 4045 bool ErrorRecovery); 4046 4047 public: 4048 const TypoExprState &getTypoExprState(TypoExpr *TE) const; 4049 4050 /// Clears the state of the given TypoExpr. 4051 void clearDelayedTypo(TypoExpr *TE); 4052 4053 /// Look up a name, looking for a single declaration. Return 4054 /// null if the results were absent, ambiguous, or overloaded. 4055 /// 4056 /// It is preferable to use the elaborated form and explicitly handle 4057 /// ambiguity and overloaded. 4058 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name, 4059 SourceLocation Loc, 4060 LookupNameKind NameKind, 4061 RedeclarationKind Redecl 4062 = NotForRedeclaration); 4063 bool LookupBuiltin(LookupResult &R); 4064 void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID); 4065 bool LookupName(LookupResult &R, Scope *S, 4066 bool AllowBuiltinCreation = false); 4067 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, 4068 bool InUnqualifiedLookup = false); 4069 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, 4070 CXXScopeSpec &SS); 4071 bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, 4072 bool AllowBuiltinCreation = false, 4073 bool EnteringContext = false); 4074 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc, 4075 RedeclarationKind Redecl 4076 = NotForRedeclaration); 4077 bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class); 4078 4079 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, 4080 UnresolvedSetImpl &Functions); 4081 4082 LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, 4083 SourceLocation GnuLabelLoc = SourceLocation()); 4084 4085 DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class); 4086 CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class); 4087 CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class, 4088 unsigned Quals); 4089 CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals, 4090 bool RValueThis, unsigned ThisQuals); 4091 CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class, 4092 unsigned Quals); 4093 CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals, 4094 bool RValueThis, unsigned ThisQuals); 4095 CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class); 4096 4097 bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id); 4098 LiteralOperatorLookupResult 4099 LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys, 4100 bool AllowRaw, bool AllowTemplate, 4101 bool AllowStringTemplate, bool DiagnoseMissing, 4102 StringLiteral *StringLit = nullptr); 4103 bool isKnownName(StringRef name); 4104 4105 /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs. 4106 enum class FunctionEmissionStatus { 4107 Emitted, 4108 CUDADiscarded, // Discarded due to CUDA/HIP hostness 4109 OMPDiscarded, // Discarded due to OpenMP hostness 4110 TemplateDiscarded, // Discarded due to uninstantiated templates 4111 Unknown, 4112 }; 4113 FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl, 4114 bool Final = false); 4115 4116 // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check. 4117 bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee); 4118 4119 void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, 4120 ArrayRef<Expr *> Args, ADLResult &Functions); 4121 4122 void LookupVisibleDecls(Scope *S, LookupNameKind Kind, 4123 VisibleDeclConsumer &Consumer, 4124 bool IncludeGlobalScope = true, 4125 bool LoadExternal = true); 4126 void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind, 4127 VisibleDeclConsumer &Consumer, 4128 bool IncludeGlobalScope = true, 4129 bool IncludeDependentBases = false, 4130 bool LoadExternal = true); 4131 4132 enum CorrectTypoKind { 4133 CTK_NonError, // CorrectTypo used in a non error recovery situation. 4134 CTK_ErrorRecovery // CorrectTypo used in normal error recovery. 4135 }; 4136 4137 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, 4138 Sema::LookupNameKind LookupKind, 4139 Scope *S, CXXScopeSpec *SS, 4140 CorrectionCandidateCallback &CCC, 4141 CorrectTypoKind Mode, 4142 DeclContext *MemberContext = nullptr, 4143 bool EnteringContext = false, 4144 const ObjCObjectPointerType *OPT = nullptr, 4145 bool RecordFailure = true); 4146 4147 TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo, 4148 Sema::LookupNameKind LookupKind, Scope *S, 4149 CXXScopeSpec *SS, 4150 CorrectionCandidateCallback &CCC, 4151 TypoDiagnosticGenerator TDG, 4152 TypoRecoveryCallback TRC, CorrectTypoKind Mode, 4153 DeclContext *MemberContext = nullptr, 4154 bool EnteringContext = false, 4155 const ObjCObjectPointerType *OPT = nullptr); 4156 4157 /// Process any TypoExprs in the given Expr and its children, 4158 /// generating diagnostics as appropriate and returning a new Expr if there 4159 /// were typos that were all successfully corrected and ExprError if one or 4160 /// more typos could not be corrected. 4161 /// 4162 /// \param E The Expr to check for TypoExprs. 4163 /// 4164 /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its 4165 /// initializer. 4166 /// 4167 /// \param RecoverUncorrectedTypos If true, when typo correction fails, it 4168 /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs. 4169 /// 4170 /// \param Filter A function applied to a newly rebuilt Expr to determine if 4171 /// it is an acceptable/usable result from a single combination of typo 4172 /// corrections. As long as the filter returns ExprError, different 4173 /// combinations of corrections will be tried until all are exhausted. 4174 ExprResult CorrectDelayedTyposInExpr( 4175 Expr *E, VarDecl *InitDecl = nullptr, 4176 bool RecoverUncorrectedTypos = false, 4177 llvm::function_ref<ExprResult(Expr *)> Filter = 4178 [](Expr *E) -> ExprResult { return E; }); 4179 4180 ExprResult CorrectDelayedTyposInExpr( 4181 ExprResult ER, VarDecl *InitDecl = nullptr, 4182 bool RecoverUncorrectedTypos = false, 4183 llvm::function_ref<ExprResult(Expr *)> Filter = 4184 [](Expr *E) -> ExprResult { return E; }) { 4185 return ER.isInvalid() 4186 ? ER 4187 : CorrectDelayedTyposInExpr(ER.get(), InitDecl, 4188 RecoverUncorrectedTypos, Filter); 4189 } 4190 4191 void diagnoseTypo(const TypoCorrection &Correction, 4192 const PartialDiagnostic &TypoDiag, 4193 bool ErrorRecovery = true); 4194 4195 void diagnoseTypo(const TypoCorrection &Correction, 4196 const PartialDiagnostic &TypoDiag, 4197 const PartialDiagnostic &PrevNote, 4198 bool ErrorRecovery = true); 4199 4200 void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F); 4201 4202 void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc, 4203 ArrayRef<Expr *> Args, 4204 AssociatedNamespaceSet &AssociatedNamespaces, 4205 AssociatedClassSet &AssociatedClasses); 4206 4207 void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, 4208 bool ConsiderLinkage, bool AllowInlineNamespace); 4209 4210 bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old); 4211 4212 void DiagnoseAmbiguousLookup(LookupResult &Result); 4213 //@} 4214 4215 /// Attempts to produce a RecoveryExpr after some AST node cannot be created. 4216 ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, 4217 ArrayRef<Expr *> SubExprs, 4218 QualType T = QualType()); 4219 4220 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id, 4221 SourceLocation IdLoc, 4222 bool TypoCorrection = false); 4223 FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, 4224 SourceLocation Loc); 4225 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, 4226 Scope *S, bool ForRedeclaration, 4227 SourceLocation Loc); 4228 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, 4229 Scope *S); 4230 void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction( 4231 FunctionDecl *FD); 4232 void AddKnownFunctionAttributes(FunctionDecl *FD); 4233 4234 // More parsing and symbol table subroutines. 4235 4236 void ProcessPragmaWeak(Scope *S, Decl *D); 4237 // Decl attributes - this routine is the top level dispatcher. 4238 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD); 4239 // Helper for delayed processing of attributes. 4240 void ProcessDeclAttributeDelayed(Decl *D, 4241 const ParsedAttributesView &AttrList); 4242 void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL, 4243 bool IncludeCXX11Attributes = true); 4244 bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, 4245 const ParsedAttributesView &AttrList); 4246 4247 void checkUnusedDeclAttributes(Declarator &D); 4248 4249 /// Determine if type T is a valid subject for a nonnull and similar 4250 /// attributes. By default, we look through references (the behavior used by 4251 /// nonnull), but if the second parameter is true, then we treat a reference 4252 /// type as valid. 4253 bool isValidPointerAttrType(QualType T, bool RefOkay = false); 4254 4255 bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value); 4256 bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, 4257 const FunctionDecl *FD = nullptr); 4258 bool CheckAttrTarget(const ParsedAttr &CurrAttr); 4259 bool CheckAttrNoArgs(const ParsedAttr &CurrAttr); 4260 bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum, 4261 StringRef &Str, 4262 SourceLocation *ArgLocation = nullptr); 4263 bool checkSectionName(SourceLocation LiteralLoc, StringRef Str); 4264 bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str); 4265 bool checkMSInheritanceAttrOnDefinition( 4266 CXXRecordDecl *RD, SourceRange Range, bool BestCase, 4267 MSInheritanceModel SemanticSpelling); 4268 4269 void CheckAlignasUnderalignment(Decl *D); 4270 4271 /// Adjust the calling convention of a method to be the ABI default if it 4272 /// wasn't specified explicitly. This handles method types formed from 4273 /// function type typedefs and typename template arguments. 4274 void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, 4275 SourceLocation Loc); 4276 4277 // Check if there is an explicit attribute, but only look through parens. 4278 // The intent is to look for an attribute on the current declarator, but not 4279 // one that came from a typedef. 4280 bool hasExplicitCallingConv(QualType T); 4281 4282 /// Get the outermost AttributedType node that sets a calling convention. 4283 /// Valid types should not have multiple attributes with different CCs. 4284 const AttributedType *getCallingConvAttributedType(QualType T) const; 4285 4286 /// Stmt attributes - this routine is the top level dispatcher. 4287 StmtResult ProcessStmtAttributes(Stmt *Stmt, 4288 const ParsedAttributesView &Attrs, 4289 SourceRange Range); 4290 4291 void WarnConflictingTypedMethods(ObjCMethodDecl *Method, 4292 ObjCMethodDecl *MethodDecl, 4293 bool IsProtocolMethodDecl); 4294 4295 void CheckConflictingOverridingMethod(ObjCMethodDecl *Method, 4296 ObjCMethodDecl *Overridden, 4297 bool IsProtocolMethodDecl); 4298 4299 /// WarnExactTypedMethods - This routine issues a warning if method 4300 /// implementation declaration matches exactly that of its declaration. 4301 void WarnExactTypedMethods(ObjCMethodDecl *Method, 4302 ObjCMethodDecl *MethodDecl, 4303 bool IsProtocolMethodDecl); 4304 4305 typedef llvm::SmallPtrSet<Selector, 8> SelectorSet; 4306 4307 /// CheckImplementationIvars - This routine checks if the instance variables 4308 /// listed in the implelementation match those listed in the interface. 4309 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, 4310 ObjCIvarDecl **Fields, unsigned nIvars, 4311 SourceLocation Loc); 4312 4313 /// ImplMethodsVsClassMethods - This is main routine to warn if any method 4314 /// remains unimplemented in the class or category \@implementation. 4315 void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl, 4316 ObjCContainerDecl* IDecl, 4317 bool IncompleteImpl = false); 4318 4319 /// DiagnoseUnimplementedProperties - This routine warns on those properties 4320 /// which must be implemented by this implementation. 4321 void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl, 4322 ObjCContainerDecl *CDecl, 4323 bool SynthesizeProperties); 4324 4325 /// Diagnose any null-resettable synthesized setters. 4326 void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl); 4327 4328 /// DefaultSynthesizeProperties - This routine default synthesizes all 4329 /// properties which must be synthesized in the class's \@implementation. 4330 void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, 4331 ObjCInterfaceDecl *IDecl, 4332 SourceLocation AtEnd); 4333 void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd); 4334 4335 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is 4336 /// an ivar synthesized for 'Method' and 'Method' is a property accessor 4337 /// declared in class 'IFace'. 4338 bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, 4339 ObjCMethodDecl *Method, ObjCIvarDecl *IV); 4340 4341 /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which 4342 /// backs the property is not used in the property's accessor. 4343 void DiagnoseUnusedBackingIvarInAccessor(Scope *S, 4344 const ObjCImplementationDecl *ImplD); 4345 4346 /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and 4347 /// it property has a backing ivar, returns this ivar; otherwise, returns NULL. 4348 /// It also returns ivar's property on success. 4349 ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method, 4350 const ObjCPropertyDecl *&PDecl) const; 4351 4352 /// Called by ActOnProperty to handle \@property declarations in 4353 /// class extensions. 4354 ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S, 4355 SourceLocation AtLoc, 4356 SourceLocation LParenLoc, 4357 FieldDeclarator &FD, 4358 Selector GetterSel, 4359 SourceLocation GetterNameLoc, 4360 Selector SetterSel, 4361 SourceLocation SetterNameLoc, 4362 const bool isReadWrite, 4363 unsigned &Attributes, 4364 const unsigned AttributesAsWritten, 4365 QualType T, 4366 TypeSourceInfo *TSI, 4367 tok::ObjCKeywordKind MethodImplKind); 4368 4369 /// Called by ActOnProperty and HandlePropertyInClassExtension to 4370 /// handle creating the ObjcPropertyDecl for a category or \@interface. 4371 ObjCPropertyDecl *CreatePropertyDecl(Scope *S, 4372 ObjCContainerDecl *CDecl, 4373 SourceLocation AtLoc, 4374 SourceLocation LParenLoc, 4375 FieldDeclarator &FD, 4376 Selector GetterSel, 4377 SourceLocation GetterNameLoc, 4378 Selector SetterSel, 4379 SourceLocation SetterNameLoc, 4380 const bool isReadWrite, 4381 const unsigned Attributes, 4382 const unsigned AttributesAsWritten, 4383 QualType T, 4384 TypeSourceInfo *TSI, 4385 tok::ObjCKeywordKind MethodImplKind, 4386 DeclContext *lexicalDC = nullptr); 4387 4388 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via 4389 /// warning) when atomic property has one but not the other user-declared 4390 /// setter or getter. 4391 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl, 4392 ObjCInterfaceDecl* IDecl); 4393 4394 void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D); 4395 4396 void DiagnoseMissingDesignatedInitOverrides( 4397 const ObjCImplementationDecl *ImplD, 4398 const ObjCInterfaceDecl *IFD); 4399 4400 void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID); 4401 4402 enum MethodMatchStrategy { 4403 MMS_loose, 4404 MMS_strict 4405 }; 4406 4407 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns 4408 /// true, or false, accordingly. 4409 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, 4410 const ObjCMethodDecl *PrevMethod, 4411 MethodMatchStrategy strategy = MMS_strict); 4412 4413 /// MatchAllMethodDeclarations - Check methods declaraed in interface or 4414 /// or protocol against those declared in their implementations. 4415 void MatchAllMethodDeclarations(const SelectorSet &InsMap, 4416 const SelectorSet &ClsMap, 4417 SelectorSet &InsMapSeen, 4418 SelectorSet &ClsMapSeen, 4419 ObjCImplDecl* IMPDecl, 4420 ObjCContainerDecl* IDecl, 4421 bool &IncompleteImpl, 4422 bool ImmediateClass, 4423 bool WarnCategoryMethodImpl=false); 4424 4425 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in 4426 /// category matches with those implemented in its primary class and 4427 /// warns each time an exact match is found. 4428 void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP); 4429 4430 /// Add the given method to the list of globally-known methods. 4431 void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method); 4432 4433 /// Returns default addr space for method qualifiers. 4434 LangAS getDefaultCXXMethodAddrSpace() const; 4435 4436 private: 4437 /// AddMethodToGlobalPool - Add an instance or factory method to the global 4438 /// pool. See descriptoin of AddInstanceMethodToGlobalPool. 4439 void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance); 4440 4441 /// LookupMethodInGlobalPool - Returns the instance or factory method and 4442 /// optionally warns if there are multiple signatures. 4443 ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R, 4444 bool receiverIdOrClass, 4445 bool instance); 4446 4447 public: 4448 /// - Returns instance or factory methods in global method pool for 4449 /// given selector. It checks the desired kind first, if none is found, and 4450 /// parameter checkTheOther is set, it then checks the other kind. If no such 4451 /// method or only one method is found, function returns false; otherwise, it 4452 /// returns true. 4453 bool 4454 CollectMultipleMethodsInGlobalPool(Selector Sel, 4455 SmallVectorImpl<ObjCMethodDecl*>& Methods, 4456 bool InstanceFirst, bool CheckTheOther, 4457 const ObjCObjectType *TypeBound = nullptr); 4458 4459 bool 4460 AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod, 4461 SourceRange R, bool receiverIdOrClass, 4462 SmallVectorImpl<ObjCMethodDecl*>& Methods); 4463 4464 void 4465 DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods, 4466 Selector Sel, SourceRange R, 4467 bool receiverIdOrClass); 4468 4469 private: 4470 /// - Returns a selector which best matches given argument list or 4471 /// nullptr if none could be found 4472 ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args, 4473 bool IsInstance, 4474 SmallVectorImpl<ObjCMethodDecl*>& Methods); 4475 4476 4477 /// Record the typo correction failure and return an empty correction. 4478 TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc, 4479 bool RecordFailure = true) { 4480 if (RecordFailure) 4481 TypoCorrectionFailures[Typo].insert(TypoLoc); 4482 return TypoCorrection(); 4483 } 4484 4485 public: 4486 /// AddInstanceMethodToGlobalPool - All instance methods in a translation 4487 /// unit are added to a global pool. This allows us to efficiently associate 4488 /// a selector with a method declaraation for purposes of typechecking 4489 /// messages sent to "id" (where the class of the object is unknown). 4490 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) { 4491 AddMethodToGlobalPool(Method, impl, /*instance*/true); 4492 } 4493 4494 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods. 4495 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) { 4496 AddMethodToGlobalPool(Method, impl, /*instance*/false); 4497 } 4498 4499 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global 4500 /// pool. 4501 void AddAnyMethodToGlobalPool(Decl *D); 4502 4503 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if 4504 /// there are multiple signatures. 4505 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, 4506 bool receiverIdOrClass=false) { 4507 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass, 4508 /*instance*/true); 4509 } 4510 4511 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if 4512 /// there are multiple signatures. 4513 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R, 4514 bool receiverIdOrClass=false) { 4515 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass, 4516 /*instance*/false); 4517 } 4518 4519 const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel, 4520 QualType ObjectType=QualType()); 4521 /// LookupImplementedMethodInGlobalPool - Returns the method which has an 4522 /// implementation. 4523 ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel); 4524 4525 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require 4526 /// initialization. 4527 void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, 4528 SmallVectorImpl<ObjCIvarDecl*> &Ivars); 4529 4530 //===--------------------------------------------------------------------===// 4531 // Statement Parsing Callbacks: SemaStmt.cpp. 4532 public: 4533 class FullExprArg { 4534 public: FullExprArg()4535 FullExprArg() : E(nullptr) { } FullExprArg(Sema & actions)4536 FullExprArg(Sema &actions) : E(nullptr) { } 4537 release()4538 ExprResult release() { 4539 return E; 4540 } 4541 get()4542 Expr *get() const { return E; } 4543 4544 Expr *operator->() { 4545 return E; 4546 } 4547 4548 private: 4549 // FIXME: No need to make the entire Sema class a friend when it's just 4550 // Sema::MakeFullExpr that needs access to the constructor below. 4551 friend class Sema; 4552 FullExprArg(Expr * expr)4553 explicit FullExprArg(Expr *expr) : E(expr) {} 4554 4555 Expr *E; 4556 }; 4557 MakeFullExpr(Expr * Arg)4558 FullExprArg MakeFullExpr(Expr *Arg) { 4559 return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation()); 4560 } MakeFullExpr(Expr * Arg,SourceLocation CC)4561 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) { 4562 return FullExprArg( 4563 ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get()); 4564 } MakeFullDiscardedValueExpr(Expr * Arg)4565 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) { 4566 ExprResult FE = 4567 ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(), 4568 /*DiscardedValue*/ true); 4569 return FullExprArg(FE.get()); 4570 } 4571 4572 StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true); 4573 StmtResult ActOnExprStmtError(); 4574 4575 StmtResult ActOnNullStmt(SourceLocation SemiLoc, 4576 bool HasLeadingEmptyMacro = false); 4577 4578 void ActOnStartOfCompoundStmt(bool IsStmtExpr); 4579 void ActOnAfterCompoundStatementLeadingPragmas(); 4580 void ActOnFinishOfCompoundStmt(); 4581 StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, 4582 ArrayRef<Stmt *> Elts, bool isStmtExpr); 4583 4584 /// A RAII object to enter scope of a compound statement. 4585 class CompoundScopeRAII { 4586 public: S(S)4587 CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) { 4588 S.ActOnStartOfCompoundStmt(IsStmtExpr); 4589 } 4590 ~CompoundScopeRAII()4591 ~CompoundScopeRAII() { 4592 S.ActOnFinishOfCompoundStmt(); 4593 } 4594 4595 private: 4596 Sema &S; 4597 }; 4598 4599 /// An RAII helper that pops function a function scope on exit. 4600 struct FunctionScopeRAII { 4601 Sema &S; 4602 bool Active; FunctionScopeRAIIFunctionScopeRAII4603 FunctionScopeRAII(Sema &S) : S(S), Active(true) {} ~FunctionScopeRAIIFunctionScopeRAII4604 ~FunctionScopeRAII() { 4605 if (Active) 4606 S.PopFunctionScopeInfo(); 4607 } disableFunctionScopeRAII4608 void disable() { Active = false; } 4609 }; 4610 4611 StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, 4612 SourceLocation StartLoc, 4613 SourceLocation EndLoc); 4614 void ActOnForEachDeclStmt(DeclGroupPtrTy Decl); 4615 StmtResult ActOnForEachLValueExpr(Expr *E); 4616 ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val); 4617 StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, 4618 SourceLocation DotDotDotLoc, ExprResult RHS, 4619 SourceLocation ColonLoc); 4620 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt); 4621 4622 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, 4623 SourceLocation ColonLoc, 4624 Stmt *SubStmt, Scope *CurScope); 4625 StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, 4626 SourceLocation ColonLoc, Stmt *SubStmt); 4627 4628 StmtResult ActOnAttributedStmt(SourceLocation AttrLoc, 4629 ArrayRef<const Attr*> Attrs, 4630 Stmt *SubStmt); 4631 4632 class ConditionResult; 4633 StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr, 4634 SourceLocation LParenLoc, Stmt *InitStmt, 4635 ConditionResult Cond, SourceLocation RParenLoc, 4636 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal); 4637 StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr, 4638 SourceLocation LParenLoc, Stmt *InitStmt, 4639 ConditionResult Cond, SourceLocation RParenLoc, 4640 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal); 4641 StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, 4642 SourceLocation LParenLoc, Stmt *InitStmt, 4643 ConditionResult Cond, 4644 SourceLocation RParenLoc); 4645 StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, 4646 Stmt *Switch, Stmt *Body); 4647 StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, 4648 ConditionResult Cond, SourceLocation RParenLoc, 4649 Stmt *Body); 4650 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, 4651 SourceLocation WhileLoc, SourceLocation CondLParen, 4652 Expr *Cond, SourceLocation CondRParen); 4653 4654 StmtResult ActOnForStmt(SourceLocation ForLoc, 4655 SourceLocation LParenLoc, 4656 Stmt *First, 4657 ConditionResult Second, 4658 FullExprArg Third, 4659 SourceLocation RParenLoc, 4660 Stmt *Body); 4661 ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc, 4662 Expr *collection); 4663 StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, 4664 Stmt *First, Expr *collection, 4665 SourceLocation RParenLoc); 4666 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body); 4667 4668 enum BuildForRangeKind { 4669 /// Initial building of a for-range statement. 4670 BFRK_Build, 4671 /// Instantiation or recovery rebuild of a for-range statement. Don't 4672 /// attempt any typo-correction. 4673 BFRK_Rebuild, 4674 /// Determining whether a for-range statement could be built. Avoid any 4675 /// unnecessary or irreversible actions. 4676 BFRK_Check 4677 }; 4678 4679 StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, 4680 SourceLocation CoawaitLoc, 4681 Stmt *InitStmt, 4682 Stmt *LoopVar, 4683 SourceLocation ColonLoc, Expr *Collection, 4684 SourceLocation RParenLoc, 4685 BuildForRangeKind Kind); 4686 StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc, 4687 SourceLocation CoawaitLoc, 4688 Stmt *InitStmt, 4689 SourceLocation ColonLoc, 4690 Stmt *RangeDecl, Stmt *Begin, Stmt *End, 4691 Expr *Cond, Expr *Inc, 4692 Stmt *LoopVarDecl, 4693 SourceLocation RParenLoc, 4694 BuildForRangeKind Kind); 4695 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body); 4696 4697 StmtResult ActOnGotoStmt(SourceLocation GotoLoc, 4698 SourceLocation LabelLoc, 4699 LabelDecl *TheDecl); 4700 StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, 4701 SourceLocation StarLoc, 4702 Expr *DestExp); 4703 StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope); 4704 StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope); 4705 4706 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, 4707 CapturedRegionKind Kind, unsigned NumParams); 4708 typedef std::pair<StringRef, QualType> CapturedParamNameType; 4709 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, 4710 CapturedRegionKind Kind, 4711 ArrayRef<CapturedParamNameType> Params, 4712 unsigned OpenMPCaptureLevel = 0); 4713 StmtResult ActOnCapturedRegionEnd(Stmt *S); 4714 void ActOnCapturedRegionError(); 4715 RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD, 4716 SourceLocation Loc, 4717 unsigned NumParams); 4718 4719 enum CopyElisionSemanticsKind { 4720 CES_Strict = 0, 4721 CES_AllowParameters = 1, 4722 CES_AllowDifferentTypes = 2, 4723 CES_AllowExceptionVariables = 4, 4724 CES_FormerDefault = (CES_AllowParameters), 4725 CES_Default = (CES_AllowParameters | CES_AllowDifferentTypes), 4726 CES_AsIfByStdMove = (CES_AllowParameters | CES_AllowDifferentTypes | 4727 CES_AllowExceptionVariables), 4728 }; 4729 4730 VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E, 4731 CopyElisionSemanticsKind CESK); 4732 bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD, 4733 CopyElisionSemanticsKind CESK); 4734 4735 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, 4736 Scope *CurScope); 4737 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp); 4738 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp); 4739 4740 StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, 4741 bool IsVolatile, unsigned NumOutputs, 4742 unsigned NumInputs, IdentifierInfo **Names, 4743 MultiExprArg Constraints, MultiExprArg Exprs, 4744 Expr *AsmString, MultiExprArg Clobbers, 4745 unsigned NumLabels, 4746 SourceLocation RParenLoc); 4747 4748 void FillInlineAsmIdentifierInfo(Expr *Res, 4749 llvm::InlineAsmIdentifierInfo &Info); 4750 ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS, 4751 SourceLocation TemplateKWLoc, 4752 UnqualifiedId &Id, 4753 bool IsUnevaluatedContext); 4754 bool LookupInlineAsmField(StringRef Base, StringRef Member, 4755 unsigned &Offset, SourceLocation AsmLoc); 4756 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member, 4757 SourceLocation AsmLoc); 4758 StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, 4759 ArrayRef<Token> AsmToks, 4760 StringRef AsmString, 4761 unsigned NumOutputs, unsigned NumInputs, 4762 ArrayRef<StringRef> Constraints, 4763 ArrayRef<StringRef> Clobbers, 4764 ArrayRef<Expr*> Exprs, 4765 SourceLocation EndLoc); 4766 LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName, 4767 SourceLocation Location, 4768 bool AlwaysCreate); 4769 4770 VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType, 4771 SourceLocation StartLoc, 4772 SourceLocation IdLoc, IdentifierInfo *Id, 4773 bool Invalid = false); 4774 4775 Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D); 4776 4777 StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen, 4778 Decl *Parm, Stmt *Body); 4779 4780 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body); 4781 4782 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try, 4783 MultiStmtArg Catch, Stmt *Finally); 4784 4785 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw); 4786 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw, 4787 Scope *CurScope); 4788 ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, 4789 Expr *operand); 4790 StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, 4791 Expr *SynchExpr, 4792 Stmt *SynchBody); 4793 4794 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body); 4795 4796 VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, 4797 SourceLocation StartLoc, 4798 SourceLocation IdLoc, 4799 IdentifierInfo *Id); 4800 4801 Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D); 4802 4803 StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc, 4804 Decl *ExDecl, Stmt *HandlerBlock); 4805 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, 4806 ArrayRef<Stmt *> Handlers); 4807 4808 StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ? 4809 SourceLocation TryLoc, Stmt *TryBlock, 4810 Stmt *Handler); 4811 StmtResult ActOnSEHExceptBlock(SourceLocation Loc, 4812 Expr *FilterExpr, 4813 Stmt *Block); 4814 void ActOnStartSEHFinallyBlock(); 4815 void ActOnAbortSEHFinallyBlock(); 4816 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block); 4817 StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope); 4818 4819 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock); 4820 4821 bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const; 4822 4823 /// If it's a file scoped decl that must warn if not used, keep track 4824 /// of it. 4825 void MarkUnusedFileScopedDecl(const DeclaratorDecl *D); 4826 4827 /// DiagnoseUnusedExprResult - If the statement passed in is an expression 4828 /// whose result is unused, warn. 4829 void DiagnoseUnusedExprResult(const Stmt *S); 4830 void DiagnoseUnusedNestedTypedefs(const RecordDecl *D); 4831 void DiagnoseUnusedDecl(const NamedDecl *ND); 4832 4833 /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null 4834 /// statement as a \p Body, and it is located on the same line. 4835 /// 4836 /// This helps prevent bugs due to typos, such as: 4837 /// if (condition); 4838 /// do_stuff(); 4839 void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, 4840 const Stmt *Body, 4841 unsigned DiagID); 4842 4843 /// Warn if a for/while loop statement \p S, which is followed by 4844 /// \p PossibleBody, has a suspicious null statement as a body. 4845 void DiagnoseEmptyLoopBody(const Stmt *S, 4846 const Stmt *PossibleBody); 4847 4848 /// Warn if a value is moved to itself. 4849 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, 4850 SourceLocation OpLoc); 4851 4852 /// Warn if we're implicitly casting from a _Nullable pointer type to a 4853 /// _Nonnull one. 4854 void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, 4855 SourceLocation Loc); 4856 4857 /// Warn when implicitly casting 0 to nullptr. 4858 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E); 4859 PushParsingDeclaration(sema::DelayedDiagnosticPool & pool)4860 ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) { 4861 return DelayedDiagnostics.push(pool); 4862 } 4863 void PopParsingDeclaration(ParsingDeclState state, Decl *decl); 4864 4865 typedef ProcessingContextState ParsingClassState; PushParsingClass()4866 ParsingClassState PushParsingClass() { 4867 ParsingClassDepth++; 4868 return DelayedDiagnostics.pushUndelayed(); 4869 } PopParsingClass(ParsingClassState state)4870 void PopParsingClass(ParsingClassState state) { 4871 ParsingClassDepth--; 4872 DelayedDiagnostics.popUndelayed(state); 4873 } 4874 4875 void redelayDiagnostics(sema::DelayedDiagnosticPool &pool); 4876 4877 void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, 4878 const ObjCInterfaceDecl *UnknownObjCClass, 4879 bool ObjCPropertyAccess, 4880 bool AvoidPartialAvailabilityChecks = false, 4881 ObjCInterfaceDecl *ClassReceiver = nullptr); 4882 4883 bool makeUnavailableInSystemHeader(SourceLocation loc, 4884 UnavailableAttr::ImplicitReason reason); 4885 4886 /// Issue any -Wunguarded-availability warnings in \c FD 4887 void DiagnoseUnguardedAvailabilityViolations(Decl *FD); 4888 4889 void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx); 4890 4891 //===--------------------------------------------------------------------===// 4892 // Expression Parsing Callbacks: SemaExpr.cpp. 4893 4894 bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid); 4895 bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, 4896 const ObjCInterfaceDecl *UnknownObjCClass = nullptr, 4897 bool ObjCPropertyAccess = false, 4898 bool AvoidPartialAvailabilityChecks = false, 4899 ObjCInterfaceDecl *ClassReciever = nullptr); 4900 void NoteDeletedFunction(FunctionDecl *FD); 4901 void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD); 4902 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD, 4903 ObjCMethodDecl *Getter, 4904 SourceLocation Loc); 4905 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 4906 ArrayRef<Expr *> Args); 4907 4908 void PushExpressionEvaluationContext( 4909 ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr, 4910 ExpressionEvaluationContextRecord::ExpressionKind Type = 4911 ExpressionEvaluationContextRecord::EK_Other); 4912 enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl }; 4913 void PushExpressionEvaluationContext( 4914 ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t, 4915 ExpressionEvaluationContextRecord::ExpressionKind Type = 4916 ExpressionEvaluationContextRecord::EK_Other); 4917 void PopExpressionEvaluationContext(); 4918 4919 void DiscardCleanupsInEvaluationContext(); 4920 4921 ExprResult TransformToPotentiallyEvaluated(Expr *E); 4922 ExprResult HandleExprEvaluationContextForTypeof(Expr *E); 4923 4924 ExprResult CheckUnevaluatedOperand(Expr *E); 4925 void CheckUnusedVolatileAssignment(Expr *E); 4926 4927 ExprResult ActOnConstantExpression(ExprResult Res); 4928 4929 // Functions for marking a declaration referenced. These functions also 4930 // contain the relevant logic for marking if a reference to a function or 4931 // variable is an odr-use (in the C++11 sense). There are separate variants 4932 // for expressions referring to a decl; these exist because odr-use marking 4933 // needs to be delayed for some constant variables when we build one of the 4934 // named expressions. 4935 // 4936 // MightBeOdrUse indicates whether the use could possibly be an odr-use, and 4937 // should usually be true. This only needs to be set to false if the lack of 4938 // odr-use cannot be determined from the current context (for instance, 4939 // because the name denotes a virtual function and was written without an 4940 // explicit nested-name-specifier). 4941 void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse); 4942 void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, 4943 bool MightBeOdrUse = true); 4944 void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var); 4945 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr); 4946 void MarkMemberReferenced(MemberExpr *E); 4947 void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E); 4948 void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc, 4949 unsigned CapturingScopeIndex); 4950 4951 ExprResult CheckLValueToRValueConversionOperand(Expr *E); 4952 void CleanupVarDeclMarking(); 4953 4954 enum TryCaptureKind { 4955 TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef 4956 }; 4957 4958 /// Try to capture the given variable. 4959 /// 4960 /// \param Var The variable to capture. 4961 /// 4962 /// \param Loc The location at which the capture occurs. 4963 /// 4964 /// \param Kind The kind of capture, which may be implicit (for either a 4965 /// block or a lambda), or explicit by-value or by-reference (for a lambda). 4966 /// 4967 /// \param EllipsisLoc The location of the ellipsis, if one is provided in 4968 /// an explicit lambda capture. 4969 /// 4970 /// \param BuildAndDiagnose Whether we are actually supposed to add the 4971 /// captures or diagnose errors. If false, this routine merely check whether 4972 /// the capture can occur without performing the capture itself or complaining 4973 /// if the variable cannot be captured. 4974 /// 4975 /// \param CaptureType Will be set to the type of the field used to capture 4976 /// this variable in the innermost block or lambda. Only valid when the 4977 /// variable can be captured. 4978 /// 4979 /// \param DeclRefType Will be set to the type of a reference to the capture 4980 /// from within the current scope. Only valid when the variable can be 4981 /// captured. 4982 /// 4983 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index 4984 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture. 4985 /// This is useful when enclosing lambdas must speculatively capture 4986 /// variables that may or may not be used in certain specializations of 4987 /// a nested generic lambda. 4988 /// 4989 /// \returns true if an error occurred (i.e., the variable cannot be 4990 /// captured) and false if the capture succeeded. 4991 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, 4992 SourceLocation EllipsisLoc, bool BuildAndDiagnose, 4993 QualType &CaptureType, 4994 QualType &DeclRefType, 4995 const unsigned *const FunctionScopeIndexToStopAt); 4996 4997 /// Try to capture the given variable. 4998 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, 4999 TryCaptureKind Kind = TryCapture_Implicit, 5000 SourceLocation EllipsisLoc = SourceLocation()); 5001 5002 /// Checks if the variable must be captured. 5003 bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc); 5004 5005 /// Given a variable, determine the type that a reference to that 5006 /// variable will have in the given scope. 5007 QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc); 5008 5009 /// Mark all of the declarations referenced within a particular AST node as 5010 /// referenced. Used when template instantiation instantiates a non-dependent 5011 /// type -- entities referenced by the type are now referenced. 5012 void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T); 5013 void MarkDeclarationsReferencedInExpr(Expr *E, 5014 bool SkipLocalVariables = false); 5015 5016 /// Try to recover by turning the given expression into a 5017 /// call. Returns true if recovery was attempted or an error was 5018 /// emitted; this may also leave the ExprResult invalid. 5019 bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, 5020 bool ForceComplain = false, 5021 bool (*IsPlausibleResult)(QualType) = nullptr); 5022 5023 /// Figure out if an expression could be turned into a call. 5024 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, 5025 UnresolvedSetImpl &NonTemplateOverloads); 5026 5027 /// Try to convert an expression \p E to type \p Ty. Returns the result of the 5028 /// conversion. 5029 ExprResult tryConvertExprToType(Expr *E, QualType Ty); 5030 5031 /// Conditionally issue a diagnostic based on the current 5032 /// evaluation context. 5033 /// 5034 /// \param Statement If Statement is non-null, delay reporting the 5035 /// diagnostic until the function body is parsed, and then do a basic 5036 /// reachability analysis to determine if the statement is reachable. 5037 /// If it is unreachable, the diagnostic will not be emitted. 5038 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, 5039 const PartialDiagnostic &PD); 5040 /// Similar, but diagnostic is only produced if all the specified statements 5041 /// are reachable. 5042 bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts, 5043 const PartialDiagnostic &PD); 5044 5045 // Primary Expressions. 5046 SourceRange getExprRange(Expr *E) const; 5047 5048 ExprResult ActOnIdExpression( 5049 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 5050 UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, 5051 CorrectionCandidateCallback *CCC = nullptr, 5052 bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr); 5053 5054 void DecomposeUnqualifiedId(const UnqualifiedId &Id, 5055 TemplateArgumentListInfo &Buffer, 5056 DeclarationNameInfo &NameInfo, 5057 const TemplateArgumentListInfo *&TemplateArgs); 5058 5059 bool DiagnoseDependentMemberLookup(LookupResult &R); 5060 5061 bool 5062 DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 5063 CorrectionCandidateCallback &CCC, 5064 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr, 5065 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr); 5066 5067 DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, 5068 IdentifierInfo *II); 5069 ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV); 5070 5071 ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, 5072 IdentifierInfo *II, 5073 bool AllowBuiltinCreation=false); 5074 5075 ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, 5076 SourceLocation TemplateKWLoc, 5077 const DeclarationNameInfo &NameInfo, 5078 bool isAddressOfOperand, 5079 const TemplateArgumentListInfo *TemplateArgs); 5080 5081 /// If \p D cannot be odr-used in the current expression evaluation context, 5082 /// return a reason explaining why. Otherwise, return NOUR_None. 5083 NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D); 5084 5085 DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 5086 SourceLocation Loc, 5087 const CXXScopeSpec *SS = nullptr); 5088 DeclRefExpr * 5089 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 5090 const DeclarationNameInfo &NameInfo, 5091 const CXXScopeSpec *SS = nullptr, 5092 NamedDecl *FoundD = nullptr, 5093 SourceLocation TemplateKWLoc = SourceLocation(), 5094 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5095 DeclRefExpr * 5096 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 5097 const DeclarationNameInfo &NameInfo, 5098 NestedNameSpecifierLoc NNS, 5099 NamedDecl *FoundD = nullptr, 5100 SourceLocation TemplateKWLoc = SourceLocation(), 5101 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5102 5103 ExprResult 5104 BuildAnonymousStructUnionMemberReference( 5105 const CXXScopeSpec &SS, 5106 SourceLocation nameLoc, 5107 IndirectFieldDecl *indirectField, 5108 DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none), 5109 Expr *baseObjectExpr = nullptr, 5110 SourceLocation opLoc = SourceLocation()); 5111 5112 ExprResult BuildPossibleImplicitMemberExpr( 5113 const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, 5114 const TemplateArgumentListInfo *TemplateArgs, const Scope *S, 5115 UnresolvedLookupExpr *AsULE = nullptr); 5116 ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS, 5117 SourceLocation TemplateKWLoc, 5118 LookupResult &R, 5119 const TemplateArgumentListInfo *TemplateArgs, 5120 bool IsDefiniteInstance, 5121 const Scope *S); 5122 bool UseArgumentDependentLookup(const CXXScopeSpec &SS, 5123 const LookupResult &R, 5124 bool HasTrailingLParen); 5125 5126 ExprResult 5127 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 5128 const DeclarationNameInfo &NameInfo, 5129 bool IsAddressOfOperand, const Scope *S, 5130 TypeSourceInfo **RecoveryTSI = nullptr); 5131 5132 ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, 5133 SourceLocation TemplateKWLoc, 5134 const DeclarationNameInfo &NameInfo, 5135 const TemplateArgumentListInfo *TemplateArgs); 5136 5137 ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, 5138 LookupResult &R, 5139 bool NeedsADL, 5140 bool AcceptInvalidDecl = false); 5141 ExprResult BuildDeclarationNameExpr( 5142 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D, 5143 NamedDecl *FoundD = nullptr, 5144 const TemplateArgumentListInfo *TemplateArgs = nullptr, 5145 bool AcceptInvalidDecl = false); 5146 5147 ExprResult BuildLiteralOperatorCall(LookupResult &R, 5148 DeclarationNameInfo &SuffixInfo, 5149 ArrayRef<Expr *> Args, 5150 SourceLocation LitEndLoc, 5151 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr); 5152 5153 ExprResult BuildPredefinedExpr(SourceLocation Loc, 5154 PredefinedExpr::IdentKind IK); 5155 ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind); 5156 ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val); 5157 5158 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc); 5159 5160 ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr); 5161 ExprResult ActOnCharacterConstant(const Token &Tok, 5162 Scope *UDLScope = nullptr); 5163 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E); 5164 ExprResult ActOnParenListExpr(SourceLocation L, 5165 SourceLocation R, 5166 MultiExprArg Val); 5167 5168 /// ActOnStringLiteral - The specified tokens were lexed as pasted string 5169 /// fragments (e.g. "foo" "bar" L"baz"). 5170 ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks, 5171 Scope *UDLScope = nullptr); 5172 5173 ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, 5174 SourceLocation DefaultLoc, 5175 SourceLocation RParenLoc, 5176 Expr *ControllingExpr, 5177 ArrayRef<ParsedType> ArgTypes, 5178 ArrayRef<Expr *> ArgExprs); 5179 ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, 5180 SourceLocation DefaultLoc, 5181 SourceLocation RParenLoc, 5182 Expr *ControllingExpr, 5183 ArrayRef<TypeSourceInfo *> Types, 5184 ArrayRef<Expr *> Exprs); 5185 5186 // Binary/Unary Operators. 'Tok' is the token for the operator. 5187 ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, 5188 Expr *InputExpr); 5189 ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, 5190 UnaryOperatorKind Opc, Expr *Input); 5191 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 5192 tok::TokenKind Op, Expr *Input); 5193 5194 bool isQualifiedMemberAccess(Expr *E); 5195 QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc); 5196 5197 ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 5198 SourceLocation OpLoc, 5199 UnaryExprOrTypeTrait ExprKind, 5200 SourceRange R); 5201 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 5202 UnaryExprOrTypeTrait ExprKind); 5203 ExprResult 5204 ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 5205 UnaryExprOrTypeTrait ExprKind, 5206 bool IsType, void *TyOrEx, 5207 SourceRange ArgRange); 5208 5209 ExprResult CheckPlaceholderExpr(Expr *E); 5210 bool CheckVecStepExpr(Expr *E); 5211 5212 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind); 5213 bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc, 5214 SourceRange ExprRange, 5215 UnaryExprOrTypeTrait ExprKind); 5216 ExprResult ActOnSizeofParameterPackExpr(Scope *S, 5217 SourceLocation OpLoc, 5218 IdentifierInfo &Name, 5219 SourceLocation NameLoc, 5220 SourceLocation RParenLoc); 5221 ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 5222 tok::TokenKind Kind, Expr *Input); 5223 5224 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 5225 Expr *Idx, SourceLocation RLoc); 5226 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 5227 Expr *Idx, SourceLocation RLoc); 5228 5229 ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx, 5230 Expr *ColumnIdx, 5231 SourceLocation RBLoc); 5232 5233 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, 5234 Expr *LowerBound, 5235 SourceLocation ColonLocFirst, 5236 SourceLocation ColonLocSecond, 5237 Expr *Length, Expr *Stride, 5238 SourceLocation RBLoc); 5239 ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc, 5240 SourceLocation RParenLoc, 5241 ArrayRef<Expr *> Dims, 5242 ArrayRef<SourceRange> Brackets); 5243 5244 /// Data structure for iterator expression. 5245 struct OMPIteratorData { 5246 IdentifierInfo *DeclIdent = nullptr; 5247 SourceLocation DeclIdentLoc; 5248 ParsedType Type; 5249 OMPIteratorExpr::IteratorRange Range; 5250 SourceLocation AssignLoc; 5251 SourceLocation ColonLoc; 5252 SourceLocation SecColonLoc; 5253 }; 5254 5255 ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc, 5256 SourceLocation LLoc, SourceLocation RLoc, 5257 ArrayRef<OMPIteratorData> Data); 5258 5259 // This struct is for use by ActOnMemberAccess to allow 5260 // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after 5261 // changing the access operator from a '.' to a '->' (to see if that is the 5262 // change needed to fix an error about an unknown member, e.g. when the class 5263 // defines a custom operator->). 5264 struct ActOnMemberAccessExtraArgs { 5265 Scope *S; 5266 UnqualifiedId &Id; 5267 Decl *ObjCImpDecl; 5268 }; 5269 5270 ExprResult BuildMemberReferenceExpr( 5271 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, 5272 CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 5273 NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, 5274 const TemplateArgumentListInfo *TemplateArgs, 5275 const Scope *S, 5276 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr); 5277 5278 ExprResult 5279 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, 5280 bool IsArrow, const CXXScopeSpec &SS, 5281 SourceLocation TemplateKWLoc, 5282 NamedDecl *FirstQualifierInScope, LookupResult &R, 5283 const TemplateArgumentListInfo *TemplateArgs, 5284 const Scope *S, 5285 bool SuppressQualifierCheck = false, 5286 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr); 5287 5288 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, 5289 SourceLocation OpLoc, 5290 const CXXScopeSpec &SS, FieldDecl *Field, 5291 DeclAccessPair FoundDecl, 5292 const DeclarationNameInfo &MemberNameInfo); 5293 5294 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow); 5295 5296 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType, 5297 const CXXScopeSpec &SS, 5298 const LookupResult &R); 5299 5300 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType, 5301 bool IsArrow, SourceLocation OpLoc, 5302 const CXXScopeSpec &SS, 5303 SourceLocation TemplateKWLoc, 5304 NamedDecl *FirstQualifierInScope, 5305 const DeclarationNameInfo &NameInfo, 5306 const TemplateArgumentListInfo *TemplateArgs); 5307 5308 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base, 5309 SourceLocation OpLoc, 5310 tok::TokenKind OpKind, 5311 CXXScopeSpec &SS, 5312 SourceLocation TemplateKWLoc, 5313 UnqualifiedId &Member, 5314 Decl *ObjCImpDecl); 5315 5316 MemberExpr * 5317 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, 5318 const CXXScopeSpec *SS, SourceLocation TemplateKWLoc, 5319 ValueDecl *Member, DeclAccessPair FoundDecl, 5320 bool HadMultipleCandidates, 5321 const DeclarationNameInfo &MemberNameInfo, QualType Ty, 5322 ExprValueKind VK, ExprObjectKind OK, 5323 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5324 MemberExpr * 5325 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, 5326 NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, 5327 ValueDecl *Member, DeclAccessPair FoundDecl, 5328 bool HadMultipleCandidates, 5329 const DeclarationNameInfo &MemberNameInfo, QualType Ty, 5330 ExprValueKind VK, ExprObjectKind OK, 5331 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5332 5333 void ActOnDefaultCtorInitializers(Decl *CDtorDecl); 5334 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 5335 FunctionDecl *FDecl, 5336 const FunctionProtoType *Proto, 5337 ArrayRef<Expr *> Args, 5338 SourceLocation RParenLoc, 5339 bool ExecConfig = false); 5340 void CheckStaticArrayArgument(SourceLocation CallLoc, 5341 ParmVarDecl *Param, 5342 const Expr *ArgExpr); 5343 5344 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 5345 /// This provides the location of the left/right parens and a list of comma 5346 /// locations. 5347 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 5348 MultiExprArg ArgExprs, SourceLocation RParenLoc, 5349 Expr *ExecConfig = nullptr); 5350 ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 5351 MultiExprArg ArgExprs, SourceLocation RParenLoc, 5352 Expr *ExecConfig = nullptr, 5353 bool IsExecConfig = false, 5354 bool AllowRecovery = false); 5355 enum class AtomicArgumentOrder { API, AST }; 5356 ExprResult 5357 BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, 5358 SourceLocation RParenLoc, MultiExprArg Args, 5359 AtomicExpr::AtomicOp Op, 5360 AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API); 5361 ExprResult 5362 BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, 5363 ArrayRef<Expr *> Arg, SourceLocation RParenLoc, 5364 Expr *Config = nullptr, bool IsExecConfig = false, 5365 ADLCallKind UsesADL = ADLCallKind::NotADL); 5366 5367 ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 5368 MultiExprArg ExecConfig, 5369 SourceLocation GGGLoc); 5370 5371 ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 5372 Declarator &D, ParsedType &Ty, 5373 SourceLocation RParenLoc, Expr *CastExpr); 5374 ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, 5375 TypeSourceInfo *Ty, 5376 SourceLocation RParenLoc, 5377 Expr *Op); 5378 CastKind PrepareScalarCast(ExprResult &src, QualType destType); 5379 5380 /// Build an altivec or OpenCL literal. 5381 ExprResult BuildVectorLiteral(SourceLocation LParenLoc, 5382 SourceLocation RParenLoc, Expr *E, 5383 TypeSourceInfo *TInfo); 5384 5385 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME); 5386 5387 ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, 5388 ParsedType Ty, 5389 SourceLocation RParenLoc, 5390 Expr *InitExpr); 5391 5392 ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, 5393 TypeSourceInfo *TInfo, 5394 SourceLocation RParenLoc, 5395 Expr *LiteralExpr); 5396 5397 ExprResult ActOnInitList(SourceLocation LBraceLoc, 5398 MultiExprArg InitArgList, 5399 SourceLocation RBraceLoc); 5400 5401 ExprResult BuildInitList(SourceLocation LBraceLoc, 5402 MultiExprArg InitArgList, 5403 SourceLocation RBraceLoc); 5404 5405 ExprResult ActOnDesignatedInitializer(Designation &Desig, 5406 SourceLocation EqualOrColonLoc, 5407 bool GNUSyntax, 5408 ExprResult Init); 5409 5410 private: 5411 static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind); 5412 5413 public: 5414 ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, 5415 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr); 5416 ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, 5417 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr); 5418 ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, 5419 Expr *LHSExpr, Expr *RHSExpr); 5420 void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, 5421 UnresolvedSetImpl &Functions); 5422 5423 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc); 5424 5425 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 5426 /// in the case of a the GNU conditional expr extension. 5427 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, 5428 SourceLocation ColonLoc, 5429 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr); 5430 5431 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 5432 ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 5433 LabelDecl *TheDecl); 5434 5435 void ActOnStartStmtExpr(); 5436 ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt, 5437 SourceLocation RPLoc); 5438 ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 5439 SourceLocation RPLoc, unsigned TemplateDepth); 5440 // Handle the final expression in a statement expression. 5441 ExprResult ActOnStmtExprResult(ExprResult E); 5442 void ActOnStmtExprError(); 5443 5444 // __builtin_offsetof(type, identifier(.identifier|[expr])*) 5445 struct OffsetOfComponent { 5446 SourceLocation LocStart, LocEnd; 5447 bool isBrackets; // true if [expr], false if .ident 5448 union { 5449 IdentifierInfo *IdentInfo; 5450 Expr *E; 5451 } U; 5452 }; 5453 5454 /// __builtin_offsetof(type, a.b[123][456].c) 5455 ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 5456 TypeSourceInfo *TInfo, 5457 ArrayRef<OffsetOfComponent> Components, 5458 SourceLocation RParenLoc); 5459 ExprResult ActOnBuiltinOffsetOf(Scope *S, 5460 SourceLocation BuiltinLoc, 5461 SourceLocation TypeLoc, 5462 ParsedType ParsedArgTy, 5463 ArrayRef<OffsetOfComponent> Components, 5464 SourceLocation RParenLoc); 5465 5466 // __builtin_choose_expr(constExpr, expr1, expr2) 5467 ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, 5468 Expr *CondExpr, Expr *LHSExpr, 5469 Expr *RHSExpr, SourceLocation RPLoc); 5470 5471 // __builtin_va_arg(expr, type) 5472 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, 5473 SourceLocation RPLoc); 5474 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, 5475 TypeSourceInfo *TInfo, SourceLocation RPLoc); 5476 5477 // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(), 5478 // __builtin_COLUMN() 5479 ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind, 5480 SourceLocation BuiltinLoc, 5481 SourceLocation RPLoc); 5482 5483 // Build a potentially resolved SourceLocExpr. 5484 ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind, 5485 SourceLocation BuiltinLoc, SourceLocation RPLoc, 5486 DeclContext *ParentContext); 5487 5488 // __null 5489 ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc); 5490 5491 bool CheckCaseExpression(Expr *E); 5492 5493 /// Describes the result of an "if-exists" condition check. 5494 enum IfExistsResult { 5495 /// The symbol exists. 5496 IER_Exists, 5497 5498 /// The symbol does not exist. 5499 IER_DoesNotExist, 5500 5501 /// The name is a dependent name, so the results will differ 5502 /// from one instantiation to the next. 5503 IER_Dependent, 5504 5505 /// An error occurred. 5506 IER_Error 5507 }; 5508 5509 IfExistsResult 5510 CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, 5511 const DeclarationNameInfo &TargetNameInfo); 5512 5513 IfExistsResult 5514 CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc, 5515 bool IsIfExists, CXXScopeSpec &SS, 5516 UnqualifiedId &Name); 5517 5518 StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc, 5519 bool IsIfExists, 5520 NestedNameSpecifierLoc QualifierLoc, 5521 DeclarationNameInfo NameInfo, 5522 Stmt *Nested); 5523 StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, 5524 bool IsIfExists, 5525 CXXScopeSpec &SS, UnqualifiedId &Name, 5526 Stmt *Nested); 5527 5528 //===------------------------- "Block" Extension ------------------------===// 5529 5530 /// ActOnBlockStart - This callback is invoked when a block literal is 5531 /// started. 5532 void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope); 5533 5534 /// ActOnBlockArguments - This callback allows processing of block arguments. 5535 /// If there are no arguments, this is still invoked. 5536 void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, 5537 Scope *CurScope); 5538 5539 /// ActOnBlockError - If there is an error parsing a block, this callback 5540 /// is invoked to pop the information about the block from the action impl. 5541 void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope); 5542 5543 /// ActOnBlockStmtExpr - This is called when the body of a block statement 5544 /// literal was successfully completed. ^(int x){...} 5545 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, 5546 Scope *CurScope); 5547 5548 //===---------------------------- Clang Extensions ----------------------===// 5549 5550 /// __builtin_convertvector(...) 5551 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, 5552 SourceLocation BuiltinLoc, 5553 SourceLocation RParenLoc); 5554 5555 //===---------------------------- OpenCL Features -----------------------===// 5556 5557 /// __builtin_astype(...) 5558 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 5559 SourceLocation BuiltinLoc, 5560 SourceLocation RParenLoc); 5561 5562 //===---------------------------- C++ Features --------------------------===// 5563 5564 // Act on C++ namespaces 5565 Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, 5566 SourceLocation NamespaceLoc, 5567 SourceLocation IdentLoc, IdentifierInfo *Ident, 5568 SourceLocation LBrace, 5569 const ParsedAttributesView &AttrList, 5570 UsingDirectiveDecl *&UsingDecl); 5571 void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace); 5572 5573 NamespaceDecl *getStdNamespace() const; 5574 NamespaceDecl *getOrCreateStdNamespace(); 5575 5576 NamespaceDecl *lookupStdExperimentalNamespace(); 5577 5578 CXXRecordDecl *getStdBadAlloc() const; 5579 EnumDecl *getStdAlignValT() const; 5580 5581 private: 5582 // A cache representing if we've fully checked the various comparison category 5583 // types stored in ASTContext. The bit-index corresponds to the integer value 5584 // of a ComparisonCategoryType enumerator. 5585 llvm::SmallBitVector FullyCheckedComparisonCategories; 5586 5587 ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl, 5588 CXXScopeSpec &SS, 5589 ParsedType TemplateTypeTy, 5590 IdentifierInfo *MemberOrBase); 5591 5592 public: 5593 enum class ComparisonCategoryUsage { 5594 /// The '<=>' operator was used in an expression and a builtin operator 5595 /// was selected. 5596 OperatorInExpression, 5597 /// A defaulted 'operator<=>' needed the comparison category. This 5598 /// typically only applies to 'std::strong_ordering', due to the implicit 5599 /// fallback return value. 5600 DefaultedOperator, 5601 }; 5602 5603 /// Lookup the specified comparison category types in the standard 5604 /// library, an check the VarDecls possibly returned by the operator<=> 5605 /// builtins for that type. 5606 /// 5607 /// \return The type of the comparison category type corresponding to the 5608 /// specified Kind, or a null type if an error occurs 5609 QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, 5610 SourceLocation Loc, 5611 ComparisonCategoryUsage Usage); 5612 5613 /// Tests whether Ty is an instance of std::initializer_list and, if 5614 /// it is and Element is not NULL, assigns the element type to Element. 5615 bool isStdInitializerList(QualType Ty, QualType *Element); 5616 5617 /// Looks for the std::initializer_list template and instantiates it 5618 /// with Element, or emits an error if it's not found. 5619 /// 5620 /// \returns The instantiated template, or null on error. 5621 QualType BuildStdInitializerList(QualType Element, SourceLocation Loc); 5622 5623 /// Determine whether Ctor is an initializer-list constructor, as 5624 /// defined in [dcl.init.list]p2. 5625 bool isInitListConstructor(const FunctionDecl *Ctor); 5626 5627 Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, 5628 SourceLocation NamespcLoc, CXXScopeSpec &SS, 5629 SourceLocation IdentLoc, 5630 IdentifierInfo *NamespcName, 5631 const ParsedAttributesView &AttrList); 5632 5633 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir); 5634 5635 Decl *ActOnNamespaceAliasDef(Scope *CurScope, 5636 SourceLocation NamespaceLoc, 5637 SourceLocation AliasLoc, 5638 IdentifierInfo *Alias, 5639 CXXScopeSpec &SS, 5640 SourceLocation IdentLoc, 5641 IdentifierInfo *Ident); 5642 5643 void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow); 5644 bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target, 5645 const LookupResult &PreviousDecls, 5646 UsingShadowDecl *&PrevShadow); 5647 UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD, 5648 NamedDecl *Target, 5649 UsingShadowDecl *PrevDecl); 5650 5651 bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, 5652 bool HasTypenameKeyword, 5653 const CXXScopeSpec &SS, 5654 SourceLocation NameLoc, 5655 const LookupResult &Previous); 5656 bool CheckUsingDeclQualifier(SourceLocation UsingLoc, 5657 bool HasTypename, 5658 const CXXScopeSpec &SS, 5659 const DeclarationNameInfo &NameInfo, 5660 SourceLocation NameLoc); 5661 5662 NamedDecl *BuildUsingDeclaration( 5663 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, 5664 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, 5665 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, 5666 const ParsedAttributesView &AttrList, bool IsInstantiation); 5667 NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom, 5668 ArrayRef<NamedDecl *> Expansions); 5669 5670 bool CheckInheritingConstructorUsingDecl(UsingDecl *UD); 5671 5672 /// Given a derived-class using shadow declaration for a constructor and the 5673 /// correspnding base class constructor, find or create the implicit 5674 /// synthesized derived class constructor to use for this initialization. 5675 CXXConstructorDecl * 5676 findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, 5677 ConstructorUsingShadowDecl *DerivedShadow); 5678 5679 Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, 5680 SourceLocation UsingLoc, 5681 SourceLocation TypenameLoc, CXXScopeSpec &SS, 5682 UnqualifiedId &Name, SourceLocation EllipsisLoc, 5683 const ParsedAttributesView &AttrList); 5684 Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, 5685 MultiTemplateParamsArg TemplateParams, 5686 SourceLocation UsingLoc, UnqualifiedId &Name, 5687 const ParsedAttributesView &AttrList, 5688 TypeResult Type, Decl *DeclFromDeclSpec); 5689 5690 /// BuildCXXConstructExpr - Creates a complete call to a constructor, 5691 /// including handling of its default argument expressions. 5692 /// 5693 /// \param ConstructKind - a CXXConstructExpr::ConstructionKind 5694 ExprResult 5695 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 5696 NamedDecl *FoundDecl, 5697 CXXConstructorDecl *Constructor, MultiExprArg Exprs, 5698 bool HadMultipleCandidates, bool IsListInitialization, 5699 bool IsStdInitListInitialization, 5700 bool RequiresZeroInit, unsigned ConstructKind, 5701 SourceRange ParenRange); 5702 5703 /// Build a CXXConstructExpr whose constructor has already been resolved if 5704 /// it denotes an inherited constructor. 5705 ExprResult 5706 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 5707 CXXConstructorDecl *Constructor, bool Elidable, 5708 MultiExprArg Exprs, 5709 bool HadMultipleCandidates, bool IsListInitialization, 5710 bool IsStdInitListInitialization, 5711 bool RequiresZeroInit, unsigned ConstructKind, 5712 SourceRange ParenRange); 5713 5714 // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if 5715 // the constructor can be elidable? 5716 ExprResult 5717 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 5718 NamedDecl *FoundDecl, 5719 CXXConstructorDecl *Constructor, bool Elidable, 5720 MultiExprArg Exprs, bool HadMultipleCandidates, 5721 bool IsListInitialization, 5722 bool IsStdInitListInitialization, bool RequiresZeroInit, 5723 unsigned ConstructKind, SourceRange ParenRange); 5724 5725 ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field); 5726 5727 5728 /// Instantiate or parse a C++ default argument expression as necessary. 5729 /// Return true on error. 5730 bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, 5731 ParmVarDecl *Param); 5732 5733 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating 5734 /// the default expr if needed. 5735 ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, 5736 FunctionDecl *FD, 5737 ParmVarDecl *Param); 5738 5739 /// FinalizeVarWithDestructor - Prepare for calling destructor on the 5740 /// constructed variable. 5741 void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType); 5742 5743 /// Helper class that collects exception specifications for 5744 /// implicitly-declared special member functions. 5745 class ImplicitExceptionSpecification { 5746 // Pointer to allow copying 5747 Sema *Self; 5748 // We order exception specifications thus: 5749 // noexcept is the most restrictive, but is only used in C++11. 5750 // throw() comes next. 5751 // Then a throw(collected exceptions) 5752 // Finally no specification, which is expressed as noexcept(false). 5753 // throw(...) is used instead if any called function uses it. 5754 ExceptionSpecificationType ComputedEST; 5755 llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen; 5756 SmallVector<QualType, 4> Exceptions; 5757 ClearExceptions()5758 void ClearExceptions() { 5759 ExceptionsSeen.clear(); 5760 Exceptions.clear(); 5761 } 5762 5763 public: ImplicitExceptionSpecification(Sema & Self)5764 explicit ImplicitExceptionSpecification(Sema &Self) 5765 : Self(&Self), ComputedEST(EST_BasicNoexcept) { 5766 if (!Self.getLangOpts().CPlusPlus11) 5767 ComputedEST = EST_DynamicNone; 5768 } 5769 5770 /// Get the computed exception specification type. getExceptionSpecType()5771 ExceptionSpecificationType getExceptionSpecType() const { 5772 assert(!isComputedNoexcept(ComputedEST) && 5773 "noexcept(expr) should not be a possible result"); 5774 return ComputedEST; 5775 } 5776 5777 /// The number of exceptions in the exception specification. size()5778 unsigned size() const { return Exceptions.size(); } 5779 5780 /// The set of exceptions in the exception specification. data()5781 const QualType *data() const { return Exceptions.data(); } 5782 5783 /// Integrate another called method into the collected data. 5784 void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method); 5785 5786 /// Integrate an invoked expression into the collected data. CalledExpr(Expr * E)5787 void CalledExpr(Expr *E) { CalledStmt(E); } 5788 5789 /// Integrate an invoked statement into the collected data. 5790 void CalledStmt(Stmt *S); 5791 5792 /// Overwrite an EPI's exception specification with this 5793 /// computed exception specification. getExceptionSpec()5794 FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const { 5795 FunctionProtoType::ExceptionSpecInfo ESI; 5796 ESI.Type = getExceptionSpecType(); 5797 if (ESI.Type == EST_Dynamic) { 5798 ESI.Exceptions = Exceptions; 5799 } else if (ESI.Type == EST_None) { 5800 /// C++11 [except.spec]p14: 5801 /// The exception-specification is noexcept(false) if the set of 5802 /// potential exceptions of the special member function contains "any" 5803 ESI.Type = EST_NoexceptFalse; 5804 ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(), 5805 tok::kw_false).get(); 5806 } 5807 return ESI; 5808 } 5809 }; 5810 5811 /// Evaluate the implicit exception specification for a defaulted 5812 /// special member function. 5813 void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD); 5814 5815 /// Check the given noexcept-specifier, convert its expression, and compute 5816 /// the appropriate ExceptionSpecificationType. 5817 ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr, 5818 ExceptionSpecificationType &EST); 5819 5820 /// Check the given exception-specification and update the 5821 /// exception specification information with the results. 5822 void checkExceptionSpecification(bool IsTopLevel, 5823 ExceptionSpecificationType EST, 5824 ArrayRef<ParsedType> DynamicExceptions, 5825 ArrayRef<SourceRange> DynamicExceptionRanges, 5826 Expr *NoexceptExpr, 5827 SmallVectorImpl<QualType> &Exceptions, 5828 FunctionProtoType::ExceptionSpecInfo &ESI); 5829 5830 /// Determine if we're in a case where we need to (incorrectly) eagerly 5831 /// parse an exception specification to work around a libstdc++ bug. 5832 bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D); 5833 5834 /// Add an exception-specification to the given member function 5835 /// (or member function template). The exception-specification was parsed 5836 /// after the method itself was declared. 5837 void actOnDelayedExceptionSpecification(Decl *Method, 5838 ExceptionSpecificationType EST, 5839 SourceRange SpecificationRange, 5840 ArrayRef<ParsedType> DynamicExceptions, 5841 ArrayRef<SourceRange> DynamicExceptionRanges, 5842 Expr *NoexceptExpr); 5843 5844 class InheritedConstructorInfo; 5845 5846 /// Determine if a special member function should have a deleted 5847 /// definition when it is defaulted. 5848 bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, 5849 InheritedConstructorInfo *ICI = nullptr, 5850 bool Diagnose = false); 5851 5852 /// Produce notes explaining why a defaulted function was defined as deleted. 5853 void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD); 5854 5855 /// Declare the implicit default constructor for the given class. 5856 /// 5857 /// \param ClassDecl The class declaration into which the implicit 5858 /// default constructor will be added. 5859 /// 5860 /// \returns The implicitly-declared default constructor. 5861 CXXConstructorDecl *DeclareImplicitDefaultConstructor( 5862 CXXRecordDecl *ClassDecl); 5863 5864 /// DefineImplicitDefaultConstructor - Checks for feasibility of 5865 /// defining this constructor as the default constructor. 5866 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, 5867 CXXConstructorDecl *Constructor); 5868 5869 /// Declare the implicit destructor for the given class. 5870 /// 5871 /// \param ClassDecl The class declaration into which the implicit 5872 /// destructor will be added. 5873 /// 5874 /// \returns The implicitly-declared destructor. 5875 CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl); 5876 5877 /// DefineImplicitDestructor - Checks for feasibility of 5878 /// defining this destructor as the default destructor. 5879 void DefineImplicitDestructor(SourceLocation CurrentLocation, 5880 CXXDestructorDecl *Destructor); 5881 5882 /// Build an exception spec for destructors that don't have one. 5883 /// 5884 /// C++11 says that user-defined destructors with no exception spec get one 5885 /// that looks as if the destructor was implicitly declared. 5886 void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor); 5887 5888 /// Define the specified inheriting constructor. 5889 void DefineInheritingConstructor(SourceLocation UseLoc, 5890 CXXConstructorDecl *Constructor); 5891 5892 /// Declare the implicit copy constructor for the given class. 5893 /// 5894 /// \param ClassDecl The class declaration into which the implicit 5895 /// copy constructor will be added. 5896 /// 5897 /// \returns The implicitly-declared copy constructor. 5898 CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl); 5899 5900 /// DefineImplicitCopyConstructor - Checks for feasibility of 5901 /// defining this constructor as the copy constructor. 5902 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, 5903 CXXConstructorDecl *Constructor); 5904 5905 /// Declare the implicit move constructor for the given class. 5906 /// 5907 /// \param ClassDecl The Class declaration into which the implicit 5908 /// move constructor will be added. 5909 /// 5910 /// \returns The implicitly-declared move constructor, or NULL if it wasn't 5911 /// declared. 5912 CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl); 5913 5914 /// DefineImplicitMoveConstructor - Checks for feasibility of 5915 /// defining this constructor as the move constructor. 5916 void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, 5917 CXXConstructorDecl *Constructor); 5918 5919 /// Declare the implicit copy assignment operator for the given class. 5920 /// 5921 /// \param ClassDecl The class declaration into which the implicit 5922 /// copy assignment operator will be added. 5923 /// 5924 /// \returns The implicitly-declared copy assignment operator. 5925 CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl); 5926 5927 /// Defines an implicitly-declared copy assignment operator. 5928 void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, 5929 CXXMethodDecl *MethodDecl); 5930 5931 /// Declare the implicit move assignment operator for the given class. 5932 /// 5933 /// \param ClassDecl The Class declaration into which the implicit 5934 /// move assignment operator will be added. 5935 /// 5936 /// \returns The implicitly-declared move assignment operator, or NULL if it 5937 /// wasn't declared. 5938 CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl); 5939 5940 /// Defines an implicitly-declared move assignment operator. 5941 void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, 5942 CXXMethodDecl *MethodDecl); 5943 5944 /// Force the declaration of any implicitly-declared members of this 5945 /// class. 5946 void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class); 5947 5948 /// Check a completed declaration of an implicit special member. 5949 void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD); 5950 5951 /// Determine whether the given function is an implicitly-deleted 5952 /// special member function. 5953 bool isImplicitlyDeleted(FunctionDecl *FD); 5954 5955 /// Check whether 'this' shows up in the type of a static member 5956 /// function after the (naturally empty) cv-qualifier-seq would be. 5957 /// 5958 /// \returns true if an error occurred. 5959 bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method); 5960 5961 /// Whether this' shows up in the exception specification of a static 5962 /// member function. 5963 bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method); 5964 5965 /// Check whether 'this' shows up in the attributes of the given 5966 /// static member function. 5967 /// 5968 /// \returns true if an error occurred. 5969 bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method); 5970 5971 /// MaybeBindToTemporary - If the passed in expression has a record type with 5972 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise 5973 /// it simply returns the passed in expression. 5974 ExprResult MaybeBindToTemporary(Expr *E); 5975 5976 /// Wrap the expression in a ConstantExpr if it is a potential immediate 5977 /// invocation. 5978 ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl); 5979 5980 bool CompleteConstructorCall(CXXConstructorDecl *Constructor, 5981 MultiExprArg ArgsPtr, 5982 SourceLocation Loc, 5983 SmallVectorImpl<Expr*> &ConvertedArgs, 5984 bool AllowExplicit = false, 5985 bool IsListInitialization = false); 5986 5987 ParsedType getInheritingConstructorName(CXXScopeSpec &SS, 5988 SourceLocation NameLoc, 5989 IdentifierInfo &Name); 5990 5991 ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc, 5992 Scope *S, CXXScopeSpec &SS, 5993 bool EnteringContext); 5994 ParsedType getDestructorName(SourceLocation TildeLoc, 5995 IdentifierInfo &II, SourceLocation NameLoc, 5996 Scope *S, CXXScopeSpec &SS, 5997 ParsedType ObjectType, 5998 bool EnteringContext); 5999 6000 ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, 6001 ParsedType ObjectType); 6002 6003 // Checks that reinterpret casts don't have undefined behavior. 6004 void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, 6005 bool IsDereference, SourceRange Range); 6006 6007 /// ActOnCXXNamedCast - Parse 6008 /// {dynamic,static,reinterpret,const,addrspace}_cast's. 6009 ExprResult ActOnCXXNamedCast(SourceLocation OpLoc, 6010 tok::TokenKind Kind, 6011 SourceLocation LAngleBracketLoc, 6012 Declarator &D, 6013 SourceLocation RAngleBracketLoc, 6014 SourceLocation LParenLoc, 6015 Expr *E, 6016 SourceLocation RParenLoc); 6017 6018 ExprResult BuildCXXNamedCast(SourceLocation OpLoc, 6019 tok::TokenKind Kind, 6020 TypeSourceInfo *Ty, 6021 Expr *E, 6022 SourceRange AngleBrackets, 6023 SourceRange Parens); 6024 6025 ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl, 6026 ExprResult Operand, 6027 SourceLocation RParenLoc); 6028 6029 ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI, 6030 Expr *Operand, SourceLocation RParenLoc); 6031 6032 ExprResult BuildCXXTypeId(QualType TypeInfoType, 6033 SourceLocation TypeidLoc, 6034 TypeSourceInfo *Operand, 6035 SourceLocation RParenLoc); 6036 ExprResult BuildCXXTypeId(QualType TypeInfoType, 6037 SourceLocation TypeidLoc, 6038 Expr *Operand, 6039 SourceLocation RParenLoc); 6040 6041 /// ActOnCXXTypeid - Parse typeid( something ). 6042 ExprResult ActOnCXXTypeid(SourceLocation OpLoc, 6043 SourceLocation LParenLoc, bool isType, 6044 void *TyOrExpr, 6045 SourceLocation RParenLoc); 6046 6047 ExprResult BuildCXXUuidof(QualType TypeInfoType, 6048 SourceLocation TypeidLoc, 6049 TypeSourceInfo *Operand, 6050 SourceLocation RParenLoc); 6051 ExprResult BuildCXXUuidof(QualType TypeInfoType, 6052 SourceLocation TypeidLoc, 6053 Expr *Operand, 6054 SourceLocation RParenLoc); 6055 6056 /// ActOnCXXUuidof - Parse __uuidof( something ). 6057 ExprResult ActOnCXXUuidof(SourceLocation OpLoc, 6058 SourceLocation LParenLoc, bool isType, 6059 void *TyOrExpr, 6060 SourceLocation RParenLoc); 6061 6062 /// Handle a C++1z fold-expression: ( expr op ... op expr ). 6063 ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS, 6064 tok::TokenKind Operator, 6065 SourceLocation EllipsisLoc, Expr *RHS, 6066 SourceLocation RParenLoc); 6067 ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, 6068 SourceLocation LParenLoc, Expr *LHS, 6069 BinaryOperatorKind Operator, 6070 SourceLocation EllipsisLoc, Expr *RHS, 6071 SourceLocation RParenLoc, 6072 Optional<unsigned> NumExpansions); 6073 ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, 6074 BinaryOperatorKind Operator); 6075 6076 //// ActOnCXXThis - Parse 'this' pointer. 6077 ExprResult ActOnCXXThis(SourceLocation loc); 6078 6079 /// Build a CXXThisExpr and mark it referenced in the current context. 6080 Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit); 6081 void MarkThisReferenced(CXXThisExpr *This); 6082 6083 /// Try to retrieve the type of the 'this' pointer. 6084 /// 6085 /// \returns The type of 'this', if possible. Otherwise, returns a NULL type. 6086 QualType getCurrentThisType(); 6087 6088 /// When non-NULL, the C++ 'this' expression is allowed despite the 6089 /// current context not being a non-static member function. In such cases, 6090 /// this provides the type used for 'this'. 6091 QualType CXXThisTypeOverride; 6092 6093 /// RAII object used to temporarily allow the C++ 'this' expression 6094 /// to be used, with the given qualifiers on the current class type. 6095 class CXXThisScopeRAII { 6096 Sema &S; 6097 QualType OldCXXThisTypeOverride; 6098 bool Enabled; 6099 6100 public: 6101 /// Introduce a new scope where 'this' may be allowed (when enabled), 6102 /// using the given declaration (which is either a class template or a 6103 /// class) along with the given qualifiers. 6104 /// along with the qualifiers placed on '*this'. 6105 CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals, 6106 bool Enabled = true); 6107 6108 ~CXXThisScopeRAII(); 6109 }; 6110 6111 /// Make sure the value of 'this' is actually available in the current 6112 /// context, if it is a potentially evaluated context. 6113 /// 6114 /// \param Loc The location at which the capture of 'this' occurs. 6115 /// 6116 /// \param Explicit Whether 'this' is explicitly captured in a lambda 6117 /// capture list. 6118 /// 6119 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index 6120 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture. 6121 /// This is useful when enclosing lambdas must speculatively capture 6122 /// 'this' that may or may not be used in certain specializations of 6123 /// a nested generic lambda (depending on whether the name resolves to 6124 /// a non-static member function or a static function). 6125 /// \return returns 'true' if failed, 'false' if success. 6126 bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false, 6127 bool BuildAndDiagnose = true, 6128 const unsigned *const FunctionScopeIndexToStopAt = nullptr, 6129 bool ByCopy = false); 6130 6131 /// Determine whether the given type is the type of *this that is used 6132 /// outside of the body of a member function for a type that is currently 6133 /// being defined. 6134 bool isThisOutsideMemberFunctionBody(QualType BaseType); 6135 6136 /// ActOnCXXBoolLiteral - Parse {true,false} literals. 6137 ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind); 6138 6139 6140 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals. 6141 ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind); 6142 6143 ExprResult 6144 ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs, 6145 SourceLocation AtLoc, SourceLocation RParen); 6146 6147 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'. 6148 ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc); 6149 6150 //// ActOnCXXThrow - Parse throw expressions. 6151 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr); 6152 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, 6153 bool IsThrownVarInScope); 6154 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E); 6155 6156 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type. 6157 /// Can be interpreted either as function-style casting ("int(x)") 6158 /// or class type construction ("ClassType(x,y,z)") 6159 /// or creation of a value-initialized type ("int()"). 6160 ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, 6161 SourceLocation LParenOrBraceLoc, 6162 MultiExprArg Exprs, 6163 SourceLocation RParenOrBraceLoc, 6164 bool ListInitialization); 6165 6166 ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, 6167 SourceLocation LParenLoc, 6168 MultiExprArg Exprs, 6169 SourceLocation RParenLoc, 6170 bool ListInitialization); 6171 6172 /// ActOnCXXNew - Parsed a C++ 'new' expression. 6173 ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 6174 SourceLocation PlacementLParen, 6175 MultiExprArg PlacementArgs, 6176 SourceLocation PlacementRParen, 6177 SourceRange TypeIdParens, Declarator &D, 6178 Expr *Initializer); 6179 ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, 6180 SourceLocation PlacementLParen, 6181 MultiExprArg PlacementArgs, 6182 SourceLocation PlacementRParen, 6183 SourceRange TypeIdParens, 6184 QualType AllocType, 6185 TypeSourceInfo *AllocTypeInfo, 6186 Optional<Expr *> ArraySize, 6187 SourceRange DirectInitRange, 6188 Expr *Initializer); 6189 6190 /// Determine whether \p FD is an aligned allocation or deallocation 6191 /// function that is unavailable. 6192 bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const; 6193 6194 /// Produce diagnostics if \p FD is an aligned allocation or deallocation 6195 /// function that is unavailable. 6196 void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, 6197 SourceLocation Loc); 6198 6199 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, 6200 SourceRange R); 6201 6202 /// The scope in which to find allocation functions. 6203 enum AllocationFunctionScope { 6204 /// Only look for allocation functions in the global scope. 6205 AFS_Global, 6206 /// Only look for allocation functions in the scope of the 6207 /// allocated class. 6208 AFS_Class, 6209 /// Look for allocation functions in both the global scope 6210 /// and in the scope of the allocated class. 6211 AFS_Both 6212 }; 6213 6214 /// Finds the overloads of operator new and delete that are appropriate 6215 /// for the allocation. 6216 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, 6217 AllocationFunctionScope NewScope, 6218 AllocationFunctionScope DeleteScope, 6219 QualType AllocType, bool IsArray, 6220 bool &PassAlignment, MultiExprArg PlaceArgs, 6221 FunctionDecl *&OperatorNew, 6222 FunctionDecl *&OperatorDelete, 6223 bool Diagnose = true); 6224 void DeclareGlobalNewDelete(); 6225 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return, 6226 ArrayRef<QualType> Params); 6227 6228 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 6229 DeclarationName Name, FunctionDecl* &Operator, 6230 bool Diagnose = true); 6231 FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc, 6232 bool CanProvideSize, 6233 bool Overaligned, 6234 DeclarationName Name); 6235 FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc, 6236 CXXRecordDecl *RD); 6237 6238 /// ActOnCXXDelete - Parsed a C++ 'delete' expression 6239 ExprResult ActOnCXXDelete(SourceLocation StartLoc, 6240 bool UseGlobal, bool ArrayForm, 6241 Expr *Operand); 6242 void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, 6243 bool IsDelete, bool CallCanBeVirtual, 6244 bool WarnOnNonAbstractTypes, 6245 SourceLocation DtorLoc); 6246 6247 ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, 6248 Expr *Operand, SourceLocation RParen); 6249 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, 6250 SourceLocation RParen); 6251 6252 /// Parsed one of the type trait support pseudo-functions. 6253 ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, 6254 ArrayRef<ParsedType> Args, 6255 SourceLocation RParenLoc); 6256 ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, 6257 ArrayRef<TypeSourceInfo *> Args, 6258 SourceLocation RParenLoc); 6259 6260 /// ActOnArrayTypeTrait - Parsed one of the binary type trait support 6261 /// pseudo-functions. 6262 ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, 6263 SourceLocation KWLoc, 6264 ParsedType LhsTy, 6265 Expr *DimExpr, 6266 SourceLocation RParen); 6267 6268 ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, 6269 SourceLocation KWLoc, 6270 TypeSourceInfo *TSInfo, 6271 Expr *DimExpr, 6272 SourceLocation RParen); 6273 6274 /// ActOnExpressionTrait - Parsed one of the unary type trait support 6275 /// pseudo-functions. 6276 ExprResult ActOnExpressionTrait(ExpressionTrait OET, 6277 SourceLocation KWLoc, 6278 Expr *Queried, 6279 SourceLocation RParen); 6280 6281 ExprResult BuildExpressionTrait(ExpressionTrait OET, 6282 SourceLocation KWLoc, 6283 Expr *Queried, 6284 SourceLocation RParen); 6285 6286 ExprResult ActOnStartCXXMemberReference(Scope *S, 6287 Expr *Base, 6288 SourceLocation OpLoc, 6289 tok::TokenKind OpKind, 6290 ParsedType &ObjectType, 6291 bool &MayBePseudoDestructor); 6292 6293 ExprResult BuildPseudoDestructorExpr(Expr *Base, 6294 SourceLocation OpLoc, 6295 tok::TokenKind OpKind, 6296 const CXXScopeSpec &SS, 6297 TypeSourceInfo *ScopeType, 6298 SourceLocation CCLoc, 6299 SourceLocation TildeLoc, 6300 PseudoDestructorTypeStorage DestroyedType); 6301 6302 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 6303 SourceLocation OpLoc, 6304 tok::TokenKind OpKind, 6305 CXXScopeSpec &SS, 6306 UnqualifiedId &FirstTypeName, 6307 SourceLocation CCLoc, 6308 SourceLocation TildeLoc, 6309 UnqualifiedId &SecondTypeName); 6310 6311 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 6312 SourceLocation OpLoc, 6313 tok::TokenKind OpKind, 6314 SourceLocation TildeLoc, 6315 const DeclSpec& DS); 6316 6317 /// MaybeCreateExprWithCleanups - If the current full-expression 6318 /// requires any cleanups, surround it with a ExprWithCleanups node. 6319 /// Otherwise, just returns the passed-in expression. 6320 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr); 6321 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt); 6322 ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr); 6323 6324 MaterializeTemporaryExpr * 6325 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, 6326 bool BoundToLvalueReference); 6327 ActOnFinishFullExpr(Expr * Expr,bool DiscardedValue)6328 ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) { 6329 return ActOnFinishFullExpr( 6330 Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue); 6331 } 6332 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC, 6333 bool DiscardedValue, bool IsConstexpr = false); 6334 StmtResult ActOnFinishFullStmt(Stmt *Stmt); 6335 6336 // Marks SS invalid if it represents an incomplete type. 6337 bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC); 6338 6339 DeclContext *computeDeclContext(QualType T); 6340 DeclContext *computeDeclContext(const CXXScopeSpec &SS, 6341 bool EnteringContext = false); 6342 bool isDependentScopeSpecifier(const CXXScopeSpec &SS); 6343 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS); 6344 6345 /// The parser has parsed a global nested-name-specifier '::'. 6346 /// 6347 /// \param CCLoc The location of the '::'. 6348 /// 6349 /// \param SS The nested-name-specifier, which will be updated in-place 6350 /// to reflect the parsed nested-name-specifier. 6351 /// 6352 /// \returns true if an error occurred, false otherwise. 6353 bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS); 6354 6355 /// The parser has parsed a '__super' nested-name-specifier. 6356 /// 6357 /// \param SuperLoc The location of the '__super' keyword. 6358 /// 6359 /// \param ColonColonLoc The location of the '::'. 6360 /// 6361 /// \param SS The nested-name-specifier, which will be updated in-place 6362 /// to reflect the parsed nested-name-specifier. 6363 /// 6364 /// \returns true if an error occurred, false otherwise. 6365 bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, 6366 SourceLocation ColonColonLoc, CXXScopeSpec &SS); 6367 6368 bool isAcceptableNestedNameSpecifier(const NamedDecl *SD, 6369 bool *CanCorrect = nullptr); 6370 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS); 6371 6372 /// Keeps information about an identifier in a nested-name-spec. 6373 /// 6374 struct NestedNameSpecInfo { 6375 /// The type of the object, if we're parsing nested-name-specifier in 6376 /// a member access expression. 6377 ParsedType ObjectType; 6378 6379 /// The identifier preceding the '::'. 6380 IdentifierInfo *Identifier; 6381 6382 /// The location of the identifier. 6383 SourceLocation IdentifierLoc; 6384 6385 /// The location of the '::'. 6386 SourceLocation CCLoc; 6387 6388 /// Creates info object for the most typical case. 6389 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc, 6390 SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType()) ObjectTypeNestedNameSpecInfo6391 : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc), 6392 CCLoc(ColonColonLoc) { 6393 } 6394 NestedNameSpecInfoNestedNameSpecInfo6395 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc, 6396 SourceLocation ColonColonLoc, QualType ObjectType) 6397 : ObjectType(ParsedType::make(ObjectType)), Identifier(II), 6398 IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) { 6399 } 6400 }; 6401 6402 bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, 6403 NestedNameSpecInfo &IdInfo); 6404 6405 bool BuildCXXNestedNameSpecifier(Scope *S, 6406 NestedNameSpecInfo &IdInfo, 6407 bool EnteringContext, 6408 CXXScopeSpec &SS, 6409 NamedDecl *ScopeLookupResult, 6410 bool ErrorRecoveryLookup, 6411 bool *IsCorrectedToColon = nullptr, 6412 bool OnlyNamespace = false); 6413 6414 /// The parser has parsed a nested-name-specifier 'identifier::'. 6415 /// 6416 /// \param S The scope in which this nested-name-specifier occurs. 6417 /// 6418 /// \param IdInfo Parser information about an identifier in the 6419 /// nested-name-spec. 6420 /// 6421 /// \param EnteringContext Whether we're entering the context nominated by 6422 /// this nested-name-specifier. 6423 /// 6424 /// \param SS The nested-name-specifier, which is both an input 6425 /// parameter (the nested-name-specifier before this type) and an 6426 /// output parameter (containing the full nested-name-specifier, 6427 /// including this new type). 6428 /// 6429 /// \param ErrorRecoveryLookup If true, then this method is called to improve 6430 /// error recovery. In this case do not emit error message. 6431 /// 6432 /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':' 6433 /// are allowed. The bool value pointed by this parameter is set to 'true' 6434 /// if the identifier is treated as if it was followed by ':', not '::'. 6435 /// 6436 /// \param OnlyNamespace If true, only considers namespaces in lookup. 6437 /// 6438 /// \returns true if an error occurred, false otherwise. 6439 bool ActOnCXXNestedNameSpecifier(Scope *S, 6440 NestedNameSpecInfo &IdInfo, 6441 bool EnteringContext, 6442 CXXScopeSpec &SS, 6443 bool ErrorRecoveryLookup = false, 6444 bool *IsCorrectedToColon = nullptr, 6445 bool OnlyNamespace = false); 6446 6447 ExprResult ActOnDecltypeExpression(Expr *E); 6448 6449 bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, 6450 const DeclSpec &DS, 6451 SourceLocation ColonColonLoc); 6452 6453 bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, 6454 NestedNameSpecInfo &IdInfo, 6455 bool EnteringContext); 6456 6457 /// The parser has parsed a nested-name-specifier 6458 /// 'template[opt] template-name < template-args >::'. 6459 /// 6460 /// \param S The scope in which this nested-name-specifier occurs. 6461 /// 6462 /// \param SS The nested-name-specifier, which is both an input 6463 /// parameter (the nested-name-specifier before this type) and an 6464 /// output parameter (containing the full nested-name-specifier, 6465 /// including this new type). 6466 /// 6467 /// \param TemplateKWLoc the location of the 'template' keyword, if any. 6468 /// \param TemplateName the template name. 6469 /// \param TemplateNameLoc The location of the template name. 6470 /// \param LAngleLoc The location of the opening angle bracket ('<'). 6471 /// \param TemplateArgs The template arguments. 6472 /// \param RAngleLoc The location of the closing angle bracket ('>'). 6473 /// \param CCLoc The location of the '::'. 6474 /// 6475 /// \param EnteringContext Whether we're entering the context of the 6476 /// nested-name-specifier. 6477 /// 6478 /// 6479 /// \returns true if an error occurred, false otherwise. 6480 bool ActOnCXXNestedNameSpecifier(Scope *S, 6481 CXXScopeSpec &SS, 6482 SourceLocation TemplateKWLoc, 6483 TemplateTy TemplateName, 6484 SourceLocation TemplateNameLoc, 6485 SourceLocation LAngleLoc, 6486 ASTTemplateArgsPtr TemplateArgs, 6487 SourceLocation RAngleLoc, 6488 SourceLocation CCLoc, 6489 bool EnteringContext); 6490 6491 /// Given a C++ nested-name-specifier, produce an annotation value 6492 /// that the parser can use later to reconstruct the given 6493 /// nested-name-specifier. 6494 /// 6495 /// \param SS A nested-name-specifier. 6496 /// 6497 /// \returns A pointer containing all of the information in the 6498 /// nested-name-specifier \p SS. 6499 void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS); 6500 6501 /// Given an annotation pointer for a nested-name-specifier, restore 6502 /// the nested-name-specifier structure. 6503 /// 6504 /// \param Annotation The annotation pointer, produced by 6505 /// \c SaveNestedNameSpecifierAnnotation(). 6506 /// 6507 /// \param AnnotationRange The source range corresponding to the annotation. 6508 /// 6509 /// \param SS The nested-name-specifier that will be updated with the contents 6510 /// of the annotation pointer. 6511 void RestoreNestedNameSpecifierAnnotation(void *Annotation, 6512 SourceRange AnnotationRange, 6513 CXXScopeSpec &SS); 6514 6515 bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS); 6516 6517 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global 6518 /// scope or nested-name-specifier) is parsed, part of a declarator-id. 6519 /// After this method is called, according to [C++ 3.4.3p3], names should be 6520 /// looked up in the declarator-id's scope, until the declarator is parsed and 6521 /// ActOnCXXExitDeclaratorScope is called. 6522 /// The 'SS' should be a non-empty valid CXXScopeSpec. 6523 bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS); 6524 6525 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously 6526 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same 6527 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well. 6528 /// Used to indicate that names should revert to being looked up in the 6529 /// defining scope. 6530 void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS); 6531 6532 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an 6533 /// initializer for the declaration 'Dcl'. 6534 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a 6535 /// static data member of class X, names should be looked up in the scope of 6536 /// class X. 6537 void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl); 6538 6539 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an 6540 /// initializer for the declaration 'Dcl'. 6541 void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl); 6542 6543 /// Create a new lambda closure type. 6544 CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange, 6545 TypeSourceInfo *Info, 6546 bool KnownDependent, 6547 LambdaCaptureDefault CaptureDefault); 6548 6549 /// Start the definition of a lambda expression. 6550 CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class, 6551 SourceRange IntroducerRange, 6552 TypeSourceInfo *MethodType, 6553 SourceLocation EndLoc, 6554 ArrayRef<ParmVarDecl *> Params, 6555 ConstexprSpecKind ConstexprKind, 6556 Expr *TrailingRequiresClause); 6557 6558 /// Number lambda for linkage purposes if necessary. 6559 void handleLambdaNumbering( 6560 CXXRecordDecl *Class, CXXMethodDecl *Method, 6561 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None); 6562 6563 /// Endow the lambda scope info with the relevant properties. 6564 void buildLambdaScope(sema::LambdaScopeInfo *LSI, 6565 CXXMethodDecl *CallOperator, 6566 SourceRange IntroducerRange, 6567 LambdaCaptureDefault CaptureDefault, 6568 SourceLocation CaptureDefaultLoc, 6569 bool ExplicitParams, 6570 bool ExplicitResultType, 6571 bool Mutable); 6572 6573 /// Perform initialization analysis of the init-capture and perform 6574 /// any implicit conversions such as an lvalue-to-rvalue conversion if 6575 /// not being used to initialize a reference. actOnLambdaInitCaptureInitialization(SourceLocation Loc,bool ByRef,SourceLocation EllipsisLoc,IdentifierInfo * Id,LambdaCaptureInitKind InitKind,Expr * & Init)6576 ParsedType actOnLambdaInitCaptureInitialization( 6577 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, 6578 IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) { 6579 return ParsedType::make(buildLambdaInitCaptureInitialization( 6580 Loc, ByRef, EllipsisLoc, None, Id, 6581 InitKind != LambdaCaptureInitKind::CopyInit, Init)); 6582 } 6583 QualType buildLambdaInitCaptureInitialization( 6584 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, 6585 Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit, 6586 Expr *&Init); 6587 6588 /// Create a dummy variable within the declcontext of the lambda's 6589 /// call operator, for name lookup purposes for a lambda init capture. 6590 /// 6591 /// CodeGen handles emission of lambda captures, ignoring these dummy 6592 /// variables appropriately. 6593 VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc, 6594 QualType InitCaptureType, 6595 SourceLocation EllipsisLoc, 6596 IdentifierInfo *Id, 6597 unsigned InitStyle, Expr *Init); 6598 6599 /// Add an init-capture to a lambda scope. 6600 void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var); 6601 6602 /// Note that we have finished the explicit captures for the 6603 /// given lambda. 6604 void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI); 6605 6606 /// \brief This is called after parsing the explicit template parameter list 6607 /// on a lambda (if it exists) in C++2a. 6608 void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc, 6609 ArrayRef<NamedDecl *> TParams, 6610 SourceLocation RAngleLoc, 6611 ExprResult RequiresClause); 6612 6613 /// Introduce the lambda parameters into scope. 6614 void addLambdaParameters( 6615 ArrayRef<LambdaIntroducer::LambdaCapture> Captures, 6616 CXXMethodDecl *CallOperator, Scope *CurScope); 6617 6618 /// Deduce a block or lambda's return type based on the return 6619 /// statements present in the body. 6620 void deduceClosureReturnType(sema::CapturingScopeInfo &CSI); 6621 6622 /// ActOnStartOfLambdaDefinition - This is called just before we start 6623 /// parsing the body of a lambda; it analyzes the explicit captures and 6624 /// arguments, and sets up various data-structures for the body of the 6625 /// lambda. 6626 void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, 6627 Declarator &ParamInfo, Scope *CurScope); 6628 6629 /// ActOnLambdaError - If there is an error parsing a lambda, this callback 6630 /// is invoked to pop the information about the lambda. 6631 void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, 6632 bool IsInstantiation = false); 6633 6634 /// ActOnLambdaExpr - This is called when the body of a lambda expression 6635 /// was successfully completed. 6636 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, 6637 Scope *CurScope); 6638 6639 /// Does copying/destroying the captured variable have side effects? 6640 bool CaptureHasSideEffects(const sema::Capture &From); 6641 6642 /// Diagnose if an explicit lambda capture is unused. Returns true if a 6643 /// diagnostic is emitted. 6644 bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange, 6645 const sema::Capture &From); 6646 6647 /// Build a FieldDecl suitable to hold the given capture. 6648 FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture); 6649 6650 /// Initialize the given capture with a suitable expression. 6651 ExprResult BuildCaptureInit(const sema::Capture &Capture, 6652 SourceLocation ImplicitCaptureLoc, 6653 bool IsOpenMPMapping = false); 6654 6655 /// Complete a lambda-expression having processed and attached the 6656 /// lambda body. 6657 ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc, 6658 sema::LambdaScopeInfo *LSI); 6659 6660 /// Get the return type to use for a lambda's conversion function(s) to 6661 /// function pointer type, given the type of the call operator. 6662 QualType 6663 getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType, 6664 CallingConv CC); 6665 6666 /// Define the "body" of the conversion from a lambda object to a 6667 /// function pointer. 6668 /// 6669 /// This routine doesn't actually define a sensible body; rather, it fills 6670 /// in the initialization expression needed to copy the lambda object into 6671 /// the block, and IR generation actually generates the real body of the 6672 /// block pointer conversion. 6673 void DefineImplicitLambdaToFunctionPointerConversion( 6674 SourceLocation CurrentLoc, CXXConversionDecl *Conv); 6675 6676 /// Define the "body" of the conversion from a lambda object to a 6677 /// block pointer. 6678 /// 6679 /// This routine doesn't actually define a sensible body; rather, it fills 6680 /// in the initialization expression needed to copy the lambda object into 6681 /// the block, and IR generation actually generates the real body of the 6682 /// block pointer conversion. 6683 void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, 6684 CXXConversionDecl *Conv); 6685 6686 ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, 6687 SourceLocation ConvLocation, 6688 CXXConversionDecl *Conv, 6689 Expr *Src); 6690 6691 /// Check whether the given expression is a valid constraint expression. 6692 /// A diagnostic is emitted if it is not, false is returned, and 6693 /// PossibleNonPrimary will be set to true if the failure might be due to a 6694 /// non-primary expression being used as an atomic constraint. 6695 bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(), 6696 bool *PossibleNonPrimary = nullptr, 6697 bool IsTrailingRequiresClause = false); 6698 6699 private: 6700 /// Caches pairs of template-like decls whose associated constraints were 6701 /// checked for subsumption and whether or not the first's constraints did in 6702 /// fact subsume the second's. 6703 llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache; 6704 /// Caches the normalized associated constraints of declarations (concepts or 6705 /// constrained declarations). If an error occurred while normalizing the 6706 /// associated constraints of the template or concept, nullptr will be cached 6707 /// here. 6708 llvm::DenseMap<NamedDecl *, NormalizedConstraint *> 6709 NormalizationCache; 6710 6711 llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &> 6712 SatisfactionCache; 6713 6714 public: 6715 const NormalizedConstraint * 6716 getNormalizedAssociatedConstraints( 6717 NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints); 6718 6719 /// \brief Check whether the given declaration's associated constraints are 6720 /// at least as constrained than another declaration's according to the 6721 /// partial ordering of constraints. 6722 /// 6723 /// \param Result If no error occurred, receives the result of true if D1 is 6724 /// at least constrained than D2, and false otherwise. 6725 /// 6726 /// \returns true if an error occurred, false otherwise. 6727 bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1, 6728 NamedDecl *D2, ArrayRef<const Expr *> AC2, 6729 bool &Result); 6730 6731 /// If D1 was not at least as constrained as D2, but would've been if a pair 6732 /// of atomic constraints involved had been declared in a concept and not 6733 /// repeated in two separate places in code. 6734 /// \returns true if such a diagnostic was emitted, false otherwise. 6735 bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, 6736 ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2); 6737 6738 /// \brief Check whether the given list of constraint expressions are 6739 /// satisfied (as if in a 'conjunction') given template arguments. 6740 /// \param Template the template-like entity that triggered the constraints 6741 /// check (either a concept or a constrained entity). 6742 /// \param ConstraintExprs a list of constraint expressions, treated as if 6743 /// they were 'AND'ed together. 6744 /// \param TemplateArgs the list of template arguments to substitute into the 6745 /// constraint expression. 6746 /// \param TemplateIDRange The source range of the template id that 6747 /// caused the constraints check. 6748 /// \param Satisfaction if true is returned, will contain details of the 6749 /// satisfaction, with enough information to diagnose an unsatisfied 6750 /// expression. 6751 /// \returns true if an error occurred and satisfaction could not be checked, 6752 /// false otherwise. 6753 bool CheckConstraintSatisfaction( 6754 const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs, 6755 ArrayRef<TemplateArgument> TemplateArgs, 6756 SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction); 6757 6758 /// \brief Check whether the given non-dependent constraint expression is 6759 /// satisfied. Returns false and updates Satisfaction with the satisfaction 6760 /// verdict if successful, emits a diagnostic and returns true if an error 6761 /// occured and satisfaction could not be determined. 6762 /// 6763 /// \returns true if an error occurred, false otherwise. 6764 bool CheckConstraintSatisfaction(const Expr *ConstraintExpr, 6765 ConstraintSatisfaction &Satisfaction); 6766 6767 /// Check whether the given function decl's trailing requires clause is 6768 /// satisfied, if any. Returns false and updates Satisfaction with the 6769 /// satisfaction verdict if successful, emits a diagnostic and returns true if 6770 /// an error occured and satisfaction could not be determined. 6771 /// 6772 /// \returns true if an error occurred, false otherwise. 6773 bool CheckFunctionConstraints(const FunctionDecl *FD, 6774 ConstraintSatisfaction &Satisfaction, 6775 SourceLocation UsageLoc = SourceLocation()); 6776 6777 6778 /// \brief Ensure that the given template arguments satisfy the constraints 6779 /// associated with the given template, emitting a diagnostic if they do not. 6780 /// 6781 /// \param Template The template to which the template arguments are being 6782 /// provided. 6783 /// 6784 /// \param TemplateArgs The converted, canonicalized template arguments. 6785 /// 6786 /// \param TemplateIDRange The source range of the template id that 6787 /// caused the constraints check. 6788 /// 6789 /// \returns true if the constrains are not satisfied or could not be checked 6790 /// for satisfaction, false if the constraints are satisfied. 6791 bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template, 6792 ArrayRef<TemplateArgument> TemplateArgs, 6793 SourceRange TemplateIDRange); 6794 6795 /// \brief Emit diagnostics explaining why a constraint expression was deemed 6796 /// unsatisfied. 6797 /// \param First whether this is the first time an unsatisfied constraint is 6798 /// diagnosed for this error. 6799 void 6800 DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, 6801 bool First = true); 6802 6803 /// \brief Emit diagnostics explaining why a constraint expression was deemed 6804 /// unsatisfied. 6805 void 6806 DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction, 6807 bool First = true); 6808 6809 // ParseObjCStringLiteral - Parse Objective-C string literals. 6810 ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs, 6811 ArrayRef<Expr *> Strings); 6812 6813 ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S); 6814 6815 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the 6816 /// numeric literal expression. Type of the expression will be "NSNumber *" 6817 /// or "id" if NSNumber is unavailable. 6818 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number); 6819 ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc, 6820 bool Value); 6821 ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements); 6822 6823 /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the 6824 /// '@' prefixed parenthesized expression. The type of the expression will 6825 /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type 6826 /// of ValueType, which is allowed to be a built-in numeric type, "char *", 6827 /// "const char *" or C structure with attribute 'objc_boxable'. 6828 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr); 6829 6830 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, 6831 Expr *IndexExpr, 6832 ObjCMethodDecl *getterMethod, 6833 ObjCMethodDecl *setterMethod); 6834 6835 ExprResult BuildObjCDictionaryLiteral(SourceRange SR, 6836 MutableArrayRef<ObjCDictionaryElement> Elements); 6837 6838 ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc, 6839 TypeSourceInfo *EncodedTypeInfo, 6840 SourceLocation RParenLoc); 6841 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, 6842 CXXConversionDecl *Method, 6843 bool HadMultipleCandidates); 6844 6845 ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc, 6846 SourceLocation EncodeLoc, 6847 SourceLocation LParenLoc, 6848 ParsedType Ty, 6849 SourceLocation RParenLoc); 6850 6851 /// ParseObjCSelectorExpression - Build selector expression for \@selector 6852 ExprResult ParseObjCSelectorExpression(Selector Sel, 6853 SourceLocation AtLoc, 6854 SourceLocation SelLoc, 6855 SourceLocation LParenLoc, 6856 SourceLocation RParenLoc, 6857 bool WarnMultipleSelectors); 6858 6859 /// ParseObjCProtocolExpression - Build protocol expression for \@protocol 6860 ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName, 6861 SourceLocation AtLoc, 6862 SourceLocation ProtoLoc, 6863 SourceLocation LParenLoc, 6864 SourceLocation ProtoIdLoc, 6865 SourceLocation RParenLoc); 6866 6867 //===--------------------------------------------------------------------===// 6868 // C++ Declarations 6869 // 6870 Decl *ActOnStartLinkageSpecification(Scope *S, 6871 SourceLocation ExternLoc, 6872 Expr *LangStr, 6873 SourceLocation LBraceLoc); 6874 Decl *ActOnFinishLinkageSpecification(Scope *S, 6875 Decl *LinkageSpec, 6876 SourceLocation RBraceLoc); 6877 6878 6879 //===--------------------------------------------------------------------===// 6880 // C++ Classes 6881 // 6882 CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS); 6883 bool isCurrentClassName(const IdentifierInfo &II, Scope *S, 6884 const CXXScopeSpec *SS = nullptr); 6885 bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS); 6886 6887 bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, 6888 SourceLocation ColonLoc, 6889 const ParsedAttributesView &Attrs); 6890 6891 NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, 6892 Declarator &D, 6893 MultiTemplateParamsArg TemplateParameterLists, 6894 Expr *BitfieldWidth, const VirtSpecifiers &VS, 6895 InClassInitStyle InitStyle); 6896 6897 void ActOnStartCXXInClassMemberInitializer(); 6898 void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, 6899 SourceLocation EqualLoc, 6900 Expr *Init); 6901 6902 MemInitResult ActOnMemInitializer(Decl *ConstructorD, 6903 Scope *S, 6904 CXXScopeSpec &SS, 6905 IdentifierInfo *MemberOrBase, 6906 ParsedType TemplateTypeTy, 6907 const DeclSpec &DS, 6908 SourceLocation IdLoc, 6909 SourceLocation LParenLoc, 6910 ArrayRef<Expr *> Args, 6911 SourceLocation RParenLoc, 6912 SourceLocation EllipsisLoc); 6913 6914 MemInitResult ActOnMemInitializer(Decl *ConstructorD, 6915 Scope *S, 6916 CXXScopeSpec &SS, 6917 IdentifierInfo *MemberOrBase, 6918 ParsedType TemplateTypeTy, 6919 const DeclSpec &DS, 6920 SourceLocation IdLoc, 6921 Expr *InitList, 6922 SourceLocation EllipsisLoc); 6923 6924 MemInitResult BuildMemInitializer(Decl *ConstructorD, 6925 Scope *S, 6926 CXXScopeSpec &SS, 6927 IdentifierInfo *MemberOrBase, 6928 ParsedType TemplateTypeTy, 6929 const DeclSpec &DS, 6930 SourceLocation IdLoc, 6931 Expr *Init, 6932 SourceLocation EllipsisLoc); 6933 6934 MemInitResult BuildMemberInitializer(ValueDecl *Member, 6935 Expr *Init, 6936 SourceLocation IdLoc); 6937 6938 MemInitResult BuildBaseInitializer(QualType BaseType, 6939 TypeSourceInfo *BaseTInfo, 6940 Expr *Init, 6941 CXXRecordDecl *ClassDecl, 6942 SourceLocation EllipsisLoc); 6943 6944 MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, 6945 Expr *Init, 6946 CXXRecordDecl *ClassDecl); 6947 6948 bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, 6949 CXXCtorInitializer *Initializer); 6950 6951 bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, 6952 ArrayRef<CXXCtorInitializer *> Initializers = None); 6953 6954 void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation); 6955 6956 6957 /// MarkBaseAndMemberDestructorsReferenced - Given a record decl, 6958 /// mark all the non-trivial destructors of its members and bases as 6959 /// referenced. 6960 void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, 6961 CXXRecordDecl *Record); 6962 6963 /// Mark destructors of virtual bases of this class referenced. In the Itanium 6964 /// C++ ABI, this is done when emitting a destructor for any non-abstract 6965 /// class. In the Microsoft C++ ABI, this is done any time a class's 6966 /// destructor is referenced. 6967 void MarkVirtualBaseDestructorsReferenced( 6968 SourceLocation Location, CXXRecordDecl *ClassDecl, 6969 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases = nullptr); 6970 6971 /// Do semantic checks to allow the complete destructor variant to be emitted 6972 /// when the destructor is defined in another translation unit. In the Itanium 6973 /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they 6974 /// can be emitted in separate TUs. To emit the complete variant, run a subset 6975 /// of the checks performed when emitting a regular destructor. 6976 void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, 6977 CXXDestructorDecl *Dtor); 6978 6979 /// The list of classes whose vtables have been used within 6980 /// this translation unit, and the source locations at which the 6981 /// first use occurred. 6982 typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse; 6983 6984 /// The list of vtables that are required but have not yet been 6985 /// materialized. 6986 SmallVector<VTableUse, 16> VTableUses; 6987 6988 /// The set of classes whose vtables have been used within 6989 /// this translation unit, and a bit that will be true if the vtable is 6990 /// required to be emitted (otherwise, it should be emitted only if needed 6991 /// by code generation). 6992 llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed; 6993 6994 /// Load any externally-stored vtable uses. 6995 void LoadExternalVTableUses(); 6996 6997 /// Note that the vtable for the given class was used at the 6998 /// given location. 6999 void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, 7000 bool DefinitionRequired = false); 7001 7002 /// Mark the exception specifications of all virtual member functions 7003 /// in the given class as needed. 7004 void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, 7005 const CXXRecordDecl *RD); 7006 7007 /// MarkVirtualMembersReferenced - Will mark all members of the given 7008 /// CXXRecordDecl referenced. 7009 void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, 7010 bool ConstexprOnly = false); 7011 7012 /// Define all of the vtables that have been used in this 7013 /// translation unit and reference any virtual members used by those 7014 /// vtables. 7015 /// 7016 /// \returns true if any work was done, false otherwise. 7017 bool DefineUsedVTables(); 7018 7019 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl); 7020 7021 void ActOnMemInitializers(Decl *ConstructorDecl, 7022 SourceLocation ColonLoc, 7023 ArrayRef<CXXCtorInitializer*> MemInits, 7024 bool AnyErrors); 7025 7026 /// Check class-level dllimport/dllexport attribute. The caller must 7027 /// ensure that referenceDLLExportedClassMethods is called some point later 7028 /// when all outer classes of Class are complete. 7029 void checkClassLevelDLLAttribute(CXXRecordDecl *Class); 7030 void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class); 7031 7032 void referenceDLLExportedClassMethods(); 7033 7034 void propagateDLLAttrToBaseClassTemplate( 7035 CXXRecordDecl *Class, Attr *ClassAttr, 7036 ClassTemplateSpecializationDecl *BaseTemplateSpec, 7037 SourceLocation BaseLoc); 7038 7039 /// Add gsl::Pointer attribute to std::container::iterator 7040 /// \param ND The declaration that introduces the name 7041 /// std::container::iterator. \param UnderlyingRecord The record named by ND. 7042 void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord); 7043 7044 /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types. 7045 void inferGslOwnerPointerAttribute(CXXRecordDecl *Record); 7046 7047 /// Add [[gsl::Pointer]] attributes for std:: types. 7048 void inferGslPointerAttribute(TypedefNameDecl *TD); 7049 7050 void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record); 7051 7052 /// Check that the C++ class annoated with "trivial_abi" satisfies all the 7053 /// conditions that are needed for the attribute to have an effect. 7054 void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD); 7055 7056 void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, 7057 Decl *TagDecl, SourceLocation LBrac, 7058 SourceLocation RBrac, 7059 const ParsedAttributesView &AttrList); 7060 void ActOnFinishCXXMemberDecls(); 7061 void ActOnFinishCXXNonNestedClass(); 7062 7063 void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param); 7064 unsigned ActOnReenterTemplateScope(Decl *Template, 7065 llvm::function_ref<Scope *()> EnterScope); 7066 void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record); 7067 void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method); 7068 void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param); 7069 void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record); 7070 void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method); 7071 void ActOnFinishDelayedMemberInitializers(Decl *Record); 7072 void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, 7073 CachedTokens &Toks); 7074 void UnmarkAsLateParsedTemplate(FunctionDecl *FD); 7075 bool IsInsideALocalClassWithinATemplateFunction(); 7076 7077 Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, 7078 Expr *AssertExpr, 7079 Expr *AssertMessageExpr, 7080 SourceLocation RParenLoc); 7081 Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, 7082 Expr *AssertExpr, 7083 StringLiteral *AssertMessageExpr, 7084 SourceLocation RParenLoc, 7085 bool Failed); 7086 7087 FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart, 7088 SourceLocation FriendLoc, 7089 TypeSourceInfo *TSInfo); 7090 Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, 7091 MultiTemplateParamsArg TemplateParams); 7092 NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D, 7093 MultiTemplateParamsArg TemplateParams); 7094 7095 QualType CheckConstructorDeclarator(Declarator &D, QualType R, 7096 StorageClass& SC); 7097 void CheckConstructor(CXXConstructorDecl *Constructor); 7098 QualType CheckDestructorDeclarator(Declarator &D, QualType R, 7099 StorageClass& SC); 7100 bool CheckDestructor(CXXDestructorDecl *Destructor); 7101 void CheckConversionDeclarator(Declarator &D, QualType &R, 7102 StorageClass& SC); 7103 Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion); 7104 void CheckDeductionGuideDeclarator(Declarator &D, QualType &R, 7105 StorageClass &SC); 7106 void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD); 7107 7108 void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD); 7109 7110 bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, 7111 CXXSpecialMember CSM); 7112 void CheckDelayedMemberExceptionSpecs(); 7113 7114 bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD, 7115 DefaultedComparisonKind DCK); 7116 void DeclareImplicitEqualityComparison(CXXRecordDecl *RD, 7117 FunctionDecl *Spaceship); 7118 void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, 7119 DefaultedComparisonKind DCK); 7120 7121 //===--------------------------------------------------------------------===// 7122 // C++ Derived Classes 7123 // 7124 7125 /// ActOnBaseSpecifier - Parsed a base specifier 7126 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class, 7127 SourceRange SpecifierRange, 7128 bool Virtual, AccessSpecifier Access, 7129 TypeSourceInfo *TInfo, 7130 SourceLocation EllipsisLoc); 7131 7132 BaseResult ActOnBaseSpecifier(Decl *classdecl, 7133 SourceRange SpecifierRange, 7134 ParsedAttributes &Attrs, 7135 bool Virtual, AccessSpecifier Access, 7136 ParsedType basetype, 7137 SourceLocation BaseLoc, 7138 SourceLocation EllipsisLoc); 7139 7140 bool AttachBaseSpecifiers(CXXRecordDecl *Class, 7141 MutableArrayRef<CXXBaseSpecifier *> Bases); 7142 void ActOnBaseSpecifiers(Decl *ClassDecl, 7143 MutableArrayRef<CXXBaseSpecifier *> Bases); 7144 7145 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base); 7146 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base, 7147 CXXBasePaths &Paths); 7148 7149 // FIXME: I don't like this name. 7150 void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath); 7151 7152 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, 7153 SourceLocation Loc, SourceRange Range, 7154 CXXCastPath *BasePath = nullptr, 7155 bool IgnoreAccess = false); 7156 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, 7157 unsigned InaccessibleBaseID, 7158 unsigned AmbiguousBaseConvID, 7159 SourceLocation Loc, SourceRange Range, 7160 DeclarationName Name, 7161 CXXCastPath *BasePath, 7162 bool IgnoreAccess = false); 7163 7164 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths); 7165 7166 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, 7167 const CXXMethodDecl *Old); 7168 7169 /// CheckOverridingFunctionReturnType - Checks whether the return types are 7170 /// covariant, according to C++ [class.virtual]p5. 7171 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, 7172 const CXXMethodDecl *Old); 7173 7174 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception 7175 /// spec is a subset of base spec. 7176 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, 7177 const CXXMethodDecl *Old); 7178 7179 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange); 7180 7181 /// CheckOverrideControl - Check C++11 override control semantics. 7182 void CheckOverrideControl(NamedDecl *D); 7183 7184 /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was 7185 /// not used in the declaration of an overriding method. 7186 void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent); 7187 7188 /// CheckForFunctionMarkedFinal - Checks whether a virtual member function 7189 /// overrides a virtual member function marked 'final', according to 7190 /// C++11 [class.virtual]p4. 7191 bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, 7192 const CXXMethodDecl *Old); 7193 7194 7195 //===--------------------------------------------------------------------===// 7196 // C++ Access Control 7197 // 7198 7199 enum AccessResult { 7200 AR_accessible, 7201 AR_inaccessible, 7202 AR_dependent, 7203 AR_delayed 7204 }; 7205 7206 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, 7207 NamedDecl *PrevMemberDecl, 7208 AccessSpecifier LexicalAS); 7209 7210 AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, 7211 DeclAccessPair FoundDecl); 7212 AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, 7213 DeclAccessPair FoundDecl); 7214 AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, 7215 SourceRange PlacementRange, 7216 CXXRecordDecl *NamingClass, 7217 DeclAccessPair FoundDecl, 7218 bool Diagnose = true); 7219 AccessResult CheckConstructorAccess(SourceLocation Loc, 7220 CXXConstructorDecl *D, 7221 DeclAccessPair FoundDecl, 7222 const InitializedEntity &Entity, 7223 bool IsCopyBindingRefToTemp = false); 7224 AccessResult CheckConstructorAccess(SourceLocation Loc, 7225 CXXConstructorDecl *D, 7226 DeclAccessPair FoundDecl, 7227 const InitializedEntity &Entity, 7228 const PartialDiagnostic &PDiag); 7229 AccessResult CheckDestructorAccess(SourceLocation Loc, 7230 CXXDestructorDecl *Dtor, 7231 const PartialDiagnostic &PDiag, 7232 QualType objectType = QualType()); 7233 AccessResult CheckFriendAccess(NamedDecl *D); 7234 AccessResult CheckMemberAccess(SourceLocation UseLoc, 7235 CXXRecordDecl *NamingClass, 7236 DeclAccessPair Found); 7237 AccessResult 7238 CheckStructuredBindingMemberAccess(SourceLocation UseLoc, 7239 CXXRecordDecl *DecomposedClass, 7240 DeclAccessPair Field); 7241 AccessResult CheckMemberOperatorAccess(SourceLocation Loc, 7242 Expr *ObjectExpr, 7243 Expr *ArgExpr, 7244 DeclAccessPair FoundDecl); 7245 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, 7246 DeclAccessPair FoundDecl); 7247 AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, 7248 QualType Base, QualType Derived, 7249 const CXXBasePath &Path, 7250 unsigned DiagID, 7251 bool ForceCheck = false, 7252 bool ForceUnprivileged = false); 7253 void CheckLookupAccess(const LookupResult &R); 7254 bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass, 7255 QualType BaseType); 7256 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, 7257 DeclAccessPair Found, QualType ObjectType, 7258 SourceLocation Loc, 7259 const PartialDiagnostic &Diag); isMemberAccessibleForDeletion(CXXRecordDecl * NamingClass,DeclAccessPair Found,QualType ObjectType)7260 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, 7261 DeclAccessPair Found, 7262 QualType ObjectType) { 7263 return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType, 7264 SourceLocation(), PDiag()); 7265 } 7266 7267 void HandleDependentAccessCheck(const DependentDiagnostic &DD, 7268 const MultiLevelTemplateArgumentList &TemplateArgs); 7269 void PerformDependentDiagnostics(const DeclContext *Pattern, 7270 const MultiLevelTemplateArgumentList &TemplateArgs); 7271 7272 void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx); 7273 7274 /// When true, access checking violations are treated as SFINAE 7275 /// failures rather than hard errors. 7276 bool AccessCheckingSFINAE; 7277 7278 enum AbstractDiagSelID { 7279 AbstractNone = -1, 7280 AbstractReturnType, 7281 AbstractParamType, 7282 AbstractVariableType, 7283 AbstractFieldType, 7284 AbstractIvarType, 7285 AbstractSynthesizedIvarType, 7286 AbstractArrayType 7287 }; 7288 7289 bool isAbstractType(SourceLocation Loc, QualType T); 7290 bool RequireNonAbstractType(SourceLocation Loc, QualType T, 7291 TypeDiagnoser &Diagnoser); 7292 template <typename... Ts> RequireNonAbstractType(SourceLocation Loc,QualType T,unsigned DiagID,const Ts &...Args)7293 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID, 7294 const Ts &...Args) { 7295 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 7296 return RequireNonAbstractType(Loc, T, Diagnoser); 7297 } 7298 7299 void DiagnoseAbstractType(const CXXRecordDecl *RD); 7300 7301 //===--------------------------------------------------------------------===// 7302 // C++ Overloaded Operators [C++ 13.5] 7303 // 7304 7305 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl); 7306 7307 bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl); 7308 7309 //===--------------------------------------------------------------------===// 7310 // C++ Templates [C++ 14] 7311 // 7312 void FilterAcceptableTemplateNames(LookupResult &R, 7313 bool AllowFunctionTemplates = true, 7314 bool AllowDependent = true); 7315 bool hasAnyAcceptableTemplateNames(LookupResult &R, 7316 bool AllowFunctionTemplates = true, 7317 bool AllowDependent = true, 7318 bool AllowNonTemplateFunctions = false); 7319 /// Try to interpret the lookup result D as a template-name. 7320 /// 7321 /// \param D A declaration found by name lookup. 7322 /// \param AllowFunctionTemplates Whether function templates should be 7323 /// considered valid results. 7324 /// \param AllowDependent Whether unresolved using declarations (that might 7325 /// name templates) should be considered valid results. 7326 static NamedDecl *getAsTemplateNameDecl(NamedDecl *D, 7327 bool AllowFunctionTemplates = true, 7328 bool AllowDependent = true); 7329 7330 enum TemplateNameIsRequiredTag { TemplateNameIsRequired }; 7331 /// Whether and why a template name is required in this lookup. 7332 class RequiredTemplateKind { 7333 public: 7334 /// Template name is required if TemplateKWLoc is valid. 7335 RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation()) TemplateKW(TemplateKWLoc)7336 : TemplateKW(TemplateKWLoc) {} 7337 /// Template name is unconditionally required. RequiredTemplateKind(TemplateNameIsRequiredTag)7338 RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {} 7339 getTemplateKeywordLoc()7340 SourceLocation getTemplateKeywordLoc() const { 7341 return TemplateKW.getValueOr(SourceLocation()); 7342 } hasTemplateKeyword()7343 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } isRequired()7344 bool isRequired() const { return TemplateKW != SourceLocation(); } 7345 explicit operator bool() const { return isRequired(); } 7346 7347 private: 7348 llvm::Optional<SourceLocation> TemplateKW; 7349 }; 7350 7351 enum class AssumedTemplateKind { 7352 /// This is not assumed to be a template name. 7353 None, 7354 /// This is assumed to be a template name because lookup found nothing. 7355 FoundNothing, 7356 /// This is assumed to be a template name because lookup found one or more 7357 /// functions (but no function templates). 7358 FoundFunctions, 7359 }; 7360 bool LookupTemplateName( 7361 LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, 7362 bool EnteringContext, bool &MemberOfUnknownSpecialization, 7363 RequiredTemplateKind RequiredTemplate = SourceLocation(), 7364 AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true); 7365 7366 TemplateNameKind isTemplateName(Scope *S, 7367 CXXScopeSpec &SS, 7368 bool hasTemplateKeyword, 7369 const UnqualifiedId &Name, 7370 ParsedType ObjectType, 7371 bool EnteringContext, 7372 TemplateTy &Template, 7373 bool &MemberOfUnknownSpecialization, 7374 bool Disambiguation = false); 7375 7376 /// Try to resolve an undeclared template name as a type template. 7377 /// 7378 /// Sets II to the identifier corresponding to the template name, and updates 7379 /// Name to a corresponding (typo-corrected) type template name and TNK to 7380 /// the corresponding kind, if possible. 7381 void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name, 7382 TemplateNameKind &TNK, 7383 SourceLocation NameLoc, 7384 IdentifierInfo *&II); 7385 7386 bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name, 7387 SourceLocation NameLoc, 7388 bool Diagnose = true); 7389 7390 /// Determine whether a particular identifier might be the name in a C++1z 7391 /// deduction-guide declaration. 7392 bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, 7393 SourceLocation NameLoc, 7394 ParsedTemplateTy *Template = nullptr); 7395 7396 bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, 7397 SourceLocation IILoc, 7398 Scope *S, 7399 const CXXScopeSpec *SS, 7400 TemplateTy &SuggestedTemplate, 7401 TemplateNameKind &SuggestedKind); 7402 7403 bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, 7404 NamedDecl *Instantiation, 7405 bool InstantiatedFromMember, 7406 const NamedDecl *Pattern, 7407 const NamedDecl *PatternDef, 7408 TemplateSpecializationKind TSK, 7409 bool Complain = true); 7410 7411 void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl); 7412 TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl); 7413 7414 NamedDecl *ActOnTypeParameter(Scope *S, bool Typename, 7415 SourceLocation EllipsisLoc, 7416 SourceLocation KeyLoc, 7417 IdentifierInfo *ParamName, 7418 SourceLocation ParamNameLoc, 7419 unsigned Depth, unsigned Position, 7420 SourceLocation EqualLoc, 7421 ParsedType DefaultArg, bool HasTypeConstraint); 7422 7423 bool ActOnTypeConstraint(const CXXScopeSpec &SS, 7424 TemplateIdAnnotation *TypeConstraint, 7425 TemplateTypeParmDecl *ConstrainedParameter, 7426 SourceLocation EllipsisLoc); 7427 7428 bool AttachTypeConstraint(NestedNameSpecifierLoc NS, 7429 DeclarationNameInfo NameInfo, 7430 ConceptDecl *NamedConcept, 7431 const TemplateArgumentListInfo *TemplateArgs, 7432 TemplateTypeParmDecl *ConstrainedParameter, 7433 SourceLocation EllipsisLoc); 7434 7435 bool AttachTypeConstraint(AutoTypeLoc TL, 7436 NonTypeTemplateParmDecl *ConstrainedParameter, 7437 SourceLocation EllipsisLoc); 7438 7439 bool RequireStructuralType(QualType T, SourceLocation Loc); 7440 7441 QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, 7442 SourceLocation Loc); 7443 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc); 7444 7445 NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, 7446 unsigned Depth, 7447 unsigned Position, 7448 SourceLocation EqualLoc, 7449 Expr *DefaultArg); 7450 NamedDecl *ActOnTemplateTemplateParameter(Scope *S, 7451 SourceLocation TmpLoc, 7452 TemplateParameterList *Params, 7453 SourceLocation EllipsisLoc, 7454 IdentifierInfo *ParamName, 7455 SourceLocation ParamNameLoc, 7456 unsigned Depth, 7457 unsigned Position, 7458 SourceLocation EqualLoc, 7459 ParsedTemplateArgument DefaultArg); 7460 7461 TemplateParameterList * 7462 ActOnTemplateParameterList(unsigned Depth, 7463 SourceLocation ExportLoc, 7464 SourceLocation TemplateLoc, 7465 SourceLocation LAngleLoc, 7466 ArrayRef<NamedDecl *> Params, 7467 SourceLocation RAngleLoc, 7468 Expr *RequiresClause); 7469 7470 /// The context in which we are checking a template parameter list. 7471 enum TemplateParamListContext { 7472 TPC_ClassTemplate, 7473 TPC_VarTemplate, 7474 TPC_FunctionTemplate, 7475 TPC_ClassTemplateMember, 7476 TPC_FriendClassTemplate, 7477 TPC_FriendFunctionTemplate, 7478 TPC_FriendFunctionTemplateDefinition, 7479 TPC_TypeAliasTemplate 7480 }; 7481 7482 bool CheckTemplateParameterList(TemplateParameterList *NewParams, 7483 TemplateParameterList *OldParams, 7484 TemplateParamListContext TPC, 7485 SkipBodyInfo *SkipBody = nullptr); 7486 TemplateParameterList *MatchTemplateParametersToScopeSpecifier( 7487 SourceLocation DeclStartLoc, SourceLocation DeclLoc, 7488 const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, 7489 ArrayRef<TemplateParameterList *> ParamLists, 7490 bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, 7491 bool SuppressDiagnostic = false); 7492 7493 DeclResult CheckClassTemplate( 7494 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, 7495 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, 7496 const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, 7497 AccessSpecifier AS, SourceLocation ModulePrivateLoc, 7498 SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, 7499 TemplateParameterList **OuterTemplateParamLists, 7500 SkipBodyInfo *SkipBody = nullptr); 7501 7502 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, 7503 QualType NTTPType, 7504 SourceLocation Loc); 7505 7506 /// Get a template argument mapping the given template parameter to itself, 7507 /// e.g. for X in \c template<int X>, this would return an expression template 7508 /// argument referencing X. 7509 TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param, 7510 SourceLocation Location); 7511 7512 void translateTemplateArguments(const ASTTemplateArgsPtr &In, 7513 TemplateArgumentListInfo &Out); 7514 7515 ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType); 7516 7517 void NoteAllFoundTemplates(TemplateName Name); 7518 7519 QualType CheckTemplateIdType(TemplateName Template, 7520 SourceLocation TemplateLoc, 7521 TemplateArgumentListInfo &TemplateArgs); 7522 7523 TypeResult 7524 ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 7525 TemplateTy Template, IdentifierInfo *TemplateII, 7526 SourceLocation TemplateIILoc, SourceLocation LAngleLoc, 7527 ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, 7528 bool IsCtorOrDtorName = false, bool IsClassName = false); 7529 7530 /// Parsed an elaborated-type-specifier that refers to a template-id, 7531 /// such as \c class T::template apply<U>. 7532 TypeResult ActOnTagTemplateIdType(TagUseKind TUK, 7533 TypeSpecifierType TagSpec, 7534 SourceLocation TagLoc, 7535 CXXScopeSpec &SS, 7536 SourceLocation TemplateKWLoc, 7537 TemplateTy TemplateD, 7538 SourceLocation TemplateLoc, 7539 SourceLocation LAngleLoc, 7540 ASTTemplateArgsPtr TemplateArgsIn, 7541 SourceLocation RAngleLoc); 7542 7543 DeclResult ActOnVarTemplateSpecialization( 7544 Scope *S, Declarator &D, TypeSourceInfo *DI, 7545 SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, 7546 StorageClass SC, bool IsPartialSpecialization); 7547 7548 /// Get the specialization of the given variable template corresponding to 7549 /// the specified argument list, or a null-but-valid result if the arguments 7550 /// are dependent. 7551 DeclResult CheckVarTemplateId(VarTemplateDecl *Template, 7552 SourceLocation TemplateLoc, 7553 SourceLocation TemplateNameLoc, 7554 const TemplateArgumentListInfo &TemplateArgs); 7555 7556 /// Form a reference to the specialization of the given variable template 7557 /// corresponding to the specified argument list, or a null-but-valid result 7558 /// if the arguments are dependent. 7559 ExprResult CheckVarTemplateId(const CXXScopeSpec &SS, 7560 const DeclarationNameInfo &NameInfo, 7561 VarTemplateDecl *Template, 7562 SourceLocation TemplateLoc, 7563 const TemplateArgumentListInfo *TemplateArgs); 7564 7565 ExprResult 7566 CheckConceptTemplateId(const CXXScopeSpec &SS, 7567 SourceLocation TemplateKWLoc, 7568 const DeclarationNameInfo &ConceptNameInfo, 7569 NamedDecl *FoundDecl, ConceptDecl *NamedConcept, 7570 const TemplateArgumentListInfo *TemplateArgs); 7571 7572 void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc); 7573 7574 ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, 7575 SourceLocation TemplateKWLoc, 7576 LookupResult &R, 7577 bool RequiresADL, 7578 const TemplateArgumentListInfo *TemplateArgs); 7579 7580 ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, 7581 SourceLocation TemplateKWLoc, 7582 const DeclarationNameInfo &NameInfo, 7583 const TemplateArgumentListInfo *TemplateArgs); 7584 7585 TemplateNameKind ActOnTemplateName( 7586 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 7587 const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, 7588 TemplateTy &Template, bool AllowInjectedClassName = false); 7589 7590 DeclResult ActOnClassTemplateSpecialization( 7591 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, 7592 SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, 7593 TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, 7594 MultiTemplateParamsArg TemplateParameterLists, 7595 SkipBodyInfo *SkipBody = nullptr); 7596 7597 bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, 7598 TemplateDecl *PrimaryTemplate, 7599 unsigned NumExplicitArgs, 7600 ArrayRef<TemplateArgument> Args); 7601 void CheckTemplatePartialSpecialization( 7602 ClassTemplatePartialSpecializationDecl *Partial); 7603 void CheckTemplatePartialSpecialization( 7604 VarTemplatePartialSpecializationDecl *Partial); 7605 7606 Decl *ActOnTemplateDeclarator(Scope *S, 7607 MultiTemplateParamsArg TemplateParameterLists, 7608 Declarator &D); 7609 7610 bool 7611 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, 7612 TemplateSpecializationKind NewTSK, 7613 NamedDecl *PrevDecl, 7614 TemplateSpecializationKind PrevTSK, 7615 SourceLocation PrevPtOfInstantiation, 7616 bool &SuppressNew); 7617 7618 bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, 7619 const TemplateArgumentListInfo &ExplicitTemplateArgs, 7620 LookupResult &Previous); 7621 7622 bool CheckFunctionTemplateSpecialization( 7623 FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, 7624 LookupResult &Previous, bool QualifiedFriend = false); 7625 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous); 7626 void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous); 7627 7628 DeclResult ActOnExplicitInstantiation( 7629 Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, 7630 unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, 7631 TemplateTy Template, SourceLocation TemplateNameLoc, 7632 SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, 7633 SourceLocation RAngleLoc, const ParsedAttributesView &Attr); 7634 7635 DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, 7636 SourceLocation TemplateLoc, 7637 unsigned TagSpec, SourceLocation KWLoc, 7638 CXXScopeSpec &SS, IdentifierInfo *Name, 7639 SourceLocation NameLoc, 7640 const ParsedAttributesView &Attr); 7641 7642 DeclResult ActOnExplicitInstantiation(Scope *S, 7643 SourceLocation ExternLoc, 7644 SourceLocation TemplateLoc, 7645 Declarator &D); 7646 7647 TemplateArgumentLoc 7648 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, 7649 SourceLocation TemplateLoc, 7650 SourceLocation RAngleLoc, 7651 Decl *Param, 7652 SmallVectorImpl<TemplateArgument> 7653 &Converted, 7654 bool &HasDefaultArg); 7655 7656 /// Specifies the context in which a particular template 7657 /// argument is being checked. 7658 enum CheckTemplateArgumentKind { 7659 /// The template argument was specified in the code or was 7660 /// instantiated with some deduced template arguments. 7661 CTAK_Specified, 7662 7663 /// The template argument was deduced via template argument 7664 /// deduction. 7665 CTAK_Deduced, 7666 7667 /// The template argument was deduced from an array bound 7668 /// via template argument deduction. 7669 CTAK_DeducedFromArrayBound 7670 }; 7671 7672 bool CheckTemplateArgument(NamedDecl *Param, 7673 TemplateArgumentLoc &Arg, 7674 NamedDecl *Template, 7675 SourceLocation TemplateLoc, 7676 SourceLocation RAngleLoc, 7677 unsigned ArgumentPackIndex, 7678 SmallVectorImpl<TemplateArgument> &Converted, 7679 CheckTemplateArgumentKind CTAK = CTAK_Specified); 7680 7681 /// Check that the given template arguments can be be provided to 7682 /// the given template, converting the arguments along the way. 7683 /// 7684 /// \param Template The template to which the template arguments are being 7685 /// provided. 7686 /// 7687 /// \param TemplateLoc The location of the template name in the source. 7688 /// 7689 /// \param TemplateArgs The list of template arguments. If the template is 7690 /// a template template parameter, this function may extend the set of 7691 /// template arguments to also include substituted, defaulted template 7692 /// arguments. 7693 /// 7694 /// \param PartialTemplateArgs True if the list of template arguments is 7695 /// intentionally partial, e.g., because we're checking just the initial 7696 /// set of template arguments. 7697 /// 7698 /// \param Converted Will receive the converted, canonicalized template 7699 /// arguments. 7700 /// 7701 /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to 7702 /// contain the converted forms of the template arguments as written. 7703 /// Otherwise, \p TemplateArgs will not be modified. 7704 /// 7705 /// \param ConstraintsNotSatisfied If provided, and an error occured, will 7706 /// receive true if the cause for the error is the associated constraints of 7707 /// the template not being satisfied by the template arguments. 7708 /// 7709 /// \returns true if an error occurred, false otherwise. 7710 bool CheckTemplateArgumentList(TemplateDecl *Template, 7711 SourceLocation TemplateLoc, 7712 TemplateArgumentListInfo &TemplateArgs, 7713 bool PartialTemplateArgs, 7714 SmallVectorImpl<TemplateArgument> &Converted, 7715 bool UpdateArgsWithConversions = true, 7716 bool *ConstraintsNotSatisfied = nullptr); 7717 7718 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, 7719 TemplateArgumentLoc &Arg, 7720 SmallVectorImpl<TemplateArgument> &Converted); 7721 7722 bool CheckTemplateArgument(TemplateTypeParmDecl *Param, 7723 TypeSourceInfo *Arg); 7724 ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param, 7725 QualType InstantiatedParamType, Expr *Arg, 7726 TemplateArgument &Converted, 7727 CheckTemplateArgumentKind CTAK = CTAK_Specified); 7728 bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, 7729 TemplateParameterList *Params, 7730 TemplateArgumentLoc &Arg); 7731 7732 ExprResult 7733 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, 7734 QualType ParamType, 7735 SourceLocation Loc); 7736 ExprResult 7737 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, 7738 SourceLocation Loc); 7739 7740 /// Enumeration describing how template parameter lists are compared 7741 /// for equality. 7742 enum TemplateParameterListEqualKind { 7743 /// We are matching the template parameter lists of two templates 7744 /// that might be redeclarations. 7745 /// 7746 /// \code 7747 /// template<typename T> struct X; 7748 /// template<typename T> struct X; 7749 /// \endcode 7750 TPL_TemplateMatch, 7751 7752 /// We are matching the template parameter lists of two template 7753 /// template parameters as part of matching the template parameter lists 7754 /// of two templates that might be redeclarations. 7755 /// 7756 /// \code 7757 /// template<template<int I> class TT> struct X; 7758 /// template<template<int Value> class Other> struct X; 7759 /// \endcode 7760 TPL_TemplateTemplateParmMatch, 7761 7762 /// We are matching the template parameter lists of a template 7763 /// template argument against the template parameter lists of a template 7764 /// template parameter. 7765 /// 7766 /// \code 7767 /// template<template<int Value> class Metafun> struct X; 7768 /// template<int Value> struct integer_c; 7769 /// X<integer_c> xic; 7770 /// \endcode 7771 TPL_TemplateTemplateArgumentMatch 7772 }; 7773 7774 bool TemplateParameterListsAreEqual(TemplateParameterList *New, 7775 TemplateParameterList *Old, 7776 bool Complain, 7777 TemplateParameterListEqualKind Kind, 7778 SourceLocation TemplateArgLoc 7779 = SourceLocation()); 7780 7781 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams); 7782 7783 /// Called when the parser has parsed a C++ typename 7784 /// specifier, e.g., "typename T::type". 7785 /// 7786 /// \param S The scope in which this typename type occurs. 7787 /// \param TypenameLoc the location of the 'typename' keyword 7788 /// \param SS the nested-name-specifier following the typename (e.g., 'T::'). 7789 /// \param II the identifier we're retrieving (e.g., 'type' in the example). 7790 /// \param IdLoc the location of the identifier. 7791 TypeResult 7792 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 7793 const CXXScopeSpec &SS, const IdentifierInfo &II, 7794 SourceLocation IdLoc); 7795 7796 /// Called when the parser has parsed a C++ typename 7797 /// specifier that ends in a template-id, e.g., 7798 /// "typename MetaFun::template apply<T1, T2>". 7799 /// 7800 /// \param S The scope in which this typename type occurs. 7801 /// \param TypenameLoc the location of the 'typename' keyword 7802 /// \param SS the nested-name-specifier following the typename (e.g., 'T::'). 7803 /// \param TemplateLoc the location of the 'template' keyword, if any. 7804 /// \param TemplateName The template name. 7805 /// \param TemplateII The identifier used to name the template. 7806 /// \param TemplateIILoc The location of the template name. 7807 /// \param LAngleLoc The location of the opening angle bracket ('<'). 7808 /// \param TemplateArgs The template arguments. 7809 /// \param RAngleLoc The location of the closing angle bracket ('>'). 7810 TypeResult 7811 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 7812 const CXXScopeSpec &SS, 7813 SourceLocation TemplateLoc, 7814 TemplateTy TemplateName, 7815 IdentifierInfo *TemplateII, 7816 SourceLocation TemplateIILoc, 7817 SourceLocation LAngleLoc, 7818 ASTTemplateArgsPtr TemplateArgs, 7819 SourceLocation RAngleLoc); 7820 7821 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, 7822 SourceLocation KeywordLoc, 7823 NestedNameSpecifierLoc QualifierLoc, 7824 const IdentifierInfo &II, 7825 SourceLocation IILoc, 7826 TypeSourceInfo **TSI, 7827 bool DeducedTSTContext); 7828 7829 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, 7830 SourceLocation KeywordLoc, 7831 NestedNameSpecifierLoc QualifierLoc, 7832 const IdentifierInfo &II, 7833 SourceLocation IILoc, 7834 bool DeducedTSTContext = true); 7835 7836 7837 TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, 7838 SourceLocation Loc, 7839 DeclarationName Name); 7840 bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS); 7841 7842 ExprResult RebuildExprInCurrentInstantiation(Expr *E); 7843 bool RebuildTemplateParamsInCurrentInstantiation( 7844 TemplateParameterList *Params); 7845 7846 std::string 7847 getTemplateArgumentBindingsText(const TemplateParameterList *Params, 7848 const TemplateArgumentList &Args); 7849 7850 std::string 7851 getTemplateArgumentBindingsText(const TemplateParameterList *Params, 7852 const TemplateArgument *Args, 7853 unsigned NumArgs); 7854 7855 //===--------------------------------------------------------------------===// 7856 // C++ Concepts 7857 //===--------------------------------------------------------------------===// 7858 Decl *ActOnConceptDefinition( 7859 Scope *S, MultiTemplateParamsArg TemplateParameterLists, 7860 IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr); 7861 7862 RequiresExprBodyDecl * 7863 ActOnStartRequiresExpr(SourceLocation RequiresKWLoc, 7864 ArrayRef<ParmVarDecl *> LocalParameters, 7865 Scope *BodyScope); 7866 void ActOnFinishRequiresExpr(); 7867 concepts::Requirement *ActOnSimpleRequirement(Expr *E); 7868 concepts::Requirement *ActOnTypeRequirement( 7869 SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc, 7870 IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId); 7871 concepts::Requirement *ActOnCompoundRequirement(Expr *E, 7872 SourceLocation NoexceptLoc); 7873 concepts::Requirement * 7874 ActOnCompoundRequirement( 7875 Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS, 7876 TemplateIdAnnotation *TypeConstraint, unsigned Depth); 7877 concepts::Requirement *ActOnNestedRequirement(Expr *Constraint); 7878 concepts::ExprRequirement * 7879 BuildExprRequirement( 7880 Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc, 7881 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement); 7882 concepts::ExprRequirement * 7883 BuildExprRequirement( 7884 concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag, 7885 bool IsSatisfied, SourceLocation NoexceptLoc, 7886 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement); 7887 concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type); 7888 concepts::TypeRequirement * 7889 BuildTypeRequirement( 7890 concepts::Requirement::SubstitutionDiagnostic *SubstDiag); 7891 concepts::NestedRequirement *BuildNestedRequirement(Expr *E); 7892 concepts::NestedRequirement * 7893 BuildNestedRequirement( 7894 concepts::Requirement::SubstitutionDiagnostic *SubstDiag); 7895 ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc, 7896 RequiresExprBodyDecl *Body, 7897 ArrayRef<ParmVarDecl *> LocalParameters, 7898 ArrayRef<concepts::Requirement *> Requirements, 7899 SourceLocation ClosingBraceLoc); 7900 7901 //===--------------------------------------------------------------------===// 7902 // C++ Variadic Templates (C++0x [temp.variadic]) 7903 //===--------------------------------------------------------------------===// 7904 7905 /// Determine whether an unexpanded parameter pack might be permitted in this 7906 /// location. Useful for error recovery. 7907 bool isUnexpandedParameterPackPermitted(); 7908 7909 /// The context in which an unexpanded parameter pack is 7910 /// being diagnosed. 7911 /// 7912 /// Note that the values of this enumeration line up with the first 7913 /// argument to the \c err_unexpanded_parameter_pack diagnostic. 7914 enum UnexpandedParameterPackContext { 7915 /// An arbitrary expression. 7916 UPPC_Expression = 0, 7917 7918 /// The base type of a class type. 7919 UPPC_BaseType, 7920 7921 /// The type of an arbitrary declaration. 7922 UPPC_DeclarationType, 7923 7924 /// The type of a data member. 7925 UPPC_DataMemberType, 7926 7927 /// The size of a bit-field. 7928 UPPC_BitFieldWidth, 7929 7930 /// The expression in a static assertion. 7931 UPPC_StaticAssertExpression, 7932 7933 /// The fixed underlying type of an enumeration. 7934 UPPC_FixedUnderlyingType, 7935 7936 /// The enumerator value. 7937 UPPC_EnumeratorValue, 7938 7939 /// A using declaration. 7940 UPPC_UsingDeclaration, 7941 7942 /// A friend declaration. 7943 UPPC_FriendDeclaration, 7944 7945 /// A declaration qualifier. 7946 UPPC_DeclarationQualifier, 7947 7948 /// An initializer. 7949 UPPC_Initializer, 7950 7951 /// A default argument. 7952 UPPC_DefaultArgument, 7953 7954 /// The type of a non-type template parameter. 7955 UPPC_NonTypeTemplateParameterType, 7956 7957 /// The type of an exception. 7958 UPPC_ExceptionType, 7959 7960 /// Partial specialization. 7961 UPPC_PartialSpecialization, 7962 7963 /// Microsoft __if_exists. 7964 UPPC_IfExists, 7965 7966 /// Microsoft __if_not_exists. 7967 UPPC_IfNotExists, 7968 7969 /// Lambda expression. 7970 UPPC_Lambda, 7971 7972 /// Block expression. 7973 UPPC_Block, 7974 7975 /// A type constraint. 7976 UPPC_TypeConstraint, 7977 7978 // A requirement in a requires-expression. 7979 UPPC_Requirement, 7980 7981 // A requires-clause. 7982 UPPC_RequiresClause, 7983 }; 7984 7985 /// Diagnose unexpanded parameter packs. 7986 /// 7987 /// \param Loc The location at which we should emit the diagnostic. 7988 /// 7989 /// \param UPPC The context in which we are diagnosing unexpanded 7990 /// parameter packs. 7991 /// 7992 /// \param Unexpanded the set of unexpanded parameter packs. 7993 /// 7994 /// \returns true if an error occurred, false otherwise. 7995 bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, 7996 UnexpandedParameterPackContext UPPC, 7997 ArrayRef<UnexpandedParameterPack> Unexpanded); 7998 7999 /// If the given type contains an unexpanded parameter pack, 8000 /// diagnose the error. 8001 /// 8002 /// \param Loc The source location where a diagnostc should be emitted. 8003 /// 8004 /// \param T The type that is being checked for unexpanded parameter 8005 /// packs. 8006 /// 8007 /// \returns true if an error occurred, false otherwise. 8008 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, 8009 UnexpandedParameterPackContext UPPC); 8010 8011 /// If the given expression contains an unexpanded parameter 8012 /// pack, diagnose the error. 8013 /// 8014 /// \param E The expression that is being checked for unexpanded 8015 /// parameter packs. 8016 /// 8017 /// \returns true if an error occurred, false otherwise. 8018 bool DiagnoseUnexpandedParameterPack(Expr *E, 8019 UnexpandedParameterPackContext UPPC = UPPC_Expression); 8020 8021 /// If the given requirees-expression contains an unexpanded reference to one 8022 /// of its own parameter packs, diagnose the error. 8023 /// 8024 /// \param RE The requiress-expression that is being checked for unexpanded 8025 /// parameter packs. 8026 /// 8027 /// \returns true if an error occurred, false otherwise. 8028 bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE); 8029 8030 /// If the given nested-name-specifier contains an unexpanded 8031 /// parameter pack, diagnose the error. 8032 /// 8033 /// \param SS The nested-name-specifier that is being checked for 8034 /// unexpanded parameter packs. 8035 /// 8036 /// \returns true if an error occurred, false otherwise. 8037 bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS, 8038 UnexpandedParameterPackContext UPPC); 8039 8040 /// If the given name contains an unexpanded parameter pack, 8041 /// diagnose the error. 8042 /// 8043 /// \param NameInfo The name (with source location information) that 8044 /// is being checked for unexpanded parameter packs. 8045 /// 8046 /// \returns true if an error occurred, false otherwise. 8047 bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo, 8048 UnexpandedParameterPackContext UPPC); 8049 8050 /// If the given template name contains an unexpanded parameter pack, 8051 /// diagnose the error. 8052 /// 8053 /// \param Loc The location of the template name. 8054 /// 8055 /// \param Template The template name that is being checked for unexpanded 8056 /// parameter packs. 8057 /// 8058 /// \returns true if an error occurred, false otherwise. 8059 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, 8060 TemplateName Template, 8061 UnexpandedParameterPackContext UPPC); 8062 8063 /// If the given template argument contains an unexpanded parameter 8064 /// pack, diagnose the error. 8065 /// 8066 /// \param Arg The template argument that is being checked for unexpanded 8067 /// parameter packs. 8068 /// 8069 /// \returns true if an error occurred, false otherwise. 8070 bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg, 8071 UnexpandedParameterPackContext UPPC); 8072 8073 /// Collect the set of unexpanded parameter packs within the given 8074 /// template argument. 8075 /// 8076 /// \param Arg The template argument that will be traversed to find 8077 /// unexpanded parameter packs. 8078 void collectUnexpandedParameterPacks(TemplateArgument Arg, 8079 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8080 8081 /// Collect the set of unexpanded parameter packs within the given 8082 /// template argument. 8083 /// 8084 /// \param Arg The template argument that will be traversed to find 8085 /// unexpanded parameter packs. 8086 void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg, 8087 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8088 8089 /// Collect the set of unexpanded parameter packs within the given 8090 /// type. 8091 /// 8092 /// \param T The type that will be traversed to find 8093 /// unexpanded parameter packs. 8094 void collectUnexpandedParameterPacks(QualType T, 8095 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8096 8097 /// Collect the set of unexpanded parameter packs within the given 8098 /// type. 8099 /// 8100 /// \param TL The type that will be traversed to find 8101 /// unexpanded parameter packs. 8102 void collectUnexpandedParameterPacks(TypeLoc TL, 8103 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8104 8105 /// Collect the set of unexpanded parameter packs within the given 8106 /// nested-name-specifier. 8107 /// 8108 /// \param NNS The nested-name-specifier that will be traversed to find 8109 /// unexpanded parameter packs. 8110 void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS, 8111 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8112 8113 /// Collect the set of unexpanded parameter packs within the given 8114 /// name. 8115 /// 8116 /// \param NameInfo The name that will be traversed to find 8117 /// unexpanded parameter packs. 8118 void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo, 8119 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8120 8121 /// Invoked when parsing a template argument followed by an 8122 /// ellipsis, which creates a pack expansion. 8123 /// 8124 /// \param Arg The template argument preceding the ellipsis, which 8125 /// may already be invalid. 8126 /// 8127 /// \param EllipsisLoc The location of the ellipsis. 8128 ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, 8129 SourceLocation EllipsisLoc); 8130 8131 /// Invoked when parsing a type followed by an ellipsis, which 8132 /// creates a pack expansion. 8133 /// 8134 /// \param Type The type preceding the ellipsis, which will become 8135 /// the pattern of the pack expansion. 8136 /// 8137 /// \param EllipsisLoc The location of the ellipsis. 8138 TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc); 8139 8140 /// Construct a pack expansion type from the pattern of the pack 8141 /// expansion. 8142 TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern, 8143 SourceLocation EllipsisLoc, 8144 Optional<unsigned> NumExpansions); 8145 8146 /// Construct a pack expansion type from the pattern of the pack 8147 /// expansion. 8148 QualType CheckPackExpansion(QualType Pattern, 8149 SourceRange PatternRange, 8150 SourceLocation EllipsisLoc, 8151 Optional<unsigned> NumExpansions); 8152 8153 /// Invoked when parsing an expression followed by an ellipsis, which 8154 /// creates a pack expansion. 8155 /// 8156 /// \param Pattern The expression preceding the ellipsis, which will become 8157 /// the pattern of the pack expansion. 8158 /// 8159 /// \param EllipsisLoc The location of the ellipsis. 8160 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc); 8161 8162 /// Invoked when parsing an expression followed by an ellipsis, which 8163 /// creates a pack expansion. 8164 /// 8165 /// \param Pattern The expression preceding the ellipsis, which will become 8166 /// the pattern of the pack expansion. 8167 /// 8168 /// \param EllipsisLoc The location of the ellipsis. 8169 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, 8170 Optional<unsigned> NumExpansions); 8171 8172 /// Determine whether we could expand a pack expansion with the 8173 /// given set of parameter packs into separate arguments by repeatedly 8174 /// transforming the pattern. 8175 /// 8176 /// \param EllipsisLoc The location of the ellipsis that identifies the 8177 /// pack expansion. 8178 /// 8179 /// \param PatternRange The source range that covers the entire pattern of 8180 /// the pack expansion. 8181 /// 8182 /// \param Unexpanded The set of unexpanded parameter packs within the 8183 /// pattern. 8184 /// 8185 /// \param ShouldExpand Will be set to \c true if the transformer should 8186 /// expand the corresponding pack expansions into separate arguments. When 8187 /// set, \c NumExpansions must also be set. 8188 /// 8189 /// \param RetainExpansion Whether the caller should add an unexpanded 8190 /// pack expansion after all of the expanded arguments. This is used 8191 /// when extending explicitly-specified template argument packs per 8192 /// C++0x [temp.arg.explicit]p9. 8193 /// 8194 /// \param NumExpansions The number of separate arguments that will be in 8195 /// the expanded form of the corresponding pack expansion. This is both an 8196 /// input and an output parameter, which can be set by the caller if the 8197 /// number of expansions is known a priori (e.g., due to a prior substitution) 8198 /// and will be set by the callee when the number of expansions is known. 8199 /// The callee must set this value when \c ShouldExpand is \c true; it may 8200 /// set this value in other cases. 8201 /// 8202 /// \returns true if an error occurred (e.g., because the parameter packs 8203 /// are to be instantiated with arguments of different lengths), false 8204 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions) 8205 /// must be set. 8206 bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, 8207 SourceRange PatternRange, 8208 ArrayRef<UnexpandedParameterPack> Unexpanded, 8209 const MultiLevelTemplateArgumentList &TemplateArgs, 8210 bool &ShouldExpand, 8211 bool &RetainExpansion, 8212 Optional<unsigned> &NumExpansions); 8213 8214 /// Determine the number of arguments in the given pack expansion 8215 /// type. 8216 /// 8217 /// This routine assumes that the number of arguments in the expansion is 8218 /// consistent across all of the unexpanded parameter packs in its pattern. 8219 /// 8220 /// Returns an empty Optional if the type can't be expanded. 8221 Optional<unsigned> getNumArgumentsInExpansion(QualType T, 8222 const MultiLevelTemplateArgumentList &TemplateArgs); 8223 8224 /// Determine whether the given declarator contains any unexpanded 8225 /// parameter packs. 8226 /// 8227 /// This routine is used by the parser to disambiguate function declarators 8228 /// with an ellipsis prior to the ')', e.g., 8229 /// 8230 /// \code 8231 /// void f(T...); 8232 /// \endcode 8233 /// 8234 /// To determine whether we have an (unnamed) function parameter pack or 8235 /// a variadic function. 8236 /// 8237 /// \returns true if the declarator contains any unexpanded parameter packs, 8238 /// false otherwise. 8239 bool containsUnexpandedParameterPacks(Declarator &D); 8240 8241 /// Returns the pattern of the pack expansion for a template argument. 8242 /// 8243 /// \param OrigLoc The template argument to expand. 8244 /// 8245 /// \param Ellipsis Will be set to the location of the ellipsis. 8246 /// 8247 /// \param NumExpansions Will be set to the number of expansions that will 8248 /// be generated from this pack expansion, if known a priori. 8249 TemplateArgumentLoc getTemplateArgumentPackExpansionPattern( 8250 TemplateArgumentLoc OrigLoc, 8251 SourceLocation &Ellipsis, 8252 Optional<unsigned> &NumExpansions) const; 8253 8254 /// Given a template argument that contains an unexpanded parameter pack, but 8255 /// which has already been substituted, attempt to determine the number of 8256 /// elements that will be produced once this argument is fully-expanded. 8257 /// 8258 /// This is intended for use when transforming 'sizeof...(Arg)' in order to 8259 /// avoid actually expanding the pack where possible. 8260 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg); 8261 8262 //===--------------------------------------------------------------------===// 8263 // C++ Template Argument Deduction (C++ [temp.deduct]) 8264 //===--------------------------------------------------------------------===// 8265 8266 /// Adjust the type \p ArgFunctionType to match the calling convention, 8267 /// noreturn, and optionally the exception specification of \p FunctionType. 8268 /// Deduction often wants to ignore these properties when matching function 8269 /// types. 8270 QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, 8271 bool AdjustExceptionSpec = false); 8272 8273 /// Describes the result of template argument deduction. 8274 /// 8275 /// The TemplateDeductionResult enumeration describes the result of 8276 /// template argument deduction, as returned from 8277 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo 8278 /// structure provides additional information about the results of 8279 /// template argument deduction, e.g., the deduced template argument 8280 /// list (if successful) or the specific template parameters or 8281 /// deduced arguments that were involved in the failure. 8282 enum TemplateDeductionResult { 8283 /// Template argument deduction was successful. 8284 TDK_Success = 0, 8285 /// The declaration was invalid; do nothing. 8286 TDK_Invalid, 8287 /// Template argument deduction exceeded the maximum template 8288 /// instantiation depth (which has already been diagnosed). 8289 TDK_InstantiationDepth, 8290 /// Template argument deduction did not deduce a value 8291 /// for every template parameter. 8292 TDK_Incomplete, 8293 /// Template argument deduction did not deduce a value for every 8294 /// expansion of an expanded template parameter pack. 8295 TDK_IncompletePack, 8296 /// Template argument deduction produced inconsistent 8297 /// deduced values for the given template parameter. 8298 TDK_Inconsistent, 8299 /// Template argument deduction failed due to inconsistent 8300 /// cv-qualifiers on a template parameter type that would 8301 /// otherwise be deduced, e.g., we tried to deduce T in "const T" 8302 /// but were given a non-const "X". 8303 TDK_Underqualified, 8304 /// Substitution of the deduced template argument values 8305 /// resulted in an error. 8306 TDK_SubstitutionFailure, 8307 /// After substituting deduced template arguments, a dependent 8308 /// parameter type did not match the corresponding argument. 8309 TDK_DeducedMismatch, 8310 /// After substituting deduced template arguments, an element of 8311 /// a dependent parameter type did not match the corresponding element 8312 /// of the corresponding argument (when deducing from an initializer list). 8313 TDK_DeducedMismatchNested, 8314 /// A non-depnedent component of the parameter did not match the 8315 /// corresponding component of the argument. 8316 TDK_NonDeducedMismatch, 8317 /// When performing template argument deduction for a function 8318 /// template, there were too many call arguments. 8319 TDK_TooManyArguments, 8320 /// When performing template argument deduction for a function 8321 /// template, there were too few call arguments. 8322 TDK_TooFewArguments, 8323 /// The explicitly-specified template arguments were not valid 8324 /// template arguments for the given template. 8325 TDK_InvalidExplicitArguments, 8326 /// Checking non-dependent argument conversions failed. 8327 TDK_NonDependentConversionFailure, 8328 /// The deduced arguments did not satisfy the constraints associated 8329 /// with the template. 8330 TDK_ConstraintsNotSatisfied, 8331 /// Deduction failed; that's all we know. 8332 TDK_MiscellaneousDeductionFailure, 8333 /// CUDA Target attributes do not match. 8334 TDK_CUDATargetMismatch 8335 }; 8336 8337 TemplateDeductionResult 8338 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 8339 const TemplateArgumentList &TemplateArgs, 8340 sema::TemplateDeductionInfo &Info); 8341 8342 TemplateDeductionResult 8343 DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, 8344 const TemplateArgumentList &TemplateArgs, 8345 sema::TemplateDeductionInfo &Info); 8346 8347 TemplateDeductionResult SubstituteExplicitTemplateArguments( 8348 FunctionTemplateDecl *FunctionTemplate, 8349 TemplateArgumentListInfo &ExplicitTemplateArgs, 8350 SmallVectorImpl<DeducedTemplateArgument> &Deduced, 8351 SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType, 8352 sema::TemplateDeductionInfo &Info); 8353 8354 /// brief A function argument from which we performed template argument 8355 // deduction for a call. 8356 struct OriginalCallArg { OriginalCallArgOriginalCallArg8357 OriginalCallArg(QualType OriginalParamType, bool DecomposedParam, 8358 unsigned ArgIdx, QualType OriginalArgType) 8359 : OriginalParamType(OriginalParamType), 8360 DecomposedParam(DecomposedParam), ArgIdx(ArgIdx), 8361 OriginalArgType(OriginalArgType) {} 8362 8363 QualType OriginalParamType; 8364 bool DecomposedParam; 8365 unsigned ArgIdx; 8366 QualType OriginalArgType; 8367 }; 8368 8369 TemplateDeductionResult FinishTemplateArgumentDeduction( 8370 FunctionTemplateDecl *FunctionTemplate, 8371 SmallVectorImpl<DeducedTemplateArgument> &Deduced, 8372 unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, 8373 sema::TemplateDeductionInfo &Info, 8374 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr, 8375 bool PartialOverloading = false, 8376 llvm::function_ref<bool()> CheckNonDependent = []{ return false; }); 8377 8378 TemplateDeductionResult DeduceTemplateArguments( 8379 FunctionTemplateDecl *FunctionTemplate, 8380 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, 8381 FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info, 8382 bool PartialOverloading, 8383 llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent); 8384 8385 TemplateDeductionResult 8386 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 8387 TemplateArgumentListInfo *ExplicitTemplateArgs, 8388 QualType ArgFunctionType, 8389 FunctionDecl *&Specialization, 8390 sema::TemplateDeductionInfo &Info, 8391 bool IsAddressOfFunction = false); 8392 8393 TemplateDeductionResult 8394 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 8395 QualType ToType, 8396 CXXConversionDecl *&Specialization, 8397 sema::TemplateDeductionInfo &Info); 8398 8399 TemplateDeductionResult 8400 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 8401 TemplateArgumentListInfo *ExplicitTemplateArgs, 8402 FunctionDecl *&Specialization, 8403 sema::TemplateDeductionInfo &Info, 8404 bool IsAddressOfFunction = false); 8405 8406 /// Substitute Replacement for \p auto in \p TypeWithAuto 8407 QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement); 8408 /// Substitute Replacement for auto in TypeWithAuto 8409 TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, 8410 QualType Replacement); 8411 /// Completely replace the \c auto in \p TypeWithAuto by 8412 /// \p Replacement. This does not retain any \c auto type sugar. 8413 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement); 8414 TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, 8415 QualType Replacement); 8416 8417 /// Result type of DeduceAutoType. 8418 enum DeduceAutoResult { 8419 DAR_Succeeded, 8420 DAR_Failed, 8421 DAR_FailedAlreadyDiagnosed 8422 }; 8423 8424 DeduceAutoResult 8425 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, 8426 Optional<unsigned> DependentDeductionDepth = None, 8427 bool IgnoreConstraints = false); 8428 DeduceAutoResult 8429 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result, 8430 Optional<unsigned> DependentDeductionDepth = None, 8431 bool IgnoreConstraints = false); 8432 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init); 8433 bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, 8434 bool Diagnose = true); 8435 8436 /// Declare implicit deduction guides for a class template if we've 8437 /// not already done so. 8438 void DeclareImplicitDeductionGuides(TemplateDecl *Template, 8439 SourceLocation Loc); 8440 8441 QualType DeduceTemplateSpecializationFromInitializer( 8442 TypeSourceInfo *TInfo, const InitializedEntity &Entity, 8443 const InitializationKind &Kind, MultiExprArg Init); 8444 8445 QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, 8446 QualType Type, TypeSourceInfo *TSI, 8447 SourceRange Range, bool DirectInit, 8448 Expr *Init); 8449 8450 TypeLoc getReturnTypeLoc(FunctionDecl *FD) const; 8451 8452 bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, 8453 SourceLocation ReturnLoc, 8454 Expr *&RetExpr, AutoType *AT); 8455 8456 FunctionTemplateDecl *getMoreSpecializedTemplate( 8457 FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, 8458 TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, 8459 unsigned NumCallArguments2, bool Reversed = false); 8460 UnresolvedSetIterator 8461 getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, 8462 TemplateSpecCandidateSet &FailedCandidates, 8463 SourceLocation Loc, 8464 const PartialDiagnostic &NoneDiag, 8465 const PartialDiagnostic &AmbigDiag, 8466 const PartialDiagnostic &CandidateDiag, 8467 bool Complain = true, QualType TargetType = QualType()); 8468 8469 ClassTemplatePartialSpecializationDecl * 8470 getMoreSpecializedPartialSpecialization( 8471 ClassTemplatePartialSpecializationDecl *PS1, 8472 ClassTemplatePartialSpecializationDecl *PS2, 8473 SourceLocation Loc); 8474 8475 bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, 8476 sema::TemplateDeductionInfo &Info); 8477 8478 VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization( 8479 VarTemplatePartialSpecializationDecl *PS1, 8480 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc); 8481 8482 bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T, 8483 sema::TemplateDeductionInfo &Info); 8484 8485 bool isTemplateTemplateParameterAtLeastAsSpecializedAs( 8486 TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc); 8487 8488 void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, 8489 unsigned Depth, llvm::SmallBitVector &Used); 8490 8491 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 8492 bool OnlyDeduced, 8493 unsigned Depth, 8494 llvm::SmallBitVector &Used); MarkDeducedTemplateParameters(const FunctionTemplateDecl * FunctionTemplate,llvm::SmallBitVector & Deduced)8495 void MarkDeducedTemplateParameters( 8496 const FunctionTemplateDecl *FunctionTemplate, 8497 llvm::SmallBitVector &Deduced) { 8498 return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced); 8499 } 8500 static void MarkDeducedTemplateParameters(ASTContext &Ctx, 8501 const FunctionTemplateDecl *FunctionTemplate, 8502 llvm::SmallBitVector &Deduced); 8503 8504 //===--------------------------------------------------------------------===// 8505 // C++ Template Instantiation 8506 // 8507 8508 MultiLevelTemplateArgumentList 8509 getTemplateInstantiationArgs(NamedDecl *D, 8510 const TemplateArgumentList *Innermost = nullptr, 8511 bool RelativeToPrimary = false, 8512 const FunctionDecl *Pattern = nullptr); 8513 8514 /// A context in which code is being synthesized (where a source location 8515 /// alone is not sufficient to identify the context). This covers template 8516 /// instantiation and various forms of implicitly-generated functions. 8517 struct CodeSynthesisContext { 8518 /// The kind of template instantiation we are performing 8519 enum SynthesisKind { 8520 /// We are instantiating a template declaration. The entity is 8521 /// the declaration we're instantiating (e.g., a CXXRecordDecl). 8522 TemplateInstantiation, 8523 8524 /// We are instantiating a default argument for a template 8525 /// parameter. The Entity is the template parameter whose argument is 8526 /// being instantiated, the Template is the template, and the 8527 /// TemplateArgs/NumTemplateArguments provide the template arguments as 8528 /// specified. 8529 DefaultTemplateArgumentInstantiation, 8530 8531 /// We are instantiating a default argument for a function. 8532 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs 8533 /// provides the template arguments as specified. 8534 DefaultFunctionArgumentInstantiation, 8535 8536 /// We are substituting explicit template arguments provided for 8537 /// a function template. The entity is a FunctionTemplateDecl. 8538 ExplicitTemplateArgumentSubstitution, 8539 8540 /// We are substituting template argument determined as part of 8541 /// template argument deduction for either a class template 8542 /// partial specialization or a function template. The 8543 /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or 8544 /// a TemplateDecl. 8545 DeducedTemplateArgumentSubstitution, 8546 8547 /// We are substituting prior template arguments into a new 8548 /// template parameter. The template parameter itself is either a 8549 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl. 8550 PriorTemplateArgumentSubstitution, 8551 8552 /// We are checking the validity of a default template argument that 8553 /// has been used when naming a template-id. 8554 DefaultTemplateArgumentChecking, 8555 8556 /// We are computing the exception specification for a defaulted special 8557 /// member function. 8558 ExceptionSpecEvaluation, 8559 8560 /// We are instantiating the exception specification for a function 8561 /// template which was deferred until it was needed. 8562 ExceptionSpecInstantiation, 8563 8564 /// We are instantiating a requirement of a requires expression. 8565 RequirementInstantiation, 8566 8567 /// We are checking the satisfaction of a nested requirement of a requires 8568 /// expression. 8569 NestedRequirementConstraintsCheck, 8570 8571 /// We are declaring an implicit special member function. 8572 DeclaringSpecialMember, 8573 8574 /// We are declaring an implicit 'operator==' for a defaulted 8575 /// 'operator<=>'. 8576 DeclaringImplicitEqualityComparison, 8577 8578 /// We are defining a synthesized function (such as a defaulted special 8579 /// member). 8580 DefiningSynthesizedFunction, 8581 8582 // We are checking the constraints associated with a constrained entity or 8583 // the constraint expression of a concept. This includes the checks that 8584 // atomic constraints have the type 'bool' and that they can be constant 8585 // evaluated. 8586 ConstraintsCheck, 8587 8588 // We are substituting template arguments into a constraint expression. 8589 ConstraintSubstitution, 8590 8591 // We are normalizing a constraint expression. 8592 ConstraintNormalization, 8593 8594 // We are substituting into the parameter mapping of an atomic constraint 8595 // during normalization. 8596 ParameterMappingSubstitution, 8597 8598 /// We are rewriting a comparison operator in terms of an operator<=>. 8599 RewritingOperatorAsSpaceship, 8600 8601 /// We are initializing a structured binding. 8602 InitializingStructuredBinding, 8603 8604 /// We are marking a class as __dllexport. 8605 MarkingClassDllexported, 8606 8607 /// Added for Template instantiation observation. 8608 /// Memoization means we are _not_ instantiating a template because 8609 /// it is already instantiated (but we entered a context where we 8610 /// would have had to if it was not already instantiated). 8611 Memoization 8612 } Kind; 8613 8614 /// Was the enclosing context a non-instantiation SFINAE context? 8615 bool SavedInNonInstantiationSFINAEContext; 8616 8617 /// The point of instantiation or synthesis within the source code. 8618 SourceLocation PointOfInstantiation; 8619 8620 /// The entity that is being synthesized. 8621 Decl *Entity; 8622 8623 /// The template (or partial specialization) in which we are 8624 /// performing the instantiation, for substitutions of prior template 8625 /// arguments. 8626 NamedDecl *Template; 8627 8628 /// The list of template arguments we are substituting, if they 8629 /// are not part of the entity. 8630 const TemplateArgument *TemplateArgs; 8631 8632 // FIXME: Wrap this union around more members, or perhaps store the 8633 // kind-specific members in the RAII object owning the context. 8634 union { 8635 /// The number of template arguments in TemplateArgs. 8636 unsigned NumTemplateArgs; 8637 8638 /// The special member being declared or defined. 8639 CXXSpecialMember SpecialMember; 8640 }; 8641 template_argumentsCodeSynthesisContext8642 ArrayRef<TemplateArgument> template_arguments() const { 8643 assert(Kind != DeclaringSpecialMember); 8644 return {TemplateArgs, NumTemplateArgs}; 8645 } 8646 8647 /// The template deduction info object associated with the 8648 /// substitution or checking of explicit or deduced template arguments. 8649 sema::TemplateDeductionInfo *DeductionInfo; 8650 8651 /// The source range that covers the construct that cause 8652 /// the instantiation, e.g., the template-id that causes a class 8653 /// template instantiation. 8654 SourceRange InstantiationRange; 8655 CodeSynthesisContextCodeSynthesisContext8656 CodeSynthesisContext() 8657 : Kind(TemplateInstantiation), 8658 SavedInNonInstantiationSFINAEContext(false), Entity(nullptr), 8659 Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0), 8660 DeductionInfo(nullptr) {} 8661 8662 /// Determines whether this template is an actual instantiation 8663 /// that should be counted toward the maximum instantiation depth. 8664 bool isInstantiationRecord() const; 8665 }; 8666 8667 /// List of active code synthesis contexts. 8668 /// 8669 /// This vector is treated as a stack. As synthesis of one entity requires 8670 /// synthesis of another, additional contexts are pushed onto the stack. 8671 SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts; 8672 8673 /// Specializations whose definitions are currently being instantiated. 8674 llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations; 8675 8676 /// Non-dependent types used in templates that have already been instantiated 8677 /// by some template instantiation. 8678 llvm::DenseSet<QualType> InstantiatedNonDependentTypes; 8679 8680 /// Extra modules inspected when performing a lookup during a template 8681 /// instantiation. Computed lazily. 8682 SmallVector<Module*, 16> CodeSynthesisContextLookupModules; 8683 8684 /// Cache of additional modules that should be used for name lookup 8685 /// within the current template instantiation. Computed lazily; use 8686 /// getLookupModules() to get a complete set. 8687 llvm::DenseSet<Module*> LookupModulesCache; 8688 8689 /// Get the set of additional modules that should be checked during 8690 /// name lookup. A module and its imports become visible when instanting a 8691 /// template defined within it. 8692 llvm::DenseSet<Module*> &getLookupModules(); 8693 8694 /// Map from the most recent declaration of a namespace to the most 8695 /// recent visible declaration of that namespace. 8696 llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache; 8697 8698 /// Whether we are in a SFINAE context that is not associated with 8699 /// template instantiation. 8700 /// 8701 /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside 8702 /// of a template instantiation or template argument deduction. 8703 bool InNonInstantiationSFINAEContext; 8704 8705 /// The number of \p CodeSynthesisContexts that are not template 8706 /// instantiations and, therefore, should not be counted as part of the 8707 /// instantiation depth. 8708 /// 8709 /// When the instantiation depth reaches the user-configurable limit 8710 /// \p LangOptions::InstantiationDepth we will abort instantiation. 8711 // FIXME: Should we have a similar limit for other forms of synthesis? 8712 unsigned NonInstantiationEntries; 8713 8714 /// The depth of the context stack at the point when the most recent 8715 /// error or warning was produced. 8716 /// 8717 /// This value is used to suppress printing of redundant context stacks 8718 /// when there are multiple errors or warnings in the same instantiation. 8719 // FIXME: Does this belong in Sema? It's tough to implement it anywhere else. 8720 unsigned LastEmittedCodeSynthesisContextDepth = 0; 8721 8722 /// The template instantiation callbacks to trace or track 8723 /// instantiations (objects can be chained). 8724 /// 8725 /// This callbacks is used to print, trace or track template 8726 /// instantiations as they are being constructed. 8727 std::vector<std::unique_ptr<TemplateInstantiationCallback>> 8728 TemplateInstCallbacks; 8729 8730 /// The current index into pack expansion arguments that will be 8731 /// used for substitution of parameter packs. 8732 /// 8733 /// The pack expansion index will be -1 to indicate that parameter packs 8734 /// should be instantiated as themselves. Otherwise, the index specifies 8735 /// which argument within the parameter pack will be used for substitution. 8736 int ArgumentPackSubstitutionIndex; 8737 8738 /// RAII object used to change the argument pack substitution index 8739 /// within a \c Sema object. 8740 /// 8741 /// See \c ArgumentPackSubstitutionIndex for more information. 8742 class ArgumentPackSubstitutionIndexRAII { 8743 Sema &Self; 8744 int OldSubstitutionIndex; 8745 8746 public: ArgumentPackSubstitutionIndexRAII(Sema & Self,int NewSubstitutionIndex)8747 ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex) 8748 : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) { 8749 Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex; 8750 } 8751 ~ArgumentPackSubstitutionIndexRAII()8752 ~ArgumentPackSubstitutionIndexRAII() { 8753 Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex; 8754 } 8755 }; 8756 8757 friend class ArgumentPackSubstitutionRAII; 8758 8759 /// For each declaration that involved template argument deduction, the 8760 /// set of diagnostics that were suppressed during that template argument 8761 /// deduction. 8762 /// 8763 /// FIXME: Serialize this structure to the AST file. 8764 typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> > 8765 SuppressedDiagnosticsMap; 8766 SuppressedDiagnosticsMap SuppressedDiagnostics; 8767 8768 /// A stack object to be created when performing template 8769 /// instantiation. 8770 /// 8771 /// Construction of an object of type \c InstantiatingTemplate 8772 /// pushes the current instantiation onto the stack of active 8773 /// instantiations. If the size of this stack exceeds the maximum 8774 /// number of recursive template instantiations, construction 8775 /// produces an error and evaluates true. 8776 /// 8777 /// Destruction of this object will pop the named instantiation off 8778 /// the stack. 8779 struct InstantiatingTemplate { 8780 /// Note that we are instantiating a class template, 8781 /// function template, variable template, alias template, 8782 /// or a member thereof. 8783 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8784 Decl *Entity, 8785 SourceRange InstantiationRange = SourceRange()); 8786 8787 struct ExceptionSpecification {}; 8788 /// Note that we are instantiating an exception specification 8789 /// of a function template. 8790 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8791 FunctionDecl *Entity, ExceptionSpecification, 8792 SourceRange InstantiationRange = SourceRange()); 8793 8794 /// Note that we are instantiating a default argument in a 8795 /// template-id. 8796 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8797 TemplateParameter Param, TemplateDecl *Template, 8798 ArrayRef<TemplateArgument> TemplateArgs, 8799 SourceRange InstantiationRange = SourceRange()); 8800 8801 /// Note that we are substituting either explicitly-specified or 8802 /// deduced template arguments during function template argument deduction. 8803 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8804 FunctionTemplateDecl *FunctionTemplate, 8805 ArrayRef<TemplateArgument> TemplateArgs, 8806 CodeSynthesisContext::SynthesisKind Kind, 8807 sema::TemplateDeductionInfo &DeductionInfo, 8808 SourceRange InstantiationRange = SourceRange()); 8809 8810 /// Note that we are instantiating as part of template 8811 /// argument deduction for a class template declaration. 8812 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8813 TemplateDecl *Template, 8814 ArrayRef<TemplateArgument> TemplateArgs, 8815 sema::TemplateDeductionInfo &DeductionInfo, 8816 SourceRange InstantiationRange = SourceRange()); 8817 8818 /// Note that we are instantiating as part of template 8819 /// argument deduction for a class template partial 8820 /// specialization. 8821 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8822 ClassTemplatePartialSpecializationDecl *PartialSpec, 8823 ArrayRef<TemplateArgument> TemplateArgs, 8824 sema::TemplateDeductionInfo &DeductionInfo, 8825 SourceRange InstantiationRange = SourceRange()); 8826 8827 /// Note that we are instantiating as part of template 8828 /// argument deduction for a variable template partial 8829 /// specialization. 8830 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8831 VarTemplatePartialSpecializationDecl *PartialSpec, 8832 ArrayRef<TemplateArgument> TemplateArgs, 8833 sema::TemplateDeductionInfo &DeductionInfo, 8834 SourceRange InstantiationRange = SourceRange()); 8835 8836 /// Note that we are instantiating a default argument for a function 8837 /// parameter. 8838 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8839 ParmVarDecl *Param, 8840 ArrayRef<TemplateArgument> TemplateArgs, 8841 SourceRange InstantiationRange = SourceRange()); 8842 8843 /// Note that we are substituting prior template arguments into a 8844 /// non-type parameter. 8845 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8846 NamedDecl *Template, 8847 NonTypeTemplateParmDecl *Param, 8848 ArrayRef<TemplateArgument> TemplateArgs, 8849 SourceRange InstantiationRange); 8850 8851 /// Note that we are substituting prior template arguments into a 8852 /// template template parameter. 8853 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8854 NamedDecl *Template, 8855 TemplateTemplateParmDecl *Param, 8856 ArrayRef<TemplateArgument> TemplateArgs, 8857 SourceRange InstantiationRange); 8858 8859 /// Note that we are checking the default template argument 8860 /// against the template parameter for a given template-id. 8861 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8862 TemplateDecl *Template, 8863 NamedDecl *Param, 8864 ArrayRef<TemplateArgument> TemplateArgs, 8865 SourceRange InstantiationRange); 8866 8867 struct ConstraintsCheck {}; 8868 /// \brief Note that we are checking the constraints associated with some 8869 /// constrained entity (a concept declaration or a template with associated 8870 /// constraints). 8871 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8872 ConstraintsCheck, NamedDecl *Template, 8873 ArrayRef<TemplateArgument> TemplateArgs, 8874 SourceRange InstantiationRange); 8875 8876 struct ConstraintSubstitution {}; 8877 /// \brief Note that we are checking a constraint expression associated 8878 /// with a template declaration or as part of the satisfaction check of a 8879 /// concept. 8880 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8881 ConstraintSubstitution, NamedDecl *Template, 8882 sema::TemplateDeductionInfo &DeductionInfo, 8883 SourceRange InstantiationRange); 8884 8885 struct ConstraintNormalization {}; 8886 /// \brief Note that we are normalizing a constraint expression. 8887 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8888 ConstraintNormalization, NamedDecl *Template, 8889 SourceRange InstantiationRange); 8890 8891 struct ParameterMappingSubstitution {}; 8892 /// \brief Note that we are subtituting into the parameter mapping of an 8893 /// atomic constraint during constraint normalization. 8894 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8895 ParameterMappingSubstitution, NamedDecl *Template, 8896 SourceRange InstantiationRange); 8897 8898 /// \brief Note that we are substituting template arguments into a part of 8899 /// a requirement of a requires expression. 8900 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8901 concepts::Requirement *Req, 8902 sema::TemplateDeductionInfo &DeductionInfo, 8903 SourceRange InstantiationRange = SourceRange()); 8904 8905 /// \brief Note that we are checking the satisfaction of the constraint 8906 /// expression inside of a nested requirement. 8907 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8908 concepts::NestedRequirement *Req, ConstraintsCheck, 8909 SourceRange InstantiationRange = SourceRange()); 8910 8911 /// Note that we have finished instantiating this template. 8912 void Clear(); 8913 ~InstantiatingTemplateInstantiatingTemplate8914 ~InstantiatingTemplate() { Clear(); } 8915 8916 /// Determines whether we have exceeded the maximum 8917 /// recursive template instantiations. isInvalidInstantiatingTemplate8918 bool isInvalid() const { return Invalid; } 8919 8920 /// Determine whether we are already instantiating this 8921 /// specialization in some surrounding active instantiation. isAlreadyInstantiatingInstantiatingTemplate8922 bool isAlreadyInstantiating() const { return AlreadyInstantiating; } 8923 8924 private: 8925 Sema &SemaRef; 8926 bool Invalid; 8927 bool AlreadyInstantiating; 8928 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation, 8929 SourceRange InstantiationRange); 8930 8931 InstantiatingTemplate( 8932 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind, 8933 SourceLocation PointOfInstantiation, SourceRange InstantiationRange, 8934 Decl *Entity, NamedDecl *Template = nullptr, 8935 ArrayRef<TemplateArgument> TemplateArgs = None, 8936 sema::TemplateDeductionInfo *DeductionInfo = nullptr); 8937 8938 InstantiatingTemplate(const InstantiatingTemplate&) = delete; 8939 8940 InstantiatingTemplate& 8941 operator=(const InstantiatingTemplate&) = delete; 8942 }; 8943 8944 void pushCodeSynthesisContext(CodeSynthesisContext Ctx); 8945 void popCodeSynthesisContext(); 8946 8947 /// Determine whether we are currently performing template instantiation. inTemplateInstantiation()8948 bool inTemplateInstantiation() const { 8949 return CodeSynthesisContexts.size() > NonInstantiationEntries; 8950 } 8951 PrintContextStack()8952 void PrintContextStack() { 8953 if (!CodeSynthesisContexts.empty() && 8954 CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) { 8955 PrintInstantiationStack(); 8956 LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size(); 8957 } 8958 if (PragmaAttributeCurrentTargetDecl) 8959 PrintPragmaAttributeInstantiationPoint(); 8960 } 8961 void PrintInstantiationStack(); 8962 8963 void PrintPragmaAttributeInstantiationPoint(); 8964 8965 /// Determines whether we are currently in a context where 8966 /// template argument substitution failures are not considered 8967 /// errors. 8968 /// 8969 /// \returns An empty \c Optional if we're not in a SFINAE context. 8970 /// Otherwise, contains a pointer that, if non-NULL, contains the nearest 8971 /// template-deduction context object, which can be used to capture 8972 /// diagnostics that will be suppressed. 8973 Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const; 8974 8975 /// Determines whether we are currently in a context that 8976 /// is not evaluated as per C++ [expr] p5. isUnevaluatedContext()8977 bool isUnevaluatedContext() const { 8978 assert(!ExprEvalContexts.empty() && 8979 "Must be in an expression evaluation context"); 8980 return ExprEvalContexts.back().isUnevaluated(); 8981 } 8982 8983 /// RAII class used to determine whether SFINAE has 8984 /// trapped any errors that occur during template argument 8985 /// deduction. 8986 class SFINAETrap { 8987 Sema &SemaRef; 8988 unsigned PrevSFINAEErrors; 8989 bool PrevInNonInstantiationSFINAEContext; 8990 bool PrevAccessCheckingSFINAE; 8991 bool PrevLastDiagnosticIgnored; 8992 8993 public: 8994 explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false) SemaRef(SemaRef)8995 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors), 8996 PrevInNonInstantiationSFINAEContext( 8997 SemaRef.InNonInstantiationSFINAEContext), 8998 PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE), 8999 PrevLastDiagnosticIgnored( 9000 SemaRef.getDiagnostics().isLastDiagnosticIgnored()) 9001 { 9002 if (!SemaRef.isSFINAEContext()) 9003 SemaRef.InNonInstantiationSFINAEContext = true; 9004 SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE; 9005 } 9006 ~SFINAETrap()9007 ~SFINAETrap() { 9008 SemaRef.NumSFINAEErrors = PrevSFINAEErrors; 9009 SemaRef.InNonInstantiationSFINAEContext 9010 = PrevInNonInstantiationSFINAEContext; 9011 SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE; 9012 SemaRef.getDiagnostics().setLastDiagnosticIgnored( 9013 PrevLastDiagnosticIgnored); 9014 } 9015 9016 /// Determine whether any SFINAE errors have been trapped. hasErrorOccurred()9017 bool hasErrorOccurred() const { 9018 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors; 9019 } 9020 }; 9021 9022 /// RAII class used to indicate that we are performing provisional 9023 /// semantic analysis to determine the validity of a construct, so 9024 /// typo-correction and diagnostics in the immediate context (not within 9025 /// implicitly-instantiated templates) should be suppressed. 9026 class TentativeAnalysisScope { 9027 Sema &SemaRef; 9028 // FIXME: Using a SFINAETrap for this is a hack. 9029 SFINAETrap Trap; 9030 bool PrevDisableTypoCorrection; 9031 public: TentativeAnalysisScope(Sema & SemaRef)9032 explicit TentativeAnalysisScope(Sema &SemaRef) 9033 : SemaRef(SemaRef), Trap(SemaRef, true), 9034 PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) { 9035 SemaRef.DisableTypoCorrection = true; 9036 } ~TentativeAnalysisScope()9037 ~TentativeAnalysisScope() { 9038 SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection; 9039 } 9040 }; 9041 9042 /// The current instantiation scope used to store local 9043 /// variables. 9044 LocalInstantiationScope *CurrentInstantiationScope; 9045 9046 /// Tracks whether we are in a context where typo correction is 9047 /// disabled. 9048 bool DisableTypoCorrection; 9049 9050 /// The number of typos corrected by CorrectTypo. 9051 unsigned TyposCorrected; 9052 9053 typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet; 9054 typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations; 9055 9056 /// A cache containing identifiers for which typo correction failed and 9057 /// their locations, so that repeated attempts to correct an identifier in a 9058 /// given location are ignored if typo correction already failed for it. 9059 IdentifierSourceLocations TypoCorrectionFailures; 9060 9061 /// Worker object for performing CFG-based warnings. 9062 sema::AnalysisBasedWarnings AnalysisWarnings; 9063 threadSafety::BeforeSet *ThreadSafetyDeclCache; 9064 9065 /// An entity for which implicit template instantiation is required. 9066 /// 9067 /// The source location associated with the declaration is the first place in 9068 /// the source code where the declaration was "used". It is not necessarily 9069 /// the point of instantiation (which will be either before or after the 9070 /// namespace-scope declaration that triggered this implicit instantiation), 9071 /// However, it is the location that diagnostics should generally refer to, 9072 /// because users will need to know what code triggered the instantiation. 9073 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation; 9074 9075 /// The queue of implicit template instantiations that are required 9076 /// but have not yet been performed. 9077 std::deque<PendingImplicitInstantiation> PendingInstantiations; 9078 9079 /// Queue of implicit template instantiations that cannot be performed 9080 /// eagerly. 9081 SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations; 9082 9083 class GlobalEagerInstantiationScope { 9084 public: GlobalEagerInstantiationScope(Sema & S,bool Enabled)9085 GlobalEagerInstantiationScope(Sema &S, bool Enabled) 9086 : S(S), Enabled(Enabled) { 9087 if (!Enabled) return; 9088 9089 SavedPendingInstantiations.swap(S.PendingInstantiations); 9090 SavedVTableUses.swap(S.VTableUses); 9091 } 9092 perform()9093 void perform() { 9094 if (Enabled) { 9095 S.DefineUsedVTables(); 9096 S.PerformPendingInstantiations(); 9097 } 9098 } 9099 ~GlobalEagerInstantiationScope()9100 ~GlobalEagerInstantiationScope() { 9101 if (!Enabled) return; 9102 9103 // Restore the set of pending vtables. 9104 assert(S.VTableUses.empty() && 9105 "VTableUses should be empty before it is discarded."); 9106 S.VTableUses.swap(SavedVTableUses); 9107 9108 // Restore the set of pending implicit instantiations. 9109 if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) { 9110 assert(S.PendingInstantiations.empty() && 9111 "PendingInstantiations should be empty before it is discarded."); 9112 S.PendingInstantiations.swap(SavedPendingInstantiations); 9113 } else { 9114 // Template instantiations in the PCH may be delayed until the TU. 9115 S.PendingInstantiations.swap(SavedPendingInstantiations); 9116 S.PendingInstantiations.insert(S.PendingInstantiations.end(), 9117 SavedPendingInstantiations.begin(), 9118 SavedPendingInstantiations.end()); 9119 } 9120 } 9121 9122 private: 9123 Sema &S; 9124 SmallVector<VTableUse, 16> SavedVTableUses; 9125 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations; 9126 bool Enabled; 9127 }; 9128 9129 /// The queue of implicit template instantiations that are required 9130 /// and must be performed within the current local scope. 9131 /// 9132 /// This queue is only used for member functions of local classes in 9133 /// templates, which must be instantiated in the same scope as their 9134 /// enclosing function, so that they can reference function-local 9135 /// types, static variables, enumerators, etc. 9136 std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations; 9137 9138 class LocalEagerInstantiationScope { 9139 public: LocalEagerInstantiationScope(Sema & S)9140 LocalEagerInstantiationScope(Sema &S) : S(S) { 9141 SavedPendingLocalImplicitInstantiations.swap( 9142 S.PendingLocalImplicitInstantiations); 9143 } 9144 perform()9145 void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); } 9146 ~LocalEagerInstantiationScope()9147 ~LocalEagerInstantiationScope() { 9148 assert(S.PendingLocalImplicitInstantiations.empty() && 9149 "there shouldn't be any pending local implicit instantiations"); 9150 SavedPendingLocalImplicitInstantiations.swap( 9151 S.PendingLocalImplicitInstantiations); 9152 } 9153 9154 private: 9155 Sema &S; 9156 std::deque<PendingImplicitInstantiation> 9157 SavedPendingLocalImplicitInstantiations; 9158 }; 9159 9160 /// A helper class for building up ExtParameterInfos. 9161 class ExtParameterInfoBuilder { 9162 SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos; 9163 bool HasInteresting = false; 9164 9165 public: 9166 /// Set the ExtParameterInfo for the parameter at the given index, 9167 /// set(unsigned index,FunctionProtoType::ExtParameterInfo info)9168 void set(unsigned index, FunctionProtoType::ExtParameterInfo info) { 9169 assert(Infos.size() <= index); 9170 Infos.resize(index); 9171 Infos.push_back(info); 9172 9173 if (!HasInteresting) 9174 HasInteresting = (info != FunctionProtoType::ExtParameterInfo()); 9175 } 9176 9177 /// Return a pointer (suitable for setting in an ExtProtoInfo) to the 9178 /// ExtParameterInfo array we've built up. 9179 const FunctionProtoType::ExtParameterInfo * getPointerOrNull(unsigned numParams)9180 getPointerOrNull(unsigned numParams) { 9181 if (!HasInteresting) return nullptr; 9182 Infos.resize(numParams); 9183 return Infos.data(); 9184 } 9185 }; 9186 9187 void PerformPendingInstantiations(bool LocalOnly = false); 9188 9189 TypeSourceInfo *SubstType(TypeSourceInfo *T, 9190 const MultiLevelTemplateArgumentList &TemplateArgs, 9191 SourceLocation Loc, DeclarationName Entity, 9192 bool AllowDeducedTST = false); 9193 9194 QualType SubstType(QualType T, 9195 const MultiLevelTemplateArgumentList &TemplateArgs, 9196 SourceLocation Loc, DeclarationName Entity); 9197 9198 TypeSourceInfo *SubstType(TypeLoc TL, 9199 const MultiLevelTemplateArgumentList &TemplateArgs, 9200 SourceLocation Loc, DeclarationName Entity); 9201 9202 TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T, 9203 const MultiLevelTemplateArgumentList &TemplateArgs, 9204 SourceLocation Loc, 9205 DeclarationName Entity, 9206 CXXRecordDecl *ThisContext, 9207 Qualifiers ThisTypeQuals); 9208 void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, 9209 const MultiLevelTemplateArgumentList &Args); 9210 bool SubstExceptionSpec(SourceLocation Loc, 9211 FunctionProtoType::ExceptionSpecInfo &ESI, 9212 SmallVectorImpl<QualType> &ExceptionStorage, 9213 const MultiLevelTemplateArgumentList &Args); 9214 ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D, 9215 const MultiLevelTemplateArgumentList &TemplateArgs, 9216 int indexAdjustment, 9217 Optional<unsigned> NumExpansions, 9218 bool ExpectParameterPack); 9219 bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, 9220 const FunctionProtoType::ExtParameterInfo *ExtParamInfos, 9221 const MultiLevelTemplateArgumentList &TemplateArgs, 9222 SmallVectorImpl<QualType> &ParamTypes, 9223 SmallVectorImpl<ParmVarDecl *> *OutParams, 9224 ExtParameterInfoBuilder &ParamInfos); 9225 ExprResult SubstExpr(Expr *E, 9226 const MultiLevelTemplateArgumentList &TemplateArgs); 9227 9228 /// Substitute the given template arguments into a list of 9229 /// expressions, expanding pack expansions if required. 9230 /// 9231 /// \param Exprs The list of expressions to substitute into. 9232 /// 9233 /// \param IsCall Whether this is some form of call, in which case 9234 /// default arguments will be dropped. 9235 /// 9236 /// \param TemplateArgs The set of template arguments to substitute. 9237 /// 9238 /// \param Outputs Will receive all of the substituted arguments. 9239 /// 9240 /// \returns true if an error occurred, false otherwise. 9241 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall, 9242 const MultiLevelTemplateArgumentList &TemplateArgs, 9243 SmallVectorImpl<Expr *> &Outputs); 9244 9245 StmtResult SubstStmt(Stmt *S, 9246 const MultiLevelTemplateArgumentList &TemplateArgs); 9247 9248 TemplateParameterList * 9249 SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, 9250 const MultiLevelTemplateArgumentList &TemplateArgs); 9251 9252 bool 9253 SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args, 9254 const MultiLevelTemplateArgumentList &TemplateArgs, 9255 TemplateArgumentListInfo &Outputs); 9256 9257 9258 Decl *SubstDecl(Decl *D, DeclContext *Owner, 9259 const MultiLevelTemplateArgumentList &TemplateArgs); 9260 9261 /// Substitute the name and return type of a defaulted 'operator<=>' to form 9262 /// an implicit 'operator=='. 9263 FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, 9264 FunctionDecl *Spaceship); 9265 9266 ExprResult SubstInitializer(Expr *E, 9267 const MultiLevelTemplateArgumentList &TemplateArgs, 9268 bool CXXDirectInit); 9269 9270 bool 9271 SubstBaseSpecifiers(CXXRecordDecl *Instantiation, 9272 CXXRecordDecl *Pattern, 9273 const MultiLevelTemplateArgumentList &TemplateArgs); 9274 9275 bool 9276 InstantiateClass(SourceLocation PointOfInstantiation, 9277 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, 9278 const MultiLevelTemplateArgumentList &TemplateArgs, 9279 TemplateSpecializationKind TSK, 9280 bool Complain = true); 9281 9282 bool InstantiateEnum(SourceLocation PointOfInstantiation, 9283 EnumDecl *Instantiation, EnumDecl *Pattern, 9284 const MultiLevelTemplateArgumentList &TemplateArgs, 9285 TemplateSpecializationKind TSK); 9286 9287 bool InstantiateInClassInitializer( 9288 SourceLocation PointOfInstantiation, FieldDecl *Instantiation, 9289 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs); 9290 9291 struct LateInstantiatedAttribute { 9292 const Attr *TmplAttr; 9293 LocalInstantiationScope *Scope; 9294 Decl *NewDecl; 9295 LateInstantiatedAttributeLateInstantiatedAttribute9296 LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S, 9297 Decl *D) 9298 : TmplAttr(A), Scope(S), NewDecl(D) 9299 { } 9300 }; 9301 typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec; 9302 9303 void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, 9304 const Decl *Pattern, Decl *Inst, 9305 LateInstantiatedAttrVec *LateAttrs = nullptr, 9306 LocalInstantiationScope *OuterMostScope = nullptr); 9307 9308 void 9309 InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, 9310 const Decl *Pattern, Decl *Inst, 9311 LateInstantiatedAttrVec *LateAttrs = nullptr, 9312 LocalInstantiationScope *OuterMostScope = nullptr); 9313 9314 void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor); 9315 9316 bool usesPartialOrExplicitSpecialization( 9317 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec); 9318 9319 bool 9320 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, 9321 ClassTemplateSpecializationDecl *ClassTemplateSpec, 9322 TemplateSpecializationKind TSK, 9323 bool Complain = true); 9324 9325 void InstantiateClassMembers(SourceLocation PointOfInstantiation, 9326 CXXRecordDecl *Instantiation, 9327 const MultiLevelTemplateArgumentList &TemplateArgs, 9328 TemplateSpecializationKind TSK); 9329 9330 void InstantiateClassTemplateSpecializationMembers( 9331 SourceLocation PointOfInstantiation, 9332 ClassTemplateSpecializationDecl *ClassTemplateSpec, 9333 TemplateSpecializationKind TSK); 9334 9335 NestedNameSpecifierLoc 9336 SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 9337 const MultiLevelTemplateArgumentList &TemplateArgs); 9338 9339 DeclarationNameInfo 9340 SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 9341 const MultiLevelTemplateArgumentList &TemplateArgs); 9342 TemplateName 9343 SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, 9344 SourceLocation Loc, 9345 const MultiLevelTemplateArgumentList &TemplateArgs); 9346 bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, 9347 TemplateArgumentListInfo &Result, 9348 const MultiLevelTemplateArgumentList &TemplateArgs); 9349 9350 bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, 9351 ParmVarDecl *Param); 9352 void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, 9353 FunctionDecl *Function); 9354 bool CheckInstantiatedFunctionTemplateConstraints( 9355 SourceLocation PointOfInstantiation, FunctionDecl *Decl, 9356 ArrayRef<TemplateArgument> TemplateArgs, 9357 ConstraintSatisfaction &Satisfaction); 9358 FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, 9359 const TemplateArgumentList *Args, 9360 SourceLocation Loc); 9361 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, 9362 FunctionDecl *Function, 9363 bool Recursive = false, 9364 bool DefinitionRequired = false, 9365 bool AtEndOfTU = false); 9366 VarTemplateSpecializationDecl *BuildVarTemplateInstantiation( 9367 VarTemplateDecl *VarTemplate, VarDecl *FromVar, 9368 const TemplateArgumentList &TemplateArgList, 9369 const TemplateArgumentListInfo &TemplateArgsInfo, 9370 SmallVectorImpl<TemplateArgument> &Converted, 9371 SourceLocation PointOfInstantiation, 9372 LateInstantiatedAttrVec *LateAttrs = nullptr, 9373 LocalInstantiationScope *StartingScope = nullptr); 9374 VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl( 9375 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, 9376 const MultiLevelTemplateArgumentList &TemplateArgs); 9377 void 9378 BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, 9379 const MultiLevelTemplateArgumentList &TemplateArgs, 9380 LateInstantiatedAttrVec *LateAttrs, 9381 DeclContext *Owner, 9382 LocalInstantiationScope *StartingScope, 9383 bool InstantiatingVarTemplate = false, 9384 VarTemplateSpecializationDecl *PrevVTSD = nullptr); 9385 9386 void InstantiateVariableInitializer( 9387 VarDecl *Var, VarDecl *OldVar, 9388 const MultiLevelTemplateArgumentList &TemplateArgs); 9389 void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, 9390 VarDecl *Var, bool Recursive = false, 9391 bool DefinitionRequired = false, 9392 bool AtEndOfTU = false); 9393 9394 void InstantiateMemInitializers(CXXConstructorDecl *New, 9395 const CXXConstructorDecl *Tmpl, 9396 const MultiLevelTemplateArgumentList &TemplateArgs); 9397 9398 NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, 9399 const MultiLevelTemplateArgumentList &TemplateArgs, 9400 bool FindingInstantiatedContext = false); 9401 DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC, 9402 const MultiLevelTemplateArgumentList &TemplateArgs); 9403 9404 // Objective-C declarations. 9405 enum ObjCContainerKind { 9406 OCK_None = -1, 9407 OCK_Interface = 0, 9408 OCK_Protocol, 9409 OCK_Category, 9410 OCK_ClassExtension, 9411 OCK_Implementation, 9412 OCK_CategoryImplementation 9413 }; 9414 ObjCContainerKind getObjCContainerKind() const; 9415 9416 DeclResult actOnObjCTypeParam(Scope *S, 9417 ObjCTypeParamVariance variance, 9418 SourceLocation varianceLoc, 9419 unsigned index, 9420 IdentifierInfo *paramName, 9421 SourceLocation paramLoc, 9422 SourceLocation colonLoc, 9423 ParsedType typeBound); 9424 9425 ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc, 9426 ArrayRef<Decl *> typeParams, 9427 SourceLocation rAngleLoc); 9428 void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList); 9429 9430 Decl *ActOnStartClassInterface( 9431 Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, 9432 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, 9433 IdentifierInfo *SuperName, SourceLocation SuperLoc, 9434 ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange, 9435 Decl *const *ProtoRefs, unsigned NumProtoRefs, 9436 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, 9437 const ParsedAttributesView &AttrList); 9438 9439 void ActOnSuperClassOfClassInterface(Scope *S, 9440 SourceLocation AtInterfaceLoc, 9441 ObjCInterfaceDecl *IDecl, 9442 IdentifierInfo *ClassName, 9443 SourceLocation ClassLoc, 9444 IdentifierInfo *SuperName, 9445 SourceLocation SuperLoc, 9446 ArrayRef<ParsedType> SuperTypeArgs, 9447 SourceRange SuperTypeArgsRange); 9448 9449 void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs, 9450 SmallVectorImpl<SourceLocation> &ProtocolLocs, 9451 IdentifierInfo *SuperName, 9452 SourceLocation SuperLoc); 9453 9454 Decl *ActOnCompatibilityAlias( 9455 SourceLocation AtCompatibilityAliasLoc, 9456 IdentifierInfo *AliasName, SourceLocation AliasLocation, 9457 IdentifierInfo *ClassName, SourceLocation ClassLocation); 9458 9459 bool CheckForwardProtocolDeclarationForCircularDependency( 9460 IdentifierInfo *PName, 9461 SourceLocation &PLoc, SourceLocation PrevLoc, 9462 const ObjCList<ObjCProtocolDecl> &PList); 9463 9464 Decl *ActOnStartProtocolInterface( 9465 SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName, 9466 SourceLocation ProtocolLoc, Decl *const *ProtoRefNames, 9467 unsigned NumProtoRefs, const SourceLocation *ProtoLocs, 9468 SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList); 9469 9470 Decl *ActOnStartCategoryInterface( 9471 SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, 9472 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, 9473 IdentifierInfo *CategoryName, SourceLocation CategoryLoc, 9474 Decl *const *ProtoRefs, unsigned NumProtoRefs, 9475 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, 9476 const ParsedAttributesView &AttrList); 9477 9478 Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc, 9479 IdentifierInfo *ClassName, 9480 SourceLocation ClassLoc, 9481 IdentifierInfo *SuperClassname, 9482 SourceLocation SuperClassLoc, 9483 const ParsedAttributesView &AttrList); 9484 9485 Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, 9486 IdentifierInfo *ClassName, 9487 SourceLocation ClassLoc, 9488 IdentifierInfo *CatName, 9489 SourceLocation CatLoc, 9490 const ParsedAttributesView &AttrList); 9491 9492 DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl, 9493 ArrayRef<Decl *> Decls); 9494 9495 DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc, 9496 IdentifierInfo **IdentList, 9497 SourceLocation *IdentLocs, 9498 ArrayRef<ObjCTypeParamList *> TypeParamLists, 9499 unsigned NumElts); 9500 9501 DeclGroupPtrTy 9502 ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc, 9503 ArrayRef<IdentifierLocPair> IdentList, 9504 const ParsedAttributesView &attrList); 9505 9506 void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer, 9507 ArrayRef<IdentifierLocPair> ProtocolId, 9508 SmallVectorImpl<Decl *> &Protocols); 9509 9510 void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId, 9511 SourceLocation ProtocolLoc, 9512 IdentifierInfo *TypeArgId, 9513 SourceLocation TypeArgLoc, 9514 bool SelectProtocolFirst = false); 9515 9516 /// Given a list of identifiers (and their locations), resolve the 9517 /// names to either Objective-C protocol qualifiers or type 9518 /// arguments, as appropriate. 9519 void actOnObjCTypeArgsOrProtocolQualifiers( 9520 Scope *S, 9521 ParsedType baseType, 9522 SourceLocation lAngleLoc, 9523 ArrayRef<IdentifierInfo *> identifiers, 9524 ArrayRef<SourceLocation> identifierLocs, 9525 SourceLocation rAngleLoc, 9526 SourceLocation &typeArgsLAngleLoc, 9527 SmallVectorImpl<ParsedType> &typeArgs, 9528 SourceLocation &typeArgsRAngleLoc, 9529 SourceLocation &protocolLAngleLoc, 9530 SmallVectorImpl<Decl *> &protocols, 9531 SourceLocation &protocolRAngleLoc, 9532 bool warnOnIncompleteProtocols); 9533 9534 /// Build a an Objective-C protocol-qualified 'id' type where no 9535 /// base type was specified. 9536 TypeResult actOnObjCProtocolQualifierType( 9537 SourceLocation lAngleLoc, 9538 ArrayRef<Decl *> protocols, 9539 ArrayRef<SourceLocation> protocolLocs, 9540 SourceLocation rAngleLoc); 9541 9542 /// Build a specialized and/or protocol-qualified Objective-C type. 9543 TypeResult actOnObjCTypeArgsAndProtocolQualifiers( 9544 Scope *S, 9545 SourceLocation Loc, 9546 ParsedType BaseType, 9547 SourceLocation TypeArgsLAngleLoc, 9548 ArrayRef<ParsedType> TypeArgs, 9549 SourceLocation TypeArgsRAngleLoc, 9550 SourceLocation ProtocolLAngleLoc, 9551 ArrayRef<Decl *> Protocols, 9552 ArrayRef<SourceLocation> ProtocolLocs, 9553 SourceLocation ProtocolRAngleLoc); 9554 9555 /// Build an Objective-C type parameter type. 9556 QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, 9557 SourceLocation ProtocolLAngleLoc, 9558 ArrayRef<ObjCProtocolDecl *> Protocols, 9559 ArrayRef<SourceLocation> ProtocolLocs, 9560 SourceLocation ProtocolRAngleLoc, 9561 bool FailOnError = false); 9562 9563 /// Build an Objective-C object pointer type. 9564 QualType BuildObjCObjectType(QualType BaseType, 9565 SourceLocation Loc, 9566 SourceLocation TypeArgsLAngleLoc, 9567 ArrayRef<TypeSourceInfo *> TypeArgs, 9568 SourceLocation TypeArgsRAngleLoc, 9569 SourceLocation ProtocolLAngleLoc, 9570 ArrayRef<ObjCProtocolDecl *> Protocols, 9571 ArrayRef<SourceLocation> ProtocolLocs, 9572 SourceLocation ProtocolRAngleLoc, 9573 bool FailOnError = false); 9574 9575 /// Ensure attributes are consistent with type. 9576 /// \param [in, out] Attributes The attributes to check; they will 9577 /// be modified to be consistent with \p PropertyTy. 9578 void CheckObjCPropertyAttributes(Decl *PropertyPtrTy, 9579 SourceLocation Loc, 9580 unsigned &Attributes, 9581 bool propertyInPrimaryClass); 9582 9583 /// Process the specified property declaration and create decls for the 9584 /// setters and getters as needed. 9585 /// \param property The property declaration being processed 9586 void ProcessPropertyDecl(ObjCPropertyDecl *property); 9587 9588 9589 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property, 9590 ObjCPropertyDecl *SuperProperty, 9591 const IdentifierInfo *Name, 9592 bool OverridingProtocolProperty); 9593 9594 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, 9595 ObjCInterfaceDecl *ID); 9596 9597 Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd, 9598 ArrayRef<Decl *> allMethods = None, 9599 ArrayRef<DeclGroupPtrTy> allTUVars = None); 9600 9601 Decl *ActOnProperty(Scope *S, SourceLocation AtLoc, 9602 SourceLocation LParenLoc, 9603 FieldDeclarator &FD, ObjCDeclSpec &ODS, 9604 Selector GetterSel, Selector SetterSel, 9605 tok::ObjCKeywordKind MethodImplKind, 9606 DeclContext *lexicalDC = nullptr); 9607 9608 Decl *ActOnPropertyImplDecl(Scope *S, 9609 SourceLocation AtLoc, 9610 SourceLocation PropertyLoc, 9611 bool ImplKind, 9612 IdentifierInfo *PropertyId, 9613 IdentifierInfo *PropertyIvar, 9614 SourceLocation PropertyIvarLoc, 9615 ObjCPropertyQueryKind QueryKind); 9616 9617 enum ObjCSpecialMethodKind { 9618 OSMK_None, 9619 OSMK_Alloc, 9620 OSMK_New, 9621 OSMK_Copy, 9622 OSMK_RetainingInit, 9623 OSMK_NonRetainingInit 9624 }; 9625 9626 struct ObjCArgInfo { 9627 IdentifierInfo *Name; 9628 SourceLocation NameLoc; 9629 // The Type is null if no type was specified, and the DeclSpec is invalid 9630 // in this case. 9631 ParsedType Type; 9632 ObjCDeclSpec DeclSpec; 9633 9634 /// ArgAttrs - Attribute list for this argument. 9635 ParsedAttributesView ArgAttrs; 9636 }; 9637 9638 Decl *ActOnMethodDeclaration( 9639 Scope *S, 9640 SourceLocation BeginLoc, // location of the + or -. 9641 SourceLocation EndLoc, // location of the ; or {. 9642 tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType, 9643 ArrayRef<SourceLocation> SelectorLocs, Selector Sel, 9644 // optional arguments. The number of types/arguments is obtained 9645 // from the Sel.getNumArgs(). 9646 ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo, 9647 unsigned CNumArgs, // c-style args 9648 const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind, 9649 bool isVariadic, bool MethodDefinition); 9650 9651 ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel, 9652 const ObjCObjectPointerType *OPT, 9653 bool IsInstance); 9654 ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty, 9655 bool IsInstance); 9656 9657 bool CheckARCMethodDecl(ObjCMethodDecl *method); 9658 bool inferObjCARCLifetime(ValueDecl *decl); 9659 9660 void deduceOpenCLAddressSpace(ValueDecl *decl); 9661 9662 ExprResult 9663 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, 9664 Expr *BaseExpr, 9665 SourceLocation OpLoc, 9666 DeclarationName MemberName, 9667 SourceLocation MemberLoc, 9668 SourceLocation SuperLoc, QualType SuperType, 9669 bool Super); 9670 9671 ExprResult 9672 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, 9673 IdentifierInfo &propertyName, 9674 SourceLocation receiverNameLoc, 9675 SourceLocation propertyNameLoc); 9676 9677 ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc); 9678 9679 /// Describes the kind of message expression indicated by a message 9680 /// send that starts with an identifier. 9681 enum ObjCMessageKind { 9682 /// The message is sent to 'super'. 9683 ObjCSuperMessage, 9684 /// The message is an instance message. 9685 ObjCInstanceMessage, 9686 /// The message is a class message, and the identifier is a type 9687 /// name. 9688 ObjCClassMessage 9689 }; 9690 9691 ObjCMessageKind getObjCMessageKind(Scope *S, 9692 IdentifierInfo *Name, 9693 SourceLocation NameLoc, 9694 bool IsSuper, 9695 bool HasTrailingDot, 9696 ParsedType &ReceiverType); 9697 9698 ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc, 9699 Selector Sel, 9700 SourceLocation LBracLoc, 9701 ArrayRef<SourceLocation> SelectorLocs, 9702 SourceLocation RBracLoc, 9703 MultiExprArg Args); 9704 9705 ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo, 9706 QualType ReceiverType, 9707 SourceLocation SuperLoc, 9708 Selector Sel, 9709 ObjCMethodDecl *Method, 9710 SourceLocation LBracLoc, 9711 ArrayRef<SourceLocation> SelectorLocs, 9712 SourceLocation RBracLoc, 9713 MultiExprArg Args, 9714 bool isImplicit = false); 9715 9716 ExprResult BuildClassMessageImplicit(QualType ReceiverType, 9717 bool isSuperReceiver, 9718 SourceLocation Loc, 9719 Selector Sel, 9720 ObjCMethodDecl *Method, 9721 MultiExprArg Args); 9722 9723 ExprResult ActOnClassMessage(Scope *S, 9724 ParsedType Receiver, 9725 Selector Sel, 9726 SourceLocation LBracLoc, 9727 ArrayRef<SourceLocation> SelectorLocs, 9728 SourceLocation RBracLoc, 9729 MultiExprArg Args); 9730 9731 ExprResult BuildInstanceMessage(Expr *Receiver, 9732 QualType ReceiverType, 9733 SourceLocation SuperLoc, 9734 Selector Sel, 9735 ObjCMethodDecl *Method, 9736 SourceLocation LBracLoc, 9737 ArrayRef<SourceLocation> SelectorLocs, 9738 SourceLocation RBracLoc, 9739 MultiExprArg Args, 9740 bool isImplicit = false); 9741 9742 ExprResult BuildInstanceMessageImplicit(Expr *Receiver, 9743 QualType ReceiverType, 9744 SourceLocation Loc, 9745 Selector Sel, 9746 ObjCMethodDecl *Method, 9747 MultiExprArg Args); 9748 9749 ExprResult ActOnInstanceMessage(Scope *S, 9750 Expr *Receiver, 9751 Selector Sel, 9752 SourceLocation LBracLoc, 9753 ArrayRef<SourceLocation> SelectorLocs, 9754 SourceLocation RBracLoc, 9755 MultiExprArg Args); 9756 9757 ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc, 9758 ObjCBridgeCastKind Kind, 9759 SourceLocation BridgeKeywordLoc, 9760 TypeSourceInfo *TSInfo, 9761 Expr *SubExpr); 9762 9763 ExprResult ActOnObjCBridgedCast(Scope *S, 9764 SourceLocation LParenLoc, 9765 ObjCBridgeCastKind Kind, 9766 SourceLocation BridgeKeywordLoc, 9767 ParsedType Type, 9768 SourceLocation RParenLoc, 9769 Expr *SubExpr); 9770 9771 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr); 9772 9773 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr); 9774 9775 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr, 9776 CastKind &Kind); 9777 9778 bool checkObjCBridgeRelatedComponents(SourceLocation Loc, 9779 QualType DestType, QualType SrcType, 9780 ObjCInterfaceDecl *&RelatedClass, 9781 ObjCMethodDecl *&ClassMethod, 9782 ObjCMethodDecl *&InstanceMethod, 9783 TypedefNameDecl *&TDNDecl, 9784 bool CfToNs, bool Diagnose = true); 9785 9786 bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, 9787 QualType DestType, QualType SrcType, 9788 Expr *&SrcExpr, bool Diagnose = true); 9789 9790 bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, 9791 bool Diagnose = true); 9792 9793 bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall); 9794 9795 /// Check whether the given new method is a valid override of the 9796 /// given overridden method, and set any properties that should be inherited. 9797 void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, 9798 const ObjCMethodDecl *Overridden); 9799 9800 /// Describes the compatibility of a result type with its method. 9801 enum ResultTypeCompatibilityKind { 9802 RTC_Compatible, 9803 RTC_Incompatible, 9804 RTC_Unknown 9805 }; 9806 9807 void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method, 9808 ObjCMethodDecl *overridden); 9809 9810 void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod, 9811 ObjCInterfaceDecl *CurrentClass, 9812 ResultTypeCompatibilityKind RTC); 9813 9814 enum PragmaOptionsAlignKind { 9815 POAK_Native, // #pragma options align=native 9816 POAK_Natural, // #pragma options align=natural 9817 POAK_Packed, // #pragma options align=packed 9818 POAK_Power, // #pragma options align=power 9819 POAK_Mac68k, // #pragma options align=mac68k 9820 POAK_Reset // #pragma options align=reset 9821 }; 9822 9823 /// ActOnPragmaClangSection - Called on well formed \#pragma clang section 9824 void ActOnPragmaClangSection(SourceLocation PragmaLoc, 9825 PragmaClangSectionAction Action, 9826 PragmaClangSectionKind SecKind, StringRef SecName); 9827 9828 /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align. 9829 void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, 9830 SourceLocation PragmaLoc); 9831 9832 /// ActOnPragmaPack - Called on well formed \#pragma pack(...). 9833 void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, 9834 StringRef SlotLabel, Expr *Alignment); 9835 9836 enum class PragmaAlignPackDiagnoseKind { 9837 NonDefaultStateAtInclude, 9838 ChangedStateAtExit 9839 }; 9840 9841 void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, 9842 SourceLocation IncludeLoc); 9843 void DiagnoseUnterminatedPragmaAlignPack(); 9844 9845 /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off]. 9846 void ActOnPragmaMSStruct(PragmaMSStructKind Kind); 9847 9848 /// ActOnPragmaMSComment - Called on well formed 9849 /// \#pragma comment(kind, "arg"). 9850 void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind, 9851 StringRef Arg); 9852 9853 /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma 9854 /// pointers_to_members(representation method[, general purpose 9855 /// representation]). 9856 void ActOnPragmaMSPointersToMembers( 9857 LangOptions::PragmaMSPointersToMembersKind Kind, 9858 SourceLocation PragmaLoc); 9859 9860 /// Called on well formed \#pragma vtordisp(). 9861 void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, 9862 SourceLocation PragmaLoc, 9863 MSVtorDispMode Value); 9864 9865 enum PragmaSectionKind { 9866 PSK_DataSeg, 9867 PSK_BSSSeg, 9868 PSK_ConstSeg, 9869 PSK_CodeSeg, 9870 }; 9871 9872 bool UnifySection(StringRef SectionName, int SectionFlags, 9873 NamedDecl *TheDecl); 9874 bool UnifySection(StringRef SectionName, 9875 int SectionFlags, 9876 SourceLocation PragmaSectionLocation); 9877 9878 /// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg. 9879 void ActOnPragmaMSSeg(SourceLocation PragmaLocation, 9880 PragmaMsStackAction Action, 9881 llvm::StringRef StackSlotLabel, 9882 StringLiteral *SegmentName, 9883 llvm::StringRef PragmaName); 9884 9885 /// Called on well formed \#pragma section(). 9886 void ActOnPragmaMSSection(SourceLocation PragmaLocation, 9887 int SectionFlags, StringLiteral *SegmentName); 9888 9889 /// Called on well-formed \#pragma init_seg(). 9890 void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, 9891 StringLiteral *SegmentName); 9892 9893 /// Called on #pragma clang __debug dump II 9894 void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II); 9895 9896 /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch 9897 void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, 9898 StringRef Value); 9899 9900 /// Are precise floating point semantics currently enabled? isPreciseFPEnabled()9901 bool isPreciseFPEnabled() { 9902 return !CurFPFeatures.getAllowFPReassociate() && 9903 !CurFPFeatures.getNoSignedZero() && 9904 !CurFPFeatures.getAllowReciprocal() && 9905 !CurFPFeatures.getAllowApproxFunc(); 9906 } 9907 9908 /// ActOnPragmaFloatControl - Call on well-formed \#pragma float_control 9909 void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, 9910 PragmaFloatControlKind Value); 9911 9912 /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'. 9913 void ActOnPragmaUnused(const Token &Identifier, 9914 Scope *curScope, 9915 SourceLocation PragmaLoc); 9916 9917 /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... . 9918 void ActOnPragmaVisibility(const IdentifierInfo* VisType, 9919 SourceLocation PragmaLoc); 9920 9921 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II, 9922 SourceLocation Loc); 9923 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W); 9924 9925 /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident. 9926 void ActOnPragmaWeakID(IdentifierInfo* WeakName, 9927 SourceLocation PragmaLoc, 9928 SourceLocation WeakNameLoc); 9929 9930 /// ActOnPragmaRedefineExtname - Called on well formed 9931 /// \#pragma redefine_extname oldname newname. 9932 void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName, 9933 IdentifierInfo* AliasName, 9934 SourceLocation PragmaLoc, 9935 SourceLocation WeakNameLoc, 9936 SourceLocation AliasNameLoc); 9937 9938 /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident. 9939 void ActOnPragmaWeakAlias(IdentifierInfo* WeakName, 9940 IdentifierInfo* AliasName, 9941 SourceLocation PragmaLoc, 9942 SourceLocation WeakNameLoc, 9943 SourceLocation AliasNameLoc); 9944 9945 /// ActOnPragmaFPContract - Called on well formed 9946 /// \#pragma {STDC,OPENCL} FP_CONTRACT and 9947 /// \#pragma clang fp contract 9948 void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC); 9949 9950 /// Called on well formed 9951 /// \#pragma clang fp reassociate 9952 void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled); 9953 9954 /// ActOnPragmaFenvAccess - Called on well formed 9955 /// \#pragma STDC FENV_ACCESS 9956 void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled); 9957 9958 /// Called on well formed '\#pragma clang fp' that has option 'exceptions'. 9959 void ActOnPragmaFPExceptions(SourceLocation Loc, 9960 LangOptions::FPExceptionModeKind); 9961 9962 /// Called to set constant rounding mode for floating point operations. 9963 void setRoundingMode(SourceLocation Loc, llvm::RoundingMode); 9964 9965 /// Called to set exception behavior for floating point operations. 9966 void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind); 9967 9968 /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to 9969 /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'. 9970 void AddAlignmentAttributesForRecord(RecordDecl *RD); 9971 9972 /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record. 9973 void AddMsStructLayoutForRecord(RecordDecl *RD); 9974 9975 /// PushNamespaceVisibilityAttr - Note that we've entered a 9976 /// namespace with a visibility attribute. 9977 void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, 9978 SourceLocation Loc); 9979 9980 /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used, 9981 /// add an appropriate visibility attribute. 9982 void AddPushedVisibilityAttribute(Decl *RD); 9983 9984 /// PopPragmaVisibility - Pop the top element of the visibility stack; used 9985 /// for '\#pragma GCC visibility' and visibility attributes on namespaces. 9986 void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc); 9987 9988 /// FreeVisContext - Deallocate and null out VisContext. 9989 void FreeVisContext(); 9990 9991 /// AddCFAuditedAttribute - Check whether we're currently within 9992 /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding 9993 /// the appropriate attribute. 9994 void AddCFAuditedAttribute(Decl *D); 9995 9996 void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, 9997 SourceLocation PragmaLoc, 9998 attr::ParsedSubjectMatchRuleSet Rules); 9999 void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc, 10000 const IdentifierInfo *Namespace); 10001 10002 /// Called on well-formed '\#pragma clang attribute pop'. 10003 void ActOnPragmaAttributePop(SourceLocation PragmaLoc, 10004 const IdentifierInfo *Namespace); 10005 10006 /// Adds the attributes that have been specified using the 10007 /// '\#pragma clang attribute push' directives to the given declaration. 10008 void AddPragmaAttributes(Scope *S, Decl *D); 10009 10010 void DiagnoseUnterminatedPragmaAttribute(); 10011 10012 /// Called on well formed \#pragma clang optimize. 10013 void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc); 10014 10015 /// Get the location for the currently active "\#pragma clang optimize 10016 /// off". If this location is invalid, then the state of the pragma is "on". getOptimizeOffPragmaLocation()10017 SourceLocation getOptimizeOffPragmaLocation() const { 10018 return OptimizeOffPragmaLocation; 10019 } 10020 10021 /// Only called on function definitions; if there is a pragma in scope 10022 /// with the effect of a range-based optnone, consider marking the function 10023 /// with attribute optnone. 10024 void AddRangeBasedOptnone(FunctionDecl *FD); 10025 10026 /// Adds the 'optnone' attribute to the function declaration if there 10027 /// are no conflicts; Loc represents the location causing the 'optnone' 10028 /// attribute to be added (usually because of a pragma). 10029 void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc); 10030 10031 /// AddAlignedAttr - Adds an aligned attribute to a particular declaration. 10032 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, 10033 bool IsPackExpansion); 10034 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T, 10035 bool IsPackExpansion); 10036 10037 /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular 10038 /// declaration. 10039 void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, 10040 Expr *OE); 10041 10042 /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular 10043 /// declaration. 10044 void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, 10045 Expr *ParamExpr); 10046 10047 /// AddAlignValueAttr - Adds an align_value attribute to a particular 10048 /// declaration. 10049 void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E); 10050 10051 /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D. 10052 void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, 10053 StringRef Annot, MutableArrayRef<Expr *> Args); 10054 10055 /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular 10056 /// declaration. 10057 void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI, 10058 Expr *MaxThreads, Expr *MinBlocks); 10059 10060 /// AddModeAttr - Adds a mode attribute to a particular declaration. 10061 void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name, 10062 bool InInstantiation = false); 10063 10064 void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, 10065 ParameterABI ABI); 10066 10067 enum class RetainOwnershipKind {NS, CF, OS}; 10068 void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, 10069 RetainOwnershipKind K, bool IsTemplateInstantiation); 10070 10071 /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size 10072 /// attribute to a particular declaration. 10073 void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI, 10074 Expr *Min, Expr *Max); 10075 10076 /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a 10077 /// particular declaration. 10078 void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI, 10079 Expr *Min, Expr *Max); 10080 10081 bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type); 10082 10083 //===--------------------------------------------------------------------===// 10084 // C++ Coroutines TS 10085 // 10086 bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, 10087 StringRef Keyword); 10088 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E); 10089 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E); 10090 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E); 10091 10092 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E, 10093 bool IsImplicit = false); 10094 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E, 10095 UnresolvedLookupExpr* Lookup); 10096 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E); 10097 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E, 10098 bool IsImplicit = false); 10099 StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs); 10100 bool buildCoroutineParameterMoves(SourceLocation Loc); 10101 VarDecl *buildCoroutinePromise(SourceLocation Loc); 10102 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body); 10103 ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc, 10104 SourceLocation FuncLoc); 10105 /// Check that the expression co_await promise.final_suspend() shall not be 10106 /// potentially-throwing. 10107 bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend); 10108 10109 //===--------------------------------------------------------------------===// 10110 // OpenCL extensions. 10111 // 10112 private: 10113 std::string CurrOpenCLExtension; 10114 /// Extensions required by an OpenCL type. 10115 llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap; 10116 /// Extensions required by an OpenCL declaration. 10117 llvm::DenseMap<const Decl*, std::set<std::string>> OpenCLDeclExtMap; 10118 public: getCurrentOpenCLExtension()10119 llvm::StringRef getCurrentOpenCLExtension() const { 10120 return CurrOpenCLExtension; 10121 } 10122 10123 /// Check if a function declaration \p FD associates with any 10124 /// extensions present in OpenCLDeclExtMap and if so return the 10125 /// extension(s) name(s). 10126 std::string getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD); 10127 10128 /// Check if a function type \p FT associates with any 10129 /// extensions present in OpenCLTypeExtMap and if so return the 10130 /// extension(s) name(s). 10131 std::string getOpenCLExtensionsFromTypeExtMap(FunctionType *FT); 10132 10133 /// Find an extension in an appropriate extension map and return its name 10134 template<typename T, typename MapT> 10135 std::string getOpenCLExtensionsFromExtMap(T* FT, MapT &Map); 10136 setCurrentOpenCLExtension(llvm::StringRef Ext)10137 void setCurrentOpenCLExtension(llvm::StringRef Ext) { 10138 CurrOpenCLExtension = std::string(Ext); 10139 } 10140 10141 /// Set OpenCL extensions for a type which can only be used when these 10142 /// OpenCL extensions are enabled. If \p Exts is empty, do nothing. 10143 /// \param Exts A space separated list of OpenCL extensions. 10144 void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts); 10145 10146 /// Set OpenCL extensions for a declaration which can only be 10147 /// used when these OpenCL extensions are enabled. If \p Exts is empty, do 10148 /// nothing. 10149 /// \param Exts A space separated list of OpenCL extensions. 10150 void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts); 10151 10152 /// Set current OpenCL extensions for a type which can only be used 10153 /// when these OpenCL extensions are enabled. If current OpenCL extension is 10154 /// empty, do nothing. 10155 void setCurrentOpenCLExtensionForType(QualType T); 10156 10157 /// Set current OpenCL extensions for a declaration which 10158 /// can only be used when these OpenCL extensions are enabled. If current 10159 /// OpenCL extension is empty, do nothing. 10160 void setCurrentOpenCLExtensionForDecl(Decl *FD); 10161 10162 bool isOpenCLDisabledDecl(Decl *FD); 10163 10164 /// Check if type \p T corresponding to declaration specifier \p DS 10165 /// is disabled due to required OpenCL extensions being disabled. If so, 10166 /// emit diagnostics. 10167 /// \return true if type is disabled. 10168 bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T); 10169 10170 /// Check if declaration \p D used by expression \p E 10171 /// is disabled due to required OpenCL extensions being disabled. If so, 10172 /// emit diagnostics. 10173 /// \return true if type is disabled. 10174 bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E); 10175 10176 //===--------------------------------------------------------------------===// 10177 // OpenMP directives and clauses. 10178 // 10179 private: 10180 void *VarDataSharingAttributesStack; 10181 /// Number of nested '#pragma omp declare target' directives. 10182 SmallVector<SourceLocation, 4> DeclareTargetNesting; 10183 /// Initialization of data-sharing attributes stack. 10184 void InitDataSharingAttributesStack(); 10185 void DestroyDataSharingAttributesStack(); 10186 ExprResult 10187 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind, 10188 bool StrictlyPositive = true); 10189 /// Returns OpenMP nesting level for current directive. 10190 unsigned getOpenMPNestingLevel() const; 10191 10192 /// Adjusts the function scopes index for the target-based regions. 10193 void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex, 10194 unsigned Level) const; 10195 10196 /// Returns the number of scopes associated with the construct on the given 10197 /// OpenMP level. 10198 int getNumberOfConstructScopes(unsigned Level) const; 10199 10200 /// Push new OpenMP function region for non-capturing function. 10201 void pushOpenMPFunctionRegion(); 10202 10203 /// Pop OpenMP function region for non-capturing function. 10204 void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI); 10205 10206 /// Checks if a type or a declaration is disabled due to the owning extension 10207 /// being disabled, and emits diagnostic messages if it is disabled. 10208 /// \param D type or declaration to be checked. 10209 /// \param DiagLoc source location for the diagnostic message. 10210 /// \param DiagInfo information to be emitted for the diagnostic message. 10211 /// \param SrcRange source range of the declaration. 10212 /// \param Map maps type or declaration to the extensions. 10213 /// \param Selector selects diagnostic message: 0 for type and 1 for 10214 /// declaration. 10215 /// \return true if the type or declaration is disabled. 10216 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT> 10217 bool checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo, 10218 MapT &Map, unsigned Selector = 0, 10219 SourceRange SrcRange = SourceRange()); 10220 10221 /// Helper to keep information about the current `omp begin/end declare 10222 /// variant` nesting. 10223 struct OMPDeclareVariantScope { 10224 /// The associated OpenMP context selector. 10225 OMPTraitInfo *TI; 10226 10227 /// The associated OpenMP context selector mangling. 10228 std::string NameSuffix; 10229 10230 OMPDeclareVariantScope(OMPTraitInfo &TI); 10231 }; 10232 10233 /// Return the OMPTraitInfo for the surrounding scope, if any. getOMPTraitInfoForSurroundingScope()10234 OMPTraitInfo *getOMPTraitInfoForSurroundingScope() { 10235 return OMPDeclareVariantScopes.empty() ? nullptr 10236 : OMPDeclareVariantScopes.back().TI; 10237 } 10238 10239 /// The current `omp begin/end declare variant` scopes. 10240 SmallVector<OMPDeclareVariantScope, 4> OMPDeclareVariantScopes; 10241 10242 /// The current `omp begin/end assumes` scopes. 10243 SmallVector<AssumptionAttr *, 4> OMPAssumeScoped; 10244 10245 /// All `omp assumes` we encountered so far. 10246 SmallVector<AssumptionAttr *, 4> OMPAssumeGlobal; 10247 10248 public: 10249 /// The declarator \p D defines a function in the scope \p S which is nested 10250 /// in an `omp begin/end declare variant` scope. In this method we create a 10251 /// declaration for \p D and rename \p D according to the OpenMP context 10252 /// selector of the surrounding scope. Return all base functions in \p Bases. 10253 void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope( 10254 Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, 10255 SmallVectorImpl<FunctionDecl *> &Bases); 10256 10257 /// Register \p D as specialization of all base functions in \p Bases in the 10258 /// current `omp begin/end declare variant` scope. 10259 void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope( 10260 Decl *D, SmallVectorImpl<FunctionDecl *> &Bases); 10261 10262 /// Act on \p D, a function definition inside of an `omp [begin/end] assumes`. 10263 void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D); 10264 10265 /// Can we exit an OpenMP declare variant scope at the moment. isInOpenMPDeclareVariantScope()10266 bool isInOpenMPDeclareVariantScope() const { 10267 return !OMPDeclareVariantScopes.empty(); 10268 } 10269 10270 /// Given the potential call expression \p Call, determine if there is a 10271 /// specialization via the OpenMP declare variant mechanism available. If 10272 /// there is, return the specialized call expression, otherwise return the 10273 /// original \p Call. 10274 ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope, 10275 SourceLocation LParenLoc, MultiExprArg ArgExprs, 10276 SourceLocation RParenLoc, Expr *ExecConfig); 10277 10278 /// Handle a `omp begin declare variant`. 10279 void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI); 10280 10281 /// Handle a `omp end declare variant`. 10282 void ActOnOpenMPEndDeclareVariant(); 10283 10284 /// Checks if the variant/multiversion functions are compatible. 10285 bool areMultiversionVariantFunctionsCompatible( 10286 const FunctionDecl *OldFD, const FunctionDecl *NewFD, 10287 const PartialDiagnostic &NoProtoDiagID, 10288 const PartialDiagnosticAt &NoteCausedDiagIDAt, 10289 const PartialDiagnosticAt &NoSupportDiagIDAt, 10290 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, 10291 bool ConstexprSupported, bool CLinkageMayDiffer); 10292 10293 /// Function tries to capture lambda's captured variables in the OpenMP region 10294 /// before the original lambda is captured. 10295 void tryCaptureOpenMPLambdas(ValueDecl *V); 10296 10297 /// Return true if the provided declaration \a VD should be captured by 10298 /// reference. 10299 /// \param Level Relative level of nested OpenMP construct for that the check 10300 /// is performed. 10301 /// \param OpenMPCaptureLevel Capture level within an OpenMP construct. 10302 bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, 10303 unsigned OpenMPCaptureLevel) const; 10304 10305 /// Check if the specified variable is used in one of the private 10306 /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP 10307 /// constructs. 10308 VarDecl *isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo = false, 10309 unsigned StopAt = 0); 10310 ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK, 10311 ExprObjectKind OK, SourceLocation Loc); 10312 10313 /// If the current region is a loop-based region, mark the start of the loop 10314 /// construct. 10315 void startOpenMPLoop(); 10316 10317 /// If the current region is a range loop-based region, mark the start of the 10318 /// loop construct. 10319 void startOpenMPCXXRangeFor(); 10320 10321 /// Check if the specified variable is used in 'private' clause. 10322 /// \param Level Relative level of nested OpenMP construct for that the check 10323 /// is performed. 10324 OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level, 10325 unsigned CapLevel) const; 10326 10327 /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.) 10328 /// for \p FD based on DSA for the provided corresponding captured declaration 10329 /// \p D. 10330 void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level); 10331 10332 /// Check if the specified variable is captured by 'target' directive. 10333 /// \param Level Relative level of nested OpenMP construct for that the check 10334 /// is performed. 10335 bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level, 10336 unsigned CaptureLevel) const; 10337 10338 /// Check if the specified global variable must be captured by outer capture 10339 /// regions. 10340 /// \param Level Relative level of nested OpenMP construct for that 10341 /// the check is performed. 10342 bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level, 10343 unsigned CaptureLevel) const; 10344 10345 ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc, 10346 Expr *Op); 10347 /// Called on start of new data sharing attribute block. 10348 void StartOpenMPDSABlock(OpenMPDirectiveKind K, 10349 const DeclarationNameInfo &DirName, Scope *CurScope, 10350 SourceLocation Loc); 10351 /// Start analysis of clauses. 10352 void StartOpenMPClause(OpenMPClauseKind K); 10353 /// End analysis of clauses. 10354 void EndOpenMPClause(); 10355 /// Called on end of data sharing attribute block. 10356 void EndOpenMPDSABlock(Stmt *CurDirective); 10357 10358 /// Check if the current region is an OpenMP loop region and if it is, 10359 /// mark loop control variable, used in \p Init for loop initialization, as 10360 /// private by default. 10361 /// \param Init First part of the for loop. 10362 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init); 10363 10364 // OpenMP directives and clauses. 10365 /// Called on correct id-expression from the '#pragma omp 10366 /// threadprivate'. 10367 ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec, 10368 const DeclarationNameInfo &Id, 10369 OpenMPDirectiveKind Kind); 10370 /// Called on well-formed '#pragma omp threadprivate'. 10371 DeclGroupPtrTy ActOnOpenMPThreadprivateDirective( 10372 SourceLocation Loc, 10373 ArrayRef<Expr *> VarList); 10374 /// Builds a new OpenMPThreadPrivateDecl and checks its correctness. 10375 OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc, 10376 ArrayRef<Expr *> VarList); 10377 /// Called on well-formed '#pragma omp allocate'. 10378 DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc, 10379 ArrayRef<Expr *> VarList, 10380 ArrayRef<OMPClause *> Clauses, 10381 DeclContext *Owner = nullptr); 10382 10383 /// Called on well-formed '#pragma omp [begin] assume[s]'. 10384 void ActOnOpenMPAssumesDirective(SourceLocation Loc, 10385 OpenMPDirectiveKind DKind, 10386 ArrayRef<StringRef> Assumptions, 10387 bool SkippedClauses); 10388 10389 /// Check if there is an active global `omp begin assumes` directive. isInOpenMPAssumeScope()10390 bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); } 10391 10392 /// Check if there is an active global `omp assumes` directive. hasGlobalOpenMPAssumes()10393 bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); } 10394 10395 /// Called on well-formed '#pragma omp end assumes'. 10396 void ActOnOpenMPEndAssumesDirective(); 10397 10398 /// Called on well-formed '#pragma omp requires'. 10399 DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc, 10400 ArrayRef<OMPClause *> ClauseList); 10401 /// Check restrictions on Requires directive 10402 OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc, 10403 ArrayRef<OMPClause *> Clauses); 10404 /// Check if the specified type is allowed to be used in 'omp declare 10405 /// reduction' construct. 10406 QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, 10407 TypeResult ParsedType); 10408 /// Called on start of '#pragma omp declare reduction'. 10409 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart( 10410 Scope *S, DeclContext *DC, DeclarationName Name, 10411 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes, 10412 AccessSpecifier AS, Decl *PrevDeclInScope = nullptr); 10413 /// Initialize declare reduction construct initializer. 10414 void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D); 10415 /// Finish current declare reduction construct initializer. 10416 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner); 10417 /// Initialize declare reduction construct initializer. 10418 /// \return omp_priv variable. 10419 VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D); 10420 /// Finish current declare reduction construct initializer. 10421 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, 10422 VarDecl *OmpPrivParm); 10423 /// Called at the end of '#pragma omp declare reduction'. 10424 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd( 10425 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid); 10426 10427 /// Check variable declaration in 'omp declare mapper' construct. 10428 TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D); 10429 /// Check if the specified type is allowed to be used in 'omp declare 10430 /// mapper' construct. 10431 QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc, 10432 TypeResult ParsedType); 10433 /// Called on start of '#pragma omp declare mapper'. 10434 DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective( 10435 Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType, 10436 SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS, 10437 Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses, 10438 Decl *PrevDeclInScope = nullptr); 10439 /// Build the mapper variable of '#pragma omp declare mapper'. 10440 ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, 10441 QualType MapperType, 10442 SourceLocation StartLoc, 10443 DeclarationName VN); 10444 bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const; 10445 const ValueDecl *getOpenMPDeclareMapperVarName() const; 10446 10447 /// Called on the start of target region i.e. '#pragma omp declare target'. 10448 bool ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc); 10449 /// Called at the end of target region i.e. '#pragme omp end declare target'. 10450 void ActOnFinishOpenMPDeclareTargetDirective(); 10451 /// Searches for the provided declaration name for OpenMP declare target 10452 /// directive. 10453 NamedDecl * 10454 lookupOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec, 10455 const DeclarationNameInfo &Id, 10456 NamedDeclSetType &SameDirectiveDecls); 10457 /// Called on correct id-expression from the '#pragma omp declare target'. 10458 void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc, 10459 OMPDeclareTargetDeclAttr::MapTypeTy MT, 10460 OMPDeclareTargetDeclAttr::DevTypeTy DT); 10461 /// Check declaration inside target region. 10462 void 10463 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, 10464 SourceLocation IdLoc = SourceLocation()); 10465 /// Finishes analysis of the deferred functions calls that may be declared as 10466 /// host/nohost during device/host compilation. 10467 void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller, 10468 const FunctionDecl *Callee, 10469 SourceLocation Loc); 10470 /// Return true inside OpenMP declare target region. isInOpenMPDeclareTargetContext()10471 bool isInOpenMPDeclareTargetContext() const { 10472 return !DeclareTargetNesting.empty(); 10473 } 10474 /// Return true inside OpenMP target region. 10475 bool isInOpenMPTargetExecutionDirective() const; 10476 10477 /// Return the number of captured regions created for an OpenMP directive. 10478 static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind); 10479 10480 /// Initialization of captured region for OpenMP region. 10481 void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope); 10482 /// End of OpenMP region. 10483 /// 10484 /// \param S Statement associated with the current OpenMP region. 10485 /// \param Clauses List of clauses for the current OpenMP region. 10486 /// 10487 /// \returns Statement for finished OpenMP region. 10488 StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses); 10489 StmtResult ActOnOpenMPExecutableDirective( 10490 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, 10491 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, 10492 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc); 10493 /// Called on well-formed '\#pragma omp parallel' after parsing 10494 /// of the associated statement. 10495 StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses, 10496 Stmt *AStmt, 10497 SourceLocation StartLoc, 10498 SourceLocation EndLoc); 10499 using VarsWithInheritedDSAType = 10500 llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>; 10501 /// Called on well-formed '\#pragma omp simd' after parsing 10502 /// of the associated statement. 10503 StmtResult 10504 ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10505 SourceLocation StartLoc, SourceLocation EndLoc, 10506 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10507 /// Called on well-formed '\#pragma omp for' after parsing 10508 /// of the associated statement. 10509 StmtResult 10510 ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10511 SourceLocation StartLoc, SourceLocation EndLoc, 10512 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10513 /// Called on well-formed '\#pragma omp for simd' after parsing 10514 /// of the associated statement. 10515 StmtResult 10516 ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10517 SourceLocation StartLoc, SourceLocation EndLoc, 10518 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10519 /// Called on well-formed '\#pragma omp sections' after parsing 10520 /// of the associated statement. 10521 StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses, 10522 Stmt *AStmt, SourceLocation StartLoc, 10523 SourceLocation EndLoc); 10524 /// Called on well-formed '\#pragma omp section' after parsing of the 10525 /// associated statement. 10526 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc, 10527 SourceLocation EndLoc); 10528 /// Called on well-formed '\#pragma omp single' after parsing of the 10529 /// associated statement. 10530 StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses, 10531 Stmt *AStmt, SourceLocation StartLoc, 10532 SourceLocation EndLoc); 10533 /// Called on well-formed '\#pragma omp master' after parsing of the 10534 /// associated statement. 10535 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc, 10536 SourceLocation EndLoc); 10537 /// Called on well-formed '\#pragma omp critical' after parsing of the 10538 /// associated statement. 10539 StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName, 10540 ArrayRef<OMPClause *> Clauses, 10541 Stmt *AStmt, SourceLocation StartLoc, 10542 SourceLocation EndLoc); 10543 /// Called on well-formed '\#pragma omp parallel for' after parsing 10544 /// of the associated statement. 10545 StmtResult ActOnOpenMPParallelForDirective( 10546 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10547 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10548 /// Called on well-formed '\#pragma omp parallel for simd' after 10549 /// parsing of the associated statement. 10550 StmtResult ActOnOpenMPParallelForSimdDirective( 10551 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10552 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10553 /// Called on well-formed '\#pragma omp parallel master' after 10554 /// parsing of the associated statement. 10555 StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses, 10556 Stmt *AStmt, 10557 SourceLocation StartLoc, 10558 SourceLocation EndLoc); 10559 /// Called on well-formed '\#pragma omp parallel sections' after 10560 /// parsing of the associated statement. 10561 StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses, 10562 Stmt *AStmt, 10563 SourceLocation StartLoc, 10564 SourceLocation EndLoc); 10565 /// Called on well-formed '\#pragma omp task' after parsing of the 10566 /// associated statement. 10567 StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses, 10568 Stmt *AStmt, SourceLocation StartLoc, 10569 SourceLocation EndLoc); 10570 /// Called on well-formed '\#pragma omp taskyield'. 10571 StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc, 10572 SourceLocation EndLoc); 10573 /// Called on well-formed '\#pragma omp barrier'. 10574 StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc, 10575 SourceLocation EndLoc); 10576 /// Called on well-formed '\#pragma omp taskwait'. 10577 StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc, 10578 SourceLocation EndLoc); 10579 /// Called on well-formed '\#pragma omp taskgroup'. 10580 StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses, 10581 Stmt *AStmt, SourceLocation StartLoc, 10582 SourceLocation EndLoc); 10583 /// Called on well-formed '\#pragma omp flush'. 10584 StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, 10585 SourceLocation StartLoc, 10586 SourceLocation EndLoc); 10587 /// Called on well-formed '\#pragma omp depobj'. 10588 StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses, 10589 SourceLocation StartLoc, 10590 SourceLocation EndLoc); 10591 /// Called on well-formed '\#pragma omp scan'. 10592 StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses, 10593 SourceLocation StartLoc, 10594 SourceLocation EndLoc); 10595 /// Called on well-formed '\#pragma omp ordered' after parsing of the 10596 /// associated statement. 10597 StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses, 10598 Stmt *AStmt, SourceLocation StartLoc, 10599 SourceLocation EndLoc); 10600 /// Called on well-formed '\#pragma omp atomic' after parsing of the 10601 /// associated statement. 10602 StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, 10603 Stmt *AStmt, SourceLocation StartLoc, 10604 SourceLocation EndLoc); 10605 /// Called on well-formed '\#pragma omp target' after parsing of the 10606 /// associated statement. 10607 StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses, 10608 Stmt *AStmt, SourceLocation StartLoc, 10609 SourceLocation EndLoc); 10610 /// Called on well-formed '\#pragma omp target data' after parsing of 10611 /// the associated statement. 10612 StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses, 10613 Stmt *AStmt, SourceLocation StartLoc, 10614 SourceLocation EndLoc); 10615 /// Called on well-formed '\#pragma omp target enter data' after 10616 /// parsing of the associated statement. 10617 StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses, 10618 SourceLocation StartLoc, 10619 SourceLocation EndLoc, 10620 Stmt *AStmt); 10621 /// Called on well-formed '\#pragma omp target exit data' after 10622 /// parsing of the associated statement. 10623 StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses, 10624 SourceLocation StartLoc, 10625 SourceLocation EndLoc, 10626 Stmt *AStmt); 10627 /// Called on well-formed '\#pragma omp target parallel' after 10628 /// parsing of the associated statement. 10629 StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses, 10630 Stmt *AStmt, 10631 SourceLocation StartLoc, 10632 SourceLocation EndLoc); 10633 /// Called on well-formed '\#pragma omp target parallel for' after 10634 /// parsing of the associated statement. 10635 StmtResult ActOnOpenMPTargetParallelForDirective( 10636 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10637 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10638 /// Called on well-formed '\#pragma omp teams' after parsing of the 10639 /// associated statement. 10640 StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses, 10641 Stmt *AStmt, SourceLocation StartLoc, 10642 SourceLocation EndLoc); 10643 /// Called on well-formed '\#pragma omp cancellation point'. 10644 StmtResult 10645 ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc, 10646 SourceLocation EndLoc, 10647 OpenMPDirectiveKind CancelRegion); 10648 /// Called on well-formed '\#pragma omp cancel'. 10649 StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses, 10650 SourceLocation StartLoc, 10651 SourceLocation EndLoc, 10652 OpenMPDirectiveKind CancelRegion); 10653 /// Called on well-formed '\#pragma omp taskloop' after parsing of the 10654 /// associated statement. 10655 StmtResult 10656 ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10657 SourceLocation StartLoc, SourceLocation EndLoc, 10658 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10659 /// Called on well-formed '\#pragma omp taskloop simd' after parsing of 10660 /// the associated statement. 10661 StmtResult ActOnOpenMPTaskLoopSimdDirective( 10662 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10663 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10664 /// Called on well-formed '\#pragma omp master taskloop' after parsing of the 10665 /// associated statement. 10666 StmtResult ActOnOpenMPMasterTaskLoopDirective( 10667 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10668 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10669 /// Called on well-formed '\#pragma omp master taskloop simd' after parsing of 10670 /// the associated statement. 10671 StmtResult ActOnOpenMPMasterTaskLoopSimdDirective( 10672 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10673 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10674 /// Called on well-formed '\#pragma omp parallel master taskloop' after 10675 /// parsing of the associated statement. 10676 StmtResult ActOnOpenMPParallelMasterTaskLoopDirective( 10677 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10678 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10679 /// Called on well-formed '\#pragma omp parallel master taskloop simd' after 10680 /// parsing of the associated statement. 10681 StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective( 10682 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10683 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10684 /// Called on well-formed '\#pragma omp distribute' after parsing 10685 /// of the associated statement. 10686 StmtResult 10687 ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10688 SourceLocation StartLoc, SourceLocation EndLoc, 10689 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10690 /// Called on well-formed '\#pragma omp target update'. 10691 StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses, 10692 SourceLocation StartLoc, 10693 SourceLocation EndLoc, 10694 Stmt *AStmt); 10695 /// Called on well-formed '\#pragma omp distribute parallel for' after 10696 /// parsing of the associated statement. 10697 StmtResult ActOnOpenMPDistributeParallelForDirective( 10698 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10699 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10700 /// Called on well-formed '\#pragma omp distribute parallel for simd' 10701 /// after parsing of the associated statement. 10702 StmtResult ActOnOpenMPDistributeParallelForSimdDirective( 10703 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10704 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10705 /// Called on well-formed '\#pragma omp distribute simd' after 10706 /// parsing of the associated statement. 10707 StmtResult ActOnOpenMPDistributeSimdDirective( 10708 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10709 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10710 /// Called on well-formed '\#pragma omp target parallel for simd' after 10711 /// parsing of the associated statement. 10712 StmtResult ActOnOpenMPTargetParallelForSimdDirective( 10713 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10714 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10715 /// Called on well-formed '\#pragma omp target simd' after parsing of 10716 /// the associated statement. 10717 StmtResult 10718 ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10719 SourceLocation StartLoc, SourceLocation EndLoc, 10720 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10721 /// Called on well-formed '\#pragma omp teams distribute' after parsing of 10722 /// the associated statement. 10723 StmtResult ActOnOpenMPTeamsDistributeDirective( 10724 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10725 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10726 /// Called on well-formed '\#pragma omp teams distribute simd' after parsing 10727 /// of the associated statement. 10728 StmtResult ActOnOpenMPTeamsDistributeSimdDirective( 10729 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10730 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10731 /// Called on well-formed '\#pragma omp teams distribute parallel for simd' 10732 /// after parsing of the associated statement. 10733 StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective( 10734 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10735 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10736 /// Called on well-formed '\#pragma omp teams distribute parallel for' 10737 /// after parsing of the associated statement. 10738 StmtResult ActOnOpenMPTeamsDistributeParallelForDirective( 10739 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10740 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10741 /// Called on well-formed '\#pragma omp target teams' after parsing of the 10742 /// associated statement. 10743 StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses, 10744 Stmt *AStmt, 10745 SourceLocation StartLoc, 10746 SourceLocation EndLoc); 10747 /// Called on well-formed '\#pragma omp target teams distribute' after parsing 10748 /// of the associated statement. 10749 StmtResult ActOnOpenMPTargetTeamsDistributeDirective( 10750 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10751 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10752 /// Called on well-formed '\#pragma omp target teams distribute parallel for' 10753 /// after parsing of the associated statement. 10754 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective( 10755 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10756 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10757 /// Called on well-formed '\#pragma omp target teams distribute parallel for 10758 /// simd' after parsing of the associated statement. 10759 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective( 10760 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10761 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10762 /// Called on well-formed '\#pragma omp target teams distribute simd' after 10763 /// parsing of the associated statement. 10764 StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective( 10765 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10766 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10767 10768 /// Checks correctness of linear modifiers. 10769 bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind, 10770 SourceLocation LinLoc); 10771 /// Checks that the specified declaration matches requirements for the linear 10772 /// decls. 10773 bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc, 10774 OpenMPLinearClauseKind LinKind, QualType Type, 10775 bool IsDeclareSimd = false); 10776 10777 /// Called on well-formed '\#pragma omp declare simd' after parsing of 10778 /// the associated method/function. 10779 DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective( 10780 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, 10781 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, 10782 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, 10783 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR); 10784 10785 /// Checks '\#pragma omp declare variant' variant function and original 10786 /// functions after parsing of the associated method/function. 10787 /// \param DG Function declaration to which declare variant directive is 10788 /// applied to. 10789 /// \param VariantRef Expression that references the variant function, which 10790 /// must be used instead of the original one, specified in \p DG. 10791 /// \param TI The trait info object representing the match clause. 10792 /// \returns None, if the function/variant function are not compatible with 10793 /// the pragma, pair of original function/variant ref expression otherwise. 10794 Optional<std::pair<FunctionDecl *, Expr *>> 10795 checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef, 10796 OMPTraitInfo &TI, SourceRange SR); 10797 10798 /// Called on well-formed '\#pragma omp declare variant' after parsing of 10799 /// the associated method/function. 10800 /// \param FD Function declaration to which declare variant directive is 10801 /// applied to. 10802 /// \param VariantRef Expression that references the variant function, which 10803 /// must be used instead of the original one, specified in \p DG. 10804 /// \param TI The context traits associated with the function variant. 10805 void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef, 10806 OMPTraitInfo &TI, SourceRange SR); 10807 10808 OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, 10809 Expr *Expr, 10810 SourceLocation StartLoc, 10811 SourceLocation LParenLoc, 10812 SourceLocation EndLoc); 10813 /// Called on well-formed 'allocator' clause. 10814 OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator, 10815 SourceLocation StartLoc, 10816 SourceLocation LParenLoc, 10817 SourceLocation EndLoc); 10818 /// Called on well-formed 'if' clause. 10819 OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier, 10820 Expr *Condition, SourceLocation StartLoc, 10821 SourceLocation LParenLoc, 10822 SourceLocation NameModifierLoc, 10823 SourceLocation ColonLoc, 10824 SourceLocation EndLoc); 10825 /// Called on well-formed 'final' clause. 10826 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc, 10827 SourceLocation LParenLoc, 10828 SourceLocation EndLoc); 10829 /// Called on well-formed 'num_threads' clause. 10830 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads, 10831 SourceLocation StartLoc, 10832 SourceLocation LParenLoc, 10833 SourceLocation EndLoc); 10834 /// Called on well-formed 'safelen' clause. 10835 OMPClause *ActOnOpenMPSafelenClause(Expr *Length, 10836 SourceLocation StartLoc, 10837 SourceLocation LParenLoc, 10838 SourceLocation EndLoc); 10839 /// Called on well-formed 'simdlen' clause. 10840 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc, 10841 SourceLocation LParenLoc, 10842 SourceLocation EndLoc); 10843 /// Called on well-formed 'collapse' clause. 10844 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops, 10845 SourceLocation StartLoc, 10846 SourceLocation LParenLoc, 10847 SourceLocation EndLoc); 10848 /// Called on well-formed 'ordered' clause. 10849 OMPClause * 10850 ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc, 10851 SourceLocation LParenLoc = SourceLocation(), 10852 Expr *NumForLoops = nullptr); 10853 /// Called on well-formed 'grainsize' clause. 10854 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc, 10855 SourceLocation LParenLoc, 10856 SourceLocation EndLoc); 10857 /// Called on well-formed 'num_tasks' clause. 10858 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc, 10859 SourceLocation LParenLoc, 10860 SourceLocation EndLoc); 10861 /// Called on well-formed 'hint' clause. 10862 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc, 10863 SourceLocation LParenLoc, 10864 SourceLocation EndLoc); 10865 /// Called on well-formed 'detach' clause. 10866 OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc, 10867 SourceLocation LParenLoc, 10868 SourceLocation EndLoc); 10869 10870 OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind, 10871 unsigned Argument, 10872 SourceLocation ArgumentLoc, 10873 SourceLocation StartLoc, 10874 SourceLocation LParenLoc, 10875 SourceLocation EndLoc); 10876 /// Called on well-formed 'default' clause. 10877 OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind, 10878 SourceLocation KindLoc, 10879 SourceLocation StartLoc, 10880 SourceLocation LParenLoc, 10881 SourceLocation EndLoc); 10882 /// Called on well-formed 'proc_bind' clause. 10883 OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind, 10884 SourceLocation KindLoc, 10885 SourceLocation StartLoc, 10886 SourceLocation LParenLoc, 10887 SourceLocation EndLoc); 10888 /// Called on well-formed 'order' clause. 10889 OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind, 10890 SourceLocation KindLoc, 10891 SourceLocation StartLoc, 10892 SourceLocation LParenLoc, 10893 SourceLocation EndLoc); 10894 /// Called on well-formed 'update' clause. 10895 OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind, 10896 SourceLocation KindLoc, 10897 SourceLocation StartLoc, 10898 SourceLocation LParenLoc, 10899 SourceLocation EndLoc); 10900 10901 OMPClause *ActOnOpenMPSingleExprWithArgClause( 10902 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr, 10903 SourceLocation StartLoc, SourceLocation LParenLoc, 10904 ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc, 10905 SourceLocation EndLoc); 10906 /// Called on well-formed 'schedule' clause. 10907 OMPClause *ActOnOpenMPScheduleClause( 10908 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2, 10909 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, 10910 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc, 10911 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc); 10912 10913 OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc, 10914 SourceLocation EndLoc); 10915 /// Called on well-formed 'nowait' clause. 10916 OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc, 10917 SourceLocation EndLoc); 10918 /// Called on well-formed 'untied' clause. 10919 OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc, 10920 SourceLocation EndLoc); 10921 /// Called on well-formed 'mergeable' clause. 10922 OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc, 10923 SourceLocation EndLoc); 10924 /// Called on well-formed 'read' clause. 10925 OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc, 10926 SourceLocation EndLoc); 10927 /// Called on well-formed 'write' clause. 10928 OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc, 10929 SourceLocation EndLoc); 10930 /// Called on well-formed 'update' clause. 10931 OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc, 10932 SourceLocation EndLoc); 10933 /// Called on well-formed 'capture' clause. 10934 OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc, 10935 SourceLocation EndLoc); 10936 /// Called on well-formed 'seq_cst' clause. 10937 OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc, 10938 SourceLocation EndLoc); 10939 /// Called on well-formed 'acq_rel' clause. 10940 OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc, 10941 SourceLocation EndLoc); 10942 /// Called on well-formed 'acquire' clause. 10943 OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc, 10944 SourceLocation EndLoc); 10945 /// Called on well-formed 'release' clause. 10946 OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc, 10947 SourceLocation EndLoc); 10948 /// Called on well-formed 'relaxed' clause. 10949 OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc, 10950 SourceLocation EndLoc); 10951 /// Called on well-formed 'destroy' clause. 10952 OMPClause *ActOnOpenMPDestroyClause(SourceLocation StartLoc, 10953 SourceLocation EndLoc); 10954 /// Called on well-formed 'threads' clause. 10955 OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc, 10956 SourceLocation EndLoc); 10957 /// Called on well-formed 'simd' clause. 10958 OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc, 10959 SourceLocation EndLoc); 10960 /// Called on well-formed 'nogroup' clause. 10961 OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc, 10962 SourceLocation EndLoc); 10963 /// Called on well-formed 'unified_address' clause. 10964 OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc, 10965 SourceLocation EndLoc); 10966 10967 /// Called on well-formed 'unified_address' clause. 10968 OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc, 10969 SourceLocation EndLoc); 10970 10971 /// Called on well-formed 'reverse_offload' clause. 10972 OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc, 10973 SourceLocation EndLoc); 10974 10975 /// Called on well-formed 'dynamic_allocators' clause. 10976 OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc, 10977 SourceLocation EndLoc); 10978 10979 /// Called on well-formed 'atomic_default_mem_order' clause. 10980 OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause( 10981 OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc, 10982 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc); 10983 10984 OMPClause *ActOnOpenMPVarListClause( 10985 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr, 10986 const OMPVarListLocTy &Locs, SourceLocation ColonLoc, 10987 CXXScopeSpec &ReductionOrMapperIdScopeSpec, 10988 DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier, 10989 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, 10990 ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit, 10991 SourceLocation ExtraModifierLoc, 10992 ArrayRef<OpenMPMotionModifierKind> MotionModifiers, 10993 ArrayRef<SourceLocation> MotionModifiersLoc); 10994 /// Called on well-formed 'inclusive' clause. 10995 OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList, 10996 SourceLocation StartLoc, 10997 SourceLocation LParenLoc, 10998 SourceLocation EndLoc); 10999 /// Called on well-formed 'exclusive' clause. 11000 OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList, 11001 SourceLocation StartLoc, 11002 SourceLocation LParenLoc, 11003 SourceLocation EndLoc); 11004 /// Called on well-formed 'allocate' clause. 11005 OMPClause * 11006 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList, 11007 SourceLocation StartLoc, SourceLocation ColonLoc, 11008 SourceLocation LParenLoc, SourceLocation EndLoc); 11009 /// Called on well-formed 'private' clause. 11010 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList, 11011 SourceLocation StartLoc, 11012 SourceLocation LParenLoc, 11013 SourceLocation EndLoc); 11014 /// Called on well-formed 'firstprivate' clause. 11015 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList, 11016 SourceLocation StartLoc, 11017 SourceLocation LParenLoc, 11018 SourceLocation EndLoc); 11019 /// Called on well-formed 'lastprivate' clause. 11020 OMPClause *ActOnOpenMPLastprivateClause( 11021 ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind, 11022 SourceLocation LPKindLoc, SourceLocation ColonLoc, 11023 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc); 11024 /// Called on well-formed 'shared' clause. 11025 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList, 11026 SourceLocation StartLoc, 11027 SourceLocation LParenLoc, 11028 SourceLocation EndLoc); 11029 /// Called on well-formed 'reduction' clause. 11030 OMPClause *ActOnOpenMPReductionClause( 11031 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier, 11032 SourceLocation StartLoc, SourceLocation LParenLoc, 11033 SourceLocation ModifierLoc, SourceLocation ColonLoc, 11034 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, 11035 const DeclarationNameInfo &ReductionId, 11036 ArrayRef<Expr *> UnresolvedReductions = llvm::None); 11037 /// Called on well-formed 'task_reduction' clause. 11038 OMPClause *ActOnOpenMPTaskReductionClause( 11039 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11040 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, 11041 CXXScopeSpec &ReductionIdScopeSpec, 11042 const DeclarationNameInfo &ReductionId, 11043 ArrayRef<Expr *> UnresolvedReductions = llvm::None); 11044 /// Called on well-formed 'in_reduction' clause. 11045 OMPClause *ActOnOpenMPInReductionClause( 11046 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11047 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, 11048 CXXScopeSpec &ReductionIdScopeSpec, 11049 const DeclarationNameInfo &ReductionId, 11050 ArrayRef<Expr *> UnresolvedReductions = llvm::None); 11051 /// Called on well-formed 'linear' clause. 11052 OMPClause * 11053 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step, 11054 SourceLocation StartLoc, SourceLocation LParenLoc, 11055 OpenMPLinearClauseKind LinKind, SourceLocation LinLoc, 11056 SourceLocation ColonLoc, SourceLocation EndLoc); 11057 /// Called on well-formed 'aligned' clause. 11058 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList, 11059 Expr *Alignment, 11060 SourceLocation StartLoc, 11061 SourceLocation LParenLoc, 11062 SourceLocation ColonLoc, 11063 SourceLocation EndLoc); 11064 /// Called on well-formed 'copyin' clause. 11065 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList, 11066 SourceLocation StartLoc, 11067 SourceLocation LParenLoc, 11068 SourceLocation EndLoc); 11069 /// Called on well-formed 'copyprivate' clause. 11070 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList, 11071 SourceLocation StartLoc, 11072 SourceLocation LParenLoc, 11073 SourceLocation EndLoc); 11074 /// Called on well-formed 'flush' pseudo clause. 11075 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList, 11076 SourceLocation StartLoc, 11077 SourceLocation LParenLoc, 11078 SourceLocation EndLoc); 11079 /// Called on well-formed 'depobj' pseudo clause. 11080 OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc, 11081 SourceLocation LParenLoc, 11082 SourceLocation EndLoc); 11083 /// Called on well-formed 'depend' clause. 11084 OMPClause * 11085 ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind, 11086 SourceLocation DepLoc, SourceLocation ColonLoc, 11087 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11088 SourceLocation LParenLoc, SourceLocation EndLoc); 11089 /// Called on well-formed 'device' clause. 11090 OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier, 11091 Expr *Device, SourceLocation StartLoc, 11092 SourceLocation LParenLoc, 11093 SourceLocation ModifierLoc, 11094 SourceLocation EndLoc); 11095 /// Called on well-formed 'map' clause. 11096 OMPClause * 11097 ActOnOpenMPMapClause(ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, 11098 ArrayRef<SourceLocation> MapTypeModifiersLoc, 11099 CXXScopeSpec &MapperIdScopeSpec, 11100 DeclarationNameInfo &MapperId, 11101 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, 11102 SourceLocation MapLoc, SourceLocation ColonLoc, 11103 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, 11104 ArrayRef<Expr *> UnresolvedMappers = llvm::None); 11105 /// Called on well-formed 'num_teams' clause. 11106 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc, 11107 SourceLocation LParenLoc, 11108 SourceLocation EndLoc); 11109 /// Called on well-formed 'thread_limit' clause. 11110 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit, 11111 SourceLocation StartLoc, 11112 SourceLocation LParenLoc, 11113 SourceLocation EndLoc); 11114 /// Called on well-formed 'priority' clause. 11115 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc, 11116 SourceLocation LParenLoc, 11117 SourceLocation EndLoc); 11118 /// Called on well-formed 'dist_schedule' clause. 11119 OMPClause *ActOnOpenMPDistScheduleClause( 11120 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, 11121 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc, 11122 SourceLocation CommaLoc, SourceLocation EndLoc); 11123 /// Called on well-formed 'defaultmap' clause. 11124 OMPClause *ActOnOpenMPDefaultmapClause( 11125 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind, 11126 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc, 11127 SourceLocation KindLoc, SourceLocation EndLoc); 11128 /// Called on well-formed 'to' clause. 11129 OMPClause * 11130 ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers, 11131 ArrayRef<SourceLocation> MotionModifiersLoc, 11132 CXXScopeSpec &MapperIdScopeSpec, 11133 DeclarationNameInfo &MapperId, SourceLocation ColonLoc, 11134 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, 11135 ArrayRef<Expr *> UnresolvedMappers = llvm::None); 11136 /// Called on well-formed 'from' clause. 11137 OMPClause * 11138 ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers, 11139 ArrayRef<SourceLocation> MotionModifiersLoc, 11140 CXXScopeSpec &MapperIdScopeSpec, 11141 DeclarationNameInfo &MapperId, SourceLocation ColonLoc, 11142 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, 11143 ArrayRef<Expr *> UnresolvedMappers = llvm::None); 11144 /// Called on well-formed 'use_device_ptr' clause. 11145 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList, 11146 const OMPVarListLocTy &Locs); 11147 /// Called on well-formed 'use_device_addr' clause. 11148 OMPClause *ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr *> VarList, 11149 const OMPVarListLocTy &Locs); 11150 /// Called on well-formed 'is_device_ptr' clause. 11151 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList, 11152 const OMPVarListLocTy &Locs); 11153 /// Called on well-formed 'nontemporal' clause. 11154 OMPClause *ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList, 11155 SourceLocation StartLoc, 11156 SourceLocation LParenLoc, 11157 SourceLocation EndLoc); 11158 11159 /// Data for list of allocators. 11160 struct UsesAllocatorsData { 11161 /// Allocator. 11162 Expr *Allocator = nullptr; 11163 /// Allocator traits. 11164 Expr *AllocatorTraits = nullptr; 11165 /// Locations of '(' and ')' symbols. 11166 SourceLocation LParenLoc, RParenLoc; 11167 }; 11168 /// Called on well-formed 'uses_allocators' clause. 11169 OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc, 11170 SourceLocation LParenLoc, 11171 SourceLocation EndLoc, 11172 ArrayRef<UsesAllocatorsData> Data); 11173 /// Called on well-formed 'affinity' clause. 11174 OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc, 11175 SourceLocation LParenLoc, 11176 SourceLocation ColonLoc, 11177 SourceLocation EndLoc, Expr *Modifier, 11178 ArrayRef<Expr *> Locators); 11179 11180 /// The kind of conversion being performed. 11181 enum CheckedConversionKind { 11182 /// An implicit conversion. 11183 CCK_ImplicitConversion, 11184 /// A C-style cast. 11185 CCK_CStyleCast, 11186 /// A functional-style cast. 11187 CCK_FunctionalCast, 11188 /// A cast other than a C-style cast. 11189 CCK_OtherCast, 11190 /// A conversion for an operand of a builtin overloaded operator. 11191 CCK_ForBuiltinOverloadedOp 11192 }; 11193 isCast(CheckedConversionKind CCK)11194 static bool isCast(CheckedConversionKind CCK) { 11195 return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast || 11196 CCK == CCK_OtherCast; 11197 } 11198 11199 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit 11200 /// cast. If there is already an implicit cast, merge into the existing one. 11201 /// If isLvalue, the result of the cast is an lvalue. 11202 ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, 11203 ExprValueKind VK = VK_RValue, 11204 const CXXCastPath *BasePath = nullptr, 11205 CheckedConversionKind CCK 11206 = CCK_ImplicitConversion); 11207 11208 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding 11209 /// to the conversion from scalar type ScalarTy to the Boolean type. 11210 static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy); 11211 11212 /// IgnoredValueConversions - Given that an expression's result is 11213 /// syntactically ignored, perform any conversions that are 11214 /// required. 11215 ExprResult IgnoredValueConversions(Expr *E); 11216 11217 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts 11218 // functions and arrays to their respective pointers (C99 6.3.2.1). 11219 ExprResult UsualUnaryConversions(Expr *E); 11220 11221 /// CallExprUnaryConversions - a special case of an unary conversion 11222 /// performed on a function designator of a call expression. 11223 ExprResult CallExprUnaryConversions(Expr *E); 11224 11225 // DefaultFunctionArrayConversion - converts functions and arrays 11226 // to their respective pointers (C99 6.3.2.1). 11227 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true); 11228 11229 // DefaultFunctionArrayLvalueConversion - converts functions and 11230 // arrays to their respective pointers and performs the 11231 // lvalue-to-rvalue conversion. 11232 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, 11233 bool Diagnose = true); 11234 11235 // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on 11236 // the operand. This function is a no-op if the operand has a function type 11237 // or an array type. 11238 ExprResult DefaultLvalueConversion(Expr *E); 11239 11240 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 11241 // do not have a prototype. Integer promotions are performed on each 11242 // argument, and arguments that have type float are promoted to double. 11243 ExprResult DefaultArgumentPromotion(Expr *E); 11244 11245 /// If \p E is a prvalue denoting an unmaterialized temporary, materialize 11246 /// it as an xvalue. In C++98, the result will still be a prvalue, because 11247 /// we don't have xvalues there. 11248 ExprResult TemporaryMaterializationConversion(Expr *E); 11249 11250 // Used for emitting the right warning by DefaultVariadicArgumentPromotion 11251 enum VariadicCallType { 11252 VariadicFunction, 11253 VariadicBlock, 11254 VariadicMethod, 11255 VariadicConstructor, 11256 VariadicDoesNotApply 11257 }; 11258 11259 VariadicCallType getVariadicCallType(FunctionDecl *FDecl, 11260 const FunctionProtoType *Proto, 11261 Expr *Fn); 11262 11263 // Used for determining in which context a type is allowed to be passed to a 11264 // vararg function. 11265 enum VarArgKind { 11266 VAK_Valid, 11267 VAK_ValidInCXX11, 11268 VAK_Undefined, 11269 VAK_MSVCUndefined, 11270 VAK_Invalid 11271 }; 11272 11273 // Determines which VarArgKind fits an expression. 11274 VarArgKind isValidVarArgType(const QualType &Ty); 11275 11276 /// Check to see if the given expression is a valid argument to a variadic 11277 /// function, issuing a diagnostic if not. 11278 void checkVariadicArgument(const Expr *E, VariadicCallType CT); 11279 11280 /// Check to see if a given expression could have '.c_str()' called on it. 11281 bool hasCStrMethod(const Expr *E); 11282 11283 /// GatherArgumentsForCall - Collector argument expressions for various 11284 /// form of call prototypes. 11285 bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, 11286 const FunctionProtoType *Proto, 11287 unsigned FirstParam, ArrayRef<Expr *> Args, 11288 SmallVectorImpl<Expr *> &AllArgs, 11289 VariadicCallType CallType = VariadicDoesNotApply, 11290 bool AllowExplicit = false, 11291 bool IsListInitialization = false); 11292 11293 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 11294 // will create a runtime trap if the resulting type is not a POD type. 11295 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 11296 FunctionDecl *FDecl); 11297 11298 /// Context in which we're performing a usual arithmetic conversion. 11299 enum ArithConvKind { 11300 /// An arithmetic operation. 11301 ACK_Arithmetic, 11302 /// A bitwise operation. 11303 ACK_BitwiseOp, 11304 /// A comparison. 11305 ACK_Comparison, 11306 /// A conditional (?:) operator. 11307 ACK_Conditional, 11308 /// A compound assignment expression. 11309 ACK_CompAssign, 11310 }; 11311 11312 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's 11313 // operands and then handles various conversions that are common to binary 11314 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this 11315 // routine returns the first non-arithmetic type found. The client is 11316 // responsible for emitting appropriate error diagnostics. 11317 QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 11318 SourceLocation Loc, ArithConvKind ACK); 11319 11320 /// AssignConvertType - All of the 'assignment' semantic checks return this 11321 /// enum to indicate whether the assignment was allowed. These checks are 11322 /// done for simple assignments, as well as initialization, return from 11323 /// function, argument passing, etc. The query is phrased in terms of a 11324 /// source and destination type. 11325 enum AssignConvertType { 11326 /// Compatible - the types are compatible according to the standard. 11327 Compatible, 11328 11329 /// PointerToInt - The assignment converts a pointer to an int, which we 11330 /// accept as an extension. 11331 PointerToInt, 11332 11333 /// IntToPointer - The assignment converts an int to a pointer, which we 11334 /// accept as an extension. 11335 IntToPointer, 11336 11337 /// FunctionVoidPointer - The assignment is between a function pointer and 11338 /// void*, which the standard doesn't allow, but we accept as an extension. 11339 FunctionVoidPointer, 11340 11341 /// IncompatiblePointer - The assignment is between two pointers types that 11342 /// are not compatible, but we accept them as an extension. 11343 IncompatiblePointer, 11344 11345 /// IncompatibleFunctionPointer - The assignment is between two function 11346 /// pointers types that are not compatible, but we accept them as an 11347 /// extension. 11348 IncompatibleFunctionPointer, 11349 11350 /// IncompatiblePointerSign - The assignment is between two pointers types 11351 /// which point to integers which have a different sign, but are otherwise 11352 /// identical. This is a subset of the above, but broken out because it's by 11353 /// far the most common case of incompatible pointers. 11354 IncompatiblePointerSign, 11355 11356 /// CompatiblePointerDiscardsQualifiers - The assignment discards 11357 /// c/v/r qualifiers, which we accept as an extension. 11358 CompatiblePointerDiscardsQualifiers, 11359 11360 /// IncompatiblePointerDiscardsQualifiers - The assignment 11361 /// discards qualifiers that we don't permit to be discarded, 11362 /// like address spaces. 11363 IncompatiblePointerDiscardsQualifiers, 11364 11365 /// IncompatibleNestedPointerAddressSpaceMismatch - The assignment 11366 /// changes address spaces in nested pointer types which is not allowed. 11367 /// For instance, converting __private int ** to __generic int ** is 11368 /// illegal even though __private could be converted to __generic. 11369 IncompatibleNestedPointerAddressSpaceMismatch, 11370 11371 /// IncompatibleNestedPointerQualifiers - The assignment is between two 11372 /// nested pointer types, and the qualifiers other than the first two 11373 /// levels differ e.g. char ** -> const char **, but we accept them as an 11374 /// extension. 11375 IncompatibleNestedPointerQualifiers, 11376 11377 /// IncompatibleVectors - The assignment is between two vector types that 11378 /// have the same size, which we accept as an extension. 11379 IncompatibleVectors, 11380 11381 /// IntToBlockPointer - The assignment converts an int to a block 11382 /// pointer. We disallow this. 11383 IntToBlockPointer, 11384 11385 /// IncompatibleBlockPointer - The assignment is between two block 11386 /// pointers types that are not compatible. 11387 IncompatibleBlockPointer, 11388 11389 /// IncompatibleObjCQualifiedId - The assignment is between a qualified 11390 /// id type and something else (that is incompatible with it). For example, 11391 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol. 11392 IncompatibleObjCQualifiedId, 11393 11394 /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an 11395 /// object with __weak qualifier. 11396 IncompatibleObjCWeakRef, 11397 11398 /// Incompatible - We reject this conversion outright, it is invalid to 11399 /// represent it in the AST. 11400 Incompatible 11401 }; 11402 11403 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the 11404 /// assignment conversion type specified by ConvTy. This returns true if the 11405 /// conversion was invalid or false if the conversion was accepted. 11406 bool DiagnoseAssignmentResult(AssignConvertType ConvTy, 11407 SourceLocation Loc, 11408 QualType DstType, QualType SrcType, 11409 Expr *SrcExpr, AssignmentAction Action, 11410 bool *Complained = nullptr); 11411 11412 /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag 11413 /// enum. If AllowMask is true, then we also allow the complement of a valid 11414 /// value, to be used as a mask. 11415 bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, 11416 bool AllowMask) const; 11417 11418 /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant 11419 /// integer not in the range of enum values. 11420 void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, 11421 Expr *SrcExpr); 11422 11423 /// CheckAssignmentConstraints - Perform type checking for assignment, 11424 /// argument passing, variable initialization, and function return values. 11425 /// C99 6.5.16. 11426 AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, 11427 QualType LHSType, 11428 QualType RHSType); 11429 11430 /// Check assignment constraints and optionally prepare for a conversion of 11431 /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS 11432 /// is true. 11433 AssignConvertType CheckAssignmentConstraints(QualType LHSType, 11434 ExprResult &RHS, 11435 CastKind &Kind, 11436 bool ConvertRHS = true); 11437 11438 /// Check assignment constraints for an assignment of RHS to LHSType. 11439 /// 11440 /// \param LHSType The destination type for the assignment. 11441 /// \param RHS The source expression for the assignment. 11442 /// \param Diagnose If \c true, diagnostics may be produced when checking 11443 /// for assignability. If a diagnostic is produced, \p RHS will be 11444 /// set to ExprError(). Note that this function may still return 11445 /// without producing a diagnostic, even for an invalid assignment. 11446 /// \param DiagnoseCFAudited If \c true, the target is a function parameter 11447 /// in an audited Core Foundation API and does not need to be checked 11448 /// for ARC retain issues. 11449 /// \param ConvertRHS If \c true, \p RHS will be updated to model the 11450 /// conversions necessary to perform the assignment. If \c false, 11451 /// \p Diagnose must also be \c false. 11452 AssignConvertType CheckSingleAssignmentConstraints( 11453 QualType LHSType, ExprResult &RHS, bool Diagnose = true, 11454 bool DiagnoseCFAudited = false, bool ConvertRHS = true); 11455 11456 // If the lhs type is a transparent union, check whether we 11457 // can initialize the transparent union with the given expression. 11458 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, 11459 ExprResult &RHS); 11460 11461 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType); 11462 11463 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType); 11464 11465 ExprResult PerformImplicitConversion(Expr *From, QualType ToType, 11466 AssignmentAction Action, 11467 bool AllowExplicit = false); 11468 ExprResult PerformImplicitConversion(Expr *From, QualType ToType, 11469 const ImplicitConversionSequence& ICS, 11470 AssignmentAction Action, 11471 CheckedConversionKind CCK 11472 = CCK_ImplicitConversion); 11473 ExprResult PerformImplicitConversion(Expr *From, QualType ToType, 11474 const StandardConversionSequence& SCS, 11475 AssignmentAction Action, 11476 CheckedConversionKind CCK); 11477 11478 ExprResult PerformQualificationConversion( 11479 Expr *E, QualType Ty, ExprValueKind VK = VK_RValue, 11480 CheckedConversionKind CCK = CCK_ImplicitConversion); 11481 11482 /// the following "Check" methods will return a valid/converted QualType 11483 /// or a null QualType (indicating an error diagnostic was issued). 11484 11485 /// type checking binary operators (subroutines of CreateBuiltinBinOp). 11486 QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, 11487 ExprResult &RHS); 11488 QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS, 11489 ExprResult &RHS); 11490 QualType CheckPointerToMemberOperands( // C++ 5.5 11491 ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, 11492 SourceLocation OpLoc, bool isIndirect); 11493 QualType CheckMultiplyDivideOperands( // C99 6.5.5 11494 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, 11495 bool IsDivide); 11496 QualType CheckRemainderOperands( // C99 6.5.5 11497 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11498 bool IsCompAssign = false); 11499 QualType CheckAdditionOperands( // C99 6.5.6 11500 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11501 BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr); 11502 QualType CheckSubtractionOperands( // C99 6.5.6 11503 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11504 QualType* CompLHSTy = nullptr); 11505 QualType CheckShiftOperands( // C99 6.5.7 11506 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11507 BinaryOperatorKind Opc, bool IsCompAssign = false); 11508 void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE); 11509 QualType CheckCompareOperands( // C99 6.5.8/9 11510 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11511 BinaryOperatorKind Opc); 11512 QualType CheckBitwiseOperands( // C99 6.5.[10...12] 11513 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11514 BinaryOperatorKind Opc); 11515 QualType CheckLogicalOperands( // C99 6.5.[13,14] 11516 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11517 BinaryOperatorKind Opc); 11518 // CheckAssignmentOperands is used for both simple and compound assignment. 11519 // For simple assignment, pass both expressions and a null converted type. 11520 // For compound assignment, pass both expressions and the converted type. 11521 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2] 11522 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType); 11523 11524 ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc, 11525 UnaryOperatorKind Opcode, Expr *Op); 11526 ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc, 11527 BinaryOperatorKind Opcode, 11528 Expr *LHS, Expr *RHS); 11529 ExprResult checkPseudoObjectRValue(Expr *E); 11530 Expr *recreateSyntacticForm(PseudoObjectExpr *E); 11531 11532 QualType CheckConditionalOperands( // C99 6.5.15 11533 ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, 11534 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc); 11535 QualType CXXCheckConditionalOperands( // C++ 5.16 11536 ExprResult &cond, ExprResult &lhs, ExprResult &rhs, 11537 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc); 11538 QualType CheckGNUVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, 11539 ExprResult &RHS, 11540 SourceLocation QuestionLoc); 11541 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, 11542 bool ConvertArgs = true); 11543 QualType FindCompositePointerType(SourceLocation Loc, 11544 ExprResult &E1, ExprResult &E2, 11545 bool ConvertArgs = true) { 11546 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get(); 11547 QualType Composite = 11548 FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs); 11549 E1 = E1Tmp; 11550 E2 = E2Tmp; 11551 return Composite; 11552 } 11553 11554 QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 11555 SourceLocation QuestionLoc); 11556 11557 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 11558 SourceLocation QuestionLoc); 11559 11560 void DiagnoseAlwaysNonNullPointer(Expr *E, 11561 Expr::NullPointerConstantKind NullType, 11562 bool IsEqual, SourceRange Range); 11563 11564 /// type checking for vector binary operators. 11565 QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 11566 SourceLocation Loc, bool IsCompAssign, 11567 bool AllowBothBool, bool AllowBoolConversion); 11568 QualType GetSignedVectorType(QualType V); 11569 QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 11570 SourceLocation Loc, 11571 BinaryOperatorKind Opc); 11572 QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 11573 SourceLocation Loc); 11574 11575 /// Type checking for matrix binary operators. 11576 QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS, 11577 SourceLocation Loc, 11578 bool IsCompAssign); 11579 QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS, 11580 SourceLocation Loc, bool IsCompAssign); 11581 11582 bool isValidSveBitcast(QualType srcType, QualType destType); 11583 11584 bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType); 11585 bool isLaxVectorConversion(QualType srcType, QualType destType); 11586 11587 /// type checking declaration initializers (C99 6.7.8) 11588 bool CheckForConstantInitializer(Expr *e, QualType t); 11589 11590 // type checking C++ declaration initializers (C++ [dcl.init]). 11591 11592 /// ReferenceCompareResult - Expresses the result of comparing two 11593 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the 11594 /// purposes of initialization by reference (C++ [dcl.init.ref]p4). 11595 enum ReferenceCompareResult { 11596 /// Ref_Incompatible - The two types are incompatible, so direct 11597 /// reference binding is not possible. 11598 Ref_Incompatible = 0, 11599 /// Ref_Related - The two types are reference-related, which means 11600 /// that their unqualified forms (T1 and T2) are either the same 11601 /// or T1 is a base class of T2. 11602 Ref_Related, 11603 /// Ref_Compatible - The two types are reference-compatible. 11604 Ref_Compatible 11605 }; 11606 11607 // Fake up a scoped enumeration that still contextually converts to bool. 11608 struct ReferenceConversionsScope { 11609 /// The conversions that would be performed on an lvalue of type T2 when 11610 /// binding a reference of type T1 to it, as determined when evaluating 11611 /// whether T1 is reference-compatible with T2. 11612 enum ReferenceConversions { 11613 Qualification = 0x1, 11614 NestedQualification = 0x2, 11615 Function = 0x4, 11616 DerivedToBase = 0x8, 11617 ObjC = 0x10, 11618 ObjCLifetime = 0x20, 11619 11620 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ObjCLifetime) 11621 }; 11622 }; 11623 using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions; 11624 11625 ReferenceCompareResult 11626 CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, 11627 ReferenceConversions *Conv = nullptr); 11628 11629 ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, 11630 Expr *CastExpr, CastKind &CastKind, 11631 ExprValueKind &VK, CXXCastPath &Path); 11632 11633 /// Force an expression with unknown-type to an expression of the 11634 /// given type. 11635 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType); 11636 11637 /// Type-check an expression that's being passed to an 11638 /// __unknown_anytype parameter. 11639 ExprResult checkUnknownAnyArg(SourceLocation callLoc, 11640 Expr *result, QualType ¶mType); 11641 11642 // CheckVectorCast - check type constraints for vectors. 11643 // Since vectors are an extension, there are no C standard reference for this. 11644 // We allow casting between vectors and integer datatypes of the same size. 11645 // returns true if the cast is invalid 11646 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 11647 CastKind &Kind); 11648 11649 /// Prepare `SplattedExpr` for a vector splat operation, adding 11650 /// implicit casts if necessary. 11651 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr); 11652 11653 // CheckExtVectorCast - check type constraints for extended vectors. 11654 // Since vectors are an extension, there are no C standard reference for this. 11655 // We allow casting between vectors and integer datatypes of the same size, 11656 // or vectors and the element type of that vector. 11657 // returns the cast expr 11658 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, 11659 CastKind &Kind); 11660 11661 ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, 11662 SourceLocation LParenLoc, 11663 Expr *CastExpr, 11664 SourceLocation RParenLoc); 11665 11666 enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error }; 11667 11668 /// Checks for invalid conversions and casts between 11669 /// retainable pointers and other pointer kinds for ARC and Weak. 11670 ARCConversionResult CheckObjCConversion(SourceRange castRange, 11671 QualType castType, Expr *&op, 11672 CheckedConversionKind CCK, 11673 bool Diagnose = true, 11674 bool DiagnoseCFAudited = false, 11675 BinaryOperatorKind Opc = BO_PtrMemD 11676 ); 11677 11678 Expr *stripARCUnbridgedCast(Expr *e); 11679 void diagnoseARCUnbridgedCast(Expr *e); 11680 11681 bool CheckObjCARCUnavailableWeakConversion(QualType castType, 11682 QualType ExprType); 11683 11684 /// checkRetainCycles - Check whether an Objective-C message send 11685 /// might create an obvious retain cycle. 11686 void checkRetainCycles(ObjCMessageExpr *msg); 11687 void checkRetainCycles(Expr *receiver, Expr *argument); 11688 void checkRetainCycles(VarDecl *Var, Expr *Init); 11689 11690 /// checkUnsafeAssigns - Check whether +1 expr is being assigned 11691 /// to weak/__unsafe_unretained type. 11692 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS); 11693 11694 /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned 11695 /// to weak/__unsafe_unretained expression. 11696 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS); 11697 11698 /// CheckMessageArgumentTypes - Check types in an Obj-C message send. 11699 /// \param Method - May be null. 11700 /// \param [out] ReturnType - The return type of the send. 11701 /// \return true iff there were any incompatible types. 11702 bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType, 11703 MultiExprArg Args, Selector Sel, 11704 ArrayRef<SourceLocation> SelectorLocs, 11705 ObjCMethodDecl *Method, bool isClassMessage, 11706 bool isSuperMessage, SourceLocation lbrac, 11707 SourceLocation rbrac, SourceRange RecRange, 11708 QualType &ReturnType, ExprValueKind &VK); 11709 11710 /// Determine the result of a message send expression based on 11711 /// the type of the receiver, the method expected to receive the message, 11712 /// and the form of the message send. 11713 QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType, 11714 ObjCMethodDecl *Method, bool isClassMessage, 11715 bool isSuperMessage); 11716 11717 /// If the given expression involves a message send to a method 11718 /// with a related result type, emit a note describing what happened. 11719 void EmitRelatedResultTypeNote(const Expr *E); 11720 11721 /// Given that we had incompatible pointer types in a return 11722 /// statement, check whether we're in a method with a related result 11723 /// type, and if so, emit a note describing what happened. 11724 void EmitRelatedResultTypeNoteForReturn(QualType destType); 11725 11726 class ConditionResult { 11727 Decl *ConditionVar; 11728 FullExprArg Condition; 11729 bool Invalid; 11730 bool HasKnownValue; 11731 bool KnownValue; 11732 11733 friend class Sema; ConditionResult(Sema & S,Decl * ConditionVar,FullExprArg Condition,bool IsConstexpr)11734 ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition, 11735 bool IsConstexpr) 11736 : ConditionVar(ConditionVar), Condition(Condition), Invalid(false), 11737 HasKnownValue(IsConstexpr && Condition.get() && 11738 !Condition.get()->isValueDependent()), 11739 KnownValue(HasKnownValue && 11740 !!Condition.get()->EvaluateKnownConstInt(S.Context)) {} ConditionResult(bool Invalid)11741 explicit ConditionResult(bool Invalid) 11742 : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid), 11743 HasKnownValue(false), KnownValue(false) {} 11744 11745 public: ConditionResult()11746 ConditionResult() : ConditionResult(false) {} isInvalid()11747 bool isInvalid() const { return Invalid; } get()11748 std::pair<VarDecl *, Expr *> get() const { 11749 return std::make_pair(cast_or_null<VarDecl>(ConditionVar), 11750 Condition.get()); 11751 } getKnownValue()11752 llvm::Optional<bool> getKnownValue() const { 11753 if (!HasKnownValue) 11754 return None; 11755 return KnownValue; 11756 } 11757 }; ConditionError()11758 static ConditionResult ConditionError() { return ConditionResult(true); } 11759 11760 enum class ConditionKind { 11761 Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'. 11762 ConstexprIf, ///< A constant boolean condition from 'if constexpr'. 11763 Switch ///< An integral condition for a 'switch' statement. 11764 }; 11765 11766 ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, 11767 Expr *SubExpr, ConditionKind CK); 11768 11769 ConditionResult ActOnConditionVariable(Decl *ConditionVar, 11770 SourceLocation StmtLoc, 11771 ConditionKind CK); 11772 11773 DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D); 11774 11775 ExprResult CheckConditionVariable(VarDecl *ConditionVar, 11776 SourceLocation StmtLoc, 11777 ConditionKind CK); 11778 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond); 11779 11780 /// CheckBooleanCondition - Diagnose problems involving the use of 11781 /// the given expression as a boolean condition (e.g. in an if 11782 /// statement). Also performs the standard function and array 11783 /// decays, possibly changing the input variable. 11784 /// 11785 /// \param Loc - A location associated with the condition, e.g. the 11786 /// 'if' keyword. 11787 /// \return true iff there were any errors 11788 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, 11789 bool IsConstexpr = false); 11790 11791 /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression 11792 /// found in an explicit(bool) specifier. 11793 ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E); 11794 11795 /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier. 11796 /// Returns true if the explicit specifier is now resolved. 11797 bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec); 11798 11799 /// DiagnoseAssignmentAsCondition - Given that an expression is 11800 /// being used as a boolean condition, warn if it's an assignment. 11801 void DiagnoseAssignmentAsCondition(Expr *E); 11802 11803 /// Redundant parentheses over an equality comparison can indicate 11804 /// that the user intended an assignment used as condition. 11805 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE); 11806 11807 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid. 11808 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false); 11809 11810 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have 11811 /// the specified width and sign. If an overflow occurs, detect it and emit 11812 /// the specified diagnostic. 11813 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal, 11814 unsigned NewWidth, bool NewSign, 11815 SourceLocation Loc, unsigned DiagID); 11816 11817 /// Checks that the Objective-C declaration is declared in the global scope. 11818 /// Emits an error and marks the declaration as invalid if it's not declared 11819 /// in the global scope. 11820 bool CheckObjCDeclScope(Decl *D); 11821 11822 /// Abstract base class used for diagnosing integer constant 11823 /// expression violations. 11824 class VerifyICEDiagnoser { 11825 public: 11826 bool Suppress; 11827 Suppress(Suppress)11828 VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { } 11829 11830 virtual SemaDiagnosticBuilder 11831 diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T); 11832 virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S, 11833 SourceLocation Loc) = 0; 11834 virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc); ~VerifyICEDiagnoser()11835 virtual ~VerifyICEDiagnoser() {} 11836 }; 11837 11838 enum AllowFoldKind { 11839 NoFold, 11840 AllowFold, 11841 }; 11842 11843 /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE, 11844 /// and reports the appropriate diagnostics. Returns false on success. 11845 /// Can optionally return the value of the expression. 11846 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 11847 VerifyICEDiagnoser &Diagnoser, 11848 AllowFoldKind CanFold = NoFold); 11849 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 11850 unsigned DiagID, 11851 AllowFoldKind CanFold = NoFold); 11852 ExprResult VerifyIntegerConstantExpression(Expr *E, 11853 llvm::APSInt *Result = nullptr, 11854 AllowFoldKind CanFold = NoFold); 11855 ExprResult VerifyIntegerConstantExpression(Expr *E, 11856 AllowFoldKind CanFold = NoFold) { 11857 return VerifyIntegerConstantExpression(E, nullptr, CanFold); 11858 } 11859 11860 /// VerifyBitField - verifies that a bit field expression is an ICE and has 11861 /// the correct width, and that the field type is valid. 11862 /// Returns false on success. 11863 /// Can optionally return whether the bit-field is of width 0 11864 ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, 11865 QualType FieldTy, bool IsMsStruct, 11866 Expr *BitWidth, bool *ZeroWidth = nullptr); 11867 11868 private: 11869 unsigned ForceCUDAHostDeviceDepth = 0; 11870 11871 public: 11872 /// Increments our count of the number of times we've seen a pragma forcing 11873 /// functions to be __host__ __device__. So long as this count is greater 11874 /// than zero, all functions encountered will be __host__ __device__. 11875 void PushForceCUDAHostDevice(); 11876 11877 /// Decrements our count of the number of times we've seen a pragma forcing 11878 /// functions to be __host__ __device__. Returns false if the count is 0 11879 /// before incrementing, so you can emit an error. 11880 bool PopForceCUDAHostDevice(); 11881 11882 /// Diagnostics that are emitted only if we discover that the given function 11883 /// must be codegen'ed. Because handling these correctly adds overhead to 11884 /// compilation, this is currently only enabled for CUDA compilations. 11885 llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>, 11886 std::vector<PartialDiagnosticAt>> 11887 DeviceDeferredDiags; 11888 11889 /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the 11890 /// key in a hashtable, both the FD and location are hashed. 11891 struct FunctionDeclAndLoc { 11892 CanonicalDeclPtr<FunctionDecl> FD; 11893 SourceLocation Loc; 11894 }; 11895 11896 /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a 11897 /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the 11898 /// same deferred diag twice. 11899 llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags; 11900 11901 /// An inverse call graph, mapping known-emitted functions to one of their 11902 /// known-emitted callers (plus the location of the call). 11903 /// 11904 /// Functions that we can tell a priori must be emitted aren't added to this 11905 /// map. 11906 llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>, 11907 /* Caller = */ FunctionDeclAndLoc> 11908 DeviceKnownEmittedFns; 11909 11910 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 11911 /// context is "used as device code". 11912 /// 11913 /// - If CurContext is a __host__ function, does not emit any diagnostics 11914 /// unless \p EmitOnBothSides is true. 11915 /// - If CurContext is a __device__ or __global__ function, emits the 11916 /// diagnostics immediately. 11917 /// - If CurContext is a __host__ __device__ function and we are compiling for 11918 /// the device, creates a diagnostic which is emitted if and when we realize 11919 /// that the function will be codegen'ed. 11920 /// 11921 /// Example usage: 11922 /// 11923 /// // Variable-length arrays are not allowed in CUDA device code. 11924 /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget()) 11925 /// return ExprError(); 11926 /// // Otherwise, continue parsing as normal. 11927 SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc, 11928 unsigned DiagID); 11929 11930 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 11931 /// context is "used as host code". 11932 /// 11933 /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched. 11934 SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID); 11935 11936 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 11937 /// context is "used as device code". 11938 /// 11939 /// - If CurContext is a `declare target` function or it is known that the 11940 /// function is emitted for the device, emits the diagnostics immediately. 11941 /// - If CurContext is a non-`declare target` function and we are compiling 11942 /// for the device, creates a diagnostic which is emitted if and when we 11943 /// realize that the function will be codegen'ed. 11944 /// 11945 /// Example usage: 11946 /// 11947 /// // Variable-length arrays are not allowed in NVPTX device code. 11948 /// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported)) 11949 /// return ExprError(); 11950 /// // Otherwise, continue parsing as normal. 11951 SemaDiagnosticBuilder 11952 diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD); 11953 11954 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 11955 /// context is "used as host code". 11956 /// 11957 /// - If CurContext is a `declare target` function or it is known that the 11958 /// function is emitted for the host, emits the diagnostics immediately. 11959 /// - If CurContext is a non-host function, just ignore it. 11960 /// 11961 /// Example usage: 11962 /// 11963 /// // Variable-length arrays are not allowed in NVPTX device code. 11964 /// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported)) 11965 /// return ExprError(); 11966 /// // Otherwise, continue parsing as normal. 11967 SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc, 11968 unsigned DiagID, FunctionDecl *FD); 11969 11970 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, 11971 FunctionDecl *FD = nullptr); 11972 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, 11973 const PartialDiagnostic &PD, 11974 FunctionDecl *FD = nullptr) { 11975 return targetDiag(Loc, PD.getDiagID(), FD) << PD; 11976 } 11977 11978 /// Check if the expression is allowed to be used in expressions for the 11979 /// offloading devices. 11980 void checkDeviceDecl(ValueDecl *D, SourceLocation Loc); 11981 11982 enum CUDAFunctionTarget { 11983 CFT_Device, 11984 CFT_Global, 11985 CFT_Host, 11986 CFT_HostDevice, 11987 CFT_InvalidTarget 11988 }; 11989 11990 /// Determines whether the given function is a CUDA device/host/kernel/etc. 11991 /// function. 11992 /// 11993 /// Use this rather than examining the function's attributes yourself -- you 11994 /// will get it wrong. Returns CFT_Host if D is null. 11995 CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, 11996 bool IgnoreImplicitHDAttr = false); 11997 CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs); 11998 11999 /// Gets the CUDA target for the current context. CurrentCUDATarget()12000 CUDAFunctionTarget CurrentCUDATarget() { 12001 return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext)); 12002 } 12003 12004 static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D); 12005 12006 // CUDA function call preference. Must be ordered numerically from 12007 // worst to best. 12008 enum CUDAFunctionPreference { 12009 CFP_Never, // Invalid caller/callee combination. 12010 CFP_WrongSide, // Calls from host-device to host or device 12011 // function that do not match current compilation 12012 // mode. 12013 CFP_HostDevice, // Any calls to host/device functions. 12014 CFP_SameSide, // Calls from host-device to host or device 12015 // function matching current compilation mode. 12016 CFP_Native, // host-to-host or device-to-device calls. 12017 }; 12018 12019 /// Identifies relative preference of a given Caller/Callee 12020 /// combination, based on their host/device attributes. 12021 /// \param Caller function which needs address of \p Callee. 12022 /// nullptr in case of global context. 12023 /// \param Callee target function 12024 /// 12025 /// \returns preference value for particular Caller/Callee combination. 12026 CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller, 12027 const FunctionDecl *Callee); 12028 12029 /// Determines whether Caller may invoke Callee, based on their CUDA 12030 /// host/device attributes. Returns false if the call is not allowed. 12031 /// 12032 /// Note: Will return true for CFP_WrongSide calls. These may appear in 12033 /// semantically correct CUDA programs, but only if they're never codegen'ed. IsAllowedCUDACall(const FunctionDecl * Caller,const FunctionDecl * Callee)12034 bool IsAllowedCUDACall(const FunctionDecl *Caller, 12035 const FunctionDecl *Callee) { 12036 return IdentifyCUDAPreference(Caller, Callee) != CFP_Never; 12037 } 12038 12039 /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, 12040 /// depending on FD and the current compilation settings. 12041 void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD, 12042 const LookupResult &Previous); 12043 12044 /// May add implicit CUDAConstantAttr attribute to VD, depending on VD 12045 /// and current compilation settings. 12046 void MaybeAddCUDAConstantAttr(VarDecl *VD); 12047 12048 public: 12049 /// Check whether we're allowed to call Callee from the current context. 12050 /// 12051 /// - If the call is never allowed in a semantically-correct program 12052 /// (CFP_Never), emits an error and returns false. 12053 /// 12054 /// - If the call is allowed in semantically-correct programs, but only if 12055 /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to 12056 /// be emitted if and when the caller is codegen'ed, and returns true. 12057 /// 12058 /// Will only create deferred diagnostics for a given SourceLocation once, 12059 /// so you can safely call this multiple times without generating duplicate 12060 /// deferred errors. 12061 /// 12062 /// - Otherwise, returns true without emitting any diagnostics. 12063 bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee); 12064 12065 void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture); 12066 12067 /// Set __device__ or __host__ __device__ attributes on the given lambda 12068 /// operator() method. 12069 /// 12070 /// CUDA lambdas by default is host device function unless it has explicit 12071 /// host or device attribute. 12072 void CUDASetLambdaAttrs(CXXMethodDecl *Method); 12073 12074 /// Finds a function in \p Matches with highest calling priority 12075 /// from \p Caller context and erases all functions with lower 12076 /// calling priority. 12077 void EraseUnwantedCUDAMatches( 12078 const FunctionDecl *Caller, 12079 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches); 12080 12081 /// Given a implicit special member, infer its CUDA target from the 12082 /// calls it needs to make to underlying base/field special members. 12083 /// \param ClassDecl the class for which the member is being created. 12084 /// \param CSM the kind of special member. 12085 /// \param MemberDecl the special member itself. 12086 /// \param ConstRHS true if this is a copy operation with a const object on 12087 /// its RHS. 12088 /// \param Diagnose true if this call should emit diagnostics. 12089 /// \return true if there was an error inferring. 12090 /// The result of this call is implicit CUDA target attribute(s) attached to 12091 /// the member declaration. 12092 bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, 12093 CXXSpecialMember CSM, 12094 CXXMethodDecl *MemberDecl, 12095 bool ConstRHS, 12096 bool Diagnose); 12097 12098 /// \return true if \p CD can be considered empty according to CUDA 12099 /// (E.2.3.1 in CUDA 7.5 Programming guide). 12100 bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD); 12101 bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD); 12102 12103 // \brief Checks that initializers of \p Var satisfy CUDA restrictions. In 12104 // case of error emits appropriate diagnostic and invalidates \p Var. 12105 // 12106 // \details CUDA allows only empty constructors as initializers for global 12107 // variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all 12108 // __shared__ variables whether they are local or not (they all are implicitly 12109 // static in CUDA). One exception is that CUDA allows constant initializers 12110 // for __constant__ and __device__ variables. 12111 void checkAllowedCUDAInitializer(VarDecl *VD); 12112 12113 /// Check whether NewFD is a valid overload for CUDA. Emits 12114 /// diagnostics and invalidates NewFD if not. 12115 void checkCUDATargetOverload(FunctionDecl *NewFD, 12116 const LookupResult &Previous); 12117 /// Copies target attributes from the template TD to the function FD. 12118 void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD); 12119 12120 /// Returns the name of the launch configuration function. This is the name 12121 /// of the function that will be called to configure kernel call, with the 12122 /// parameters specified via <<<>>>. 12123 std::string getCudaConfigureFuncName() const; 12124 12125 /// \name Code completion 12126 //@{ 12127 /// Describes the context in which code completion occurs. 12128 enum ParserCompletionContext { 12129 /// Code completion occurs at top-level or namespace context. 12130 PCC_Namespace, 12131 /// Code completion occurs within a class, struct, or union. 12132 PCC_Class, 12133 /// Code completion occurs within an Objective-C interface, protocol, 12134 /// or category. 12135 PCC_ObjCInterface, 12136 /// Code completion occurs within an Objective-C implementation or 12137 /// category implementation 12138 PCC_ObjCImplementation, 12139 /// Code completion occurs within the list of instance variables 12140 /// in an Objective-C interface, protocol, category, or implementation. 12141 PCC_ObjCInstanceVariableList, 12142 /// Code completion occurs following one or more template 12143 /// headers. 12144 PCC_Template, 12145 /// Code completion occurs following one or more template 12146 /// headers within a class. 12147 PCC_MemberTemplate, 12148 /// Code completion occurs within an expression. 12149 PCC_Expression, 12150 /// Code completion occurs within a statement, which may 12151 /// also be an expression or a declaration. 12152 PCC_Statement, 12153 /// Code completion occurs at the beginning of the 12154 /// initialization statement (or expression) in a for loop. 12155 PCC_ForInit, 12156 /// Code completion occurs within the condition of an if, 12157 /// while, switch, or for statement. 12158 PCC_Condition, 12159 /// Code completion occurs within the body of a function on a 12160 /// recovery path, where we do not have a specific handle on our position 12161 /// in the grammar. 12162 PCC_RecoveryInFunction, 12163 /// Code completion occurs where only a type is permitted. 12164 PCC_Type, 12165 /// Code completion occurs in a parenthesized expression, which 12166 /// might also be a type cast. 12167 PCC_ParenthesizedExpression, 12168 /// Code completion occurs within a sequence of declaration 12169 /// specifiers within a function, method, or block. 12170 PCC_LocalDeclarationSpecifiers 12171 }; 12172 12173 void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path); 12174 void CodeCompleteOrdinaryName(Scope *S, 12175 ParserCompletionContext CompletionContext); 12176 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, 12177 bool AllowNonIdentifiers, 12178 bool AllowNestedNameSpecifiers); 12179 12180 struct CodeCompleteExpressionData; 12181 void CodeCompleteExpression(Scope *S, 12182 const CodeCompleteExpressionData &Data); 12183 void CodeCompleteExpression(Scope *S, QualType PreferredType, 12184 bool IsParenthesized = false); 12185 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase, 12186 SourceLocation OpLoc, bool IsArrow, 12187 bool IsBaseExprStatement, 12188 QualType PreferredType); 12189 void CodeCompletePostfixExpression(Scope *S, ExprResult LHS, 12190 QualType PreferredType); 12191 void CodeCompleteTag(Scope *S, unsigned TagSpec); 12192 void CodeCompleteTypeQualifiers(DeclSpec &DS); 12193 void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D, 12194 const VirtSpecifiers *VS = nullptr); 12195 void CodeCompleteBracketDeclarator(Scope *S); 12196 void CodeCompleteCase(Scope *S); 12197 /// Reports signatures for a call to CodeCompleteConsumer and returns the 12198 /// preferred type for the current argument. Returned type can be null. 12199 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args, 12200 SourceLocation OpenParLoc); 12201 QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type, 12202 SourceLocation Loc, 12203 ArrayRef<Expr *> Args, 12204 SourceLocation OpenParLoc); 12205 QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl, 12206 CXXScopeSpec SS, 12207 ParsedType TemplateTypeTy, 12208 ArrayRef<Expr *> ArgExprs, 12209 IdentifierInfo *II, 12210 SourceLocation OpenParLoc); 12211 void CodeCompleteInitializer(Scope *S, Decl *D); 12212 /// Trigger code completion for a record of \p BaseType. \p InitExprs are 12213 /// expressions in the initializer list seen so far and \p D is the current 12214 /// Designation being parsed. 12215 void CodeCompleteDesignator(const QualType BaseType, 12216 llvm::ArrayRef<Expr *> InitExprs, 12217 const Designation &D); 12218 void CodeCompleteAfterIf(Scope *S, bool IsBracedThen); 12219 12220 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext, 12221 bool IsUsingDeclaration, QualType BaseType, 12222 QualType PreferredType); 12223 void CodeCompleteUsing(Scope *S); 12224 void CodeCompleteUsingDirective(Scope *S); 12225 void CodeCompleteNamespaceDecl(Scope *S); 12226 void CodeCompleteNamespaceAliasDecl(Scope *S); 12227 void CodeCompleteOperatorName(Scope *S); 12228 void CodeCompleteConstructorInitializer( 12229 Decl *Constructor, 12230 ArrayRef<CXXCtorInitializer *> Initializers); 12231 12232 void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, 12233 bool AfterAmpersand); 12234 void CodeCompleteAfterFunctionEquals(Declarator &D); 12235 12236 void CodeCompleteObjCAtDirective(Scope *S); 12237 void CodeCompleteObjCAtVisibility(Scope *S); 12238 void CodeCompleteObjCAtStatement(Scope *S); 12239 void CodeCompleteObjCAtExpression(Scope *S); 12240 void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS); 12241 void CodeCompleteObjCPropertyGetter(Scope *S); 12242 void CodeCompleteObjCPropertySetter(Scope *S); 12243 void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, 12244 bool IsParameter); 12245 void CodeCompleteObjCMessageReceiver(Scope *S); 12246 void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, 12247 ArrayRef<IdentifierInfo *> SelIdents, 12248 bool AtArgumentExpression); 12249 void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, 12250 ArrayRef<IdentifierInfo *> SelIdents, 12251 bool AtArgumentExpression, 12252 bool IsSuper = false); 12253 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver, 12254 ArrayRef<IdentifierInfo *> SelIdents, 12255 bool AtArgumentExpression, 12256 ObjCInterfaceDecl *Super = nullptr); 12257 void CodeCompleteObjCForCollection(Scope *S, 12258 DeclGroupPtrTy IterationVar); 12259 void CodeCompleteObjCSelector(Scope *S, 12260 ArrayRef<IdentifierInfo *> SelIdents); 12261 void CodeCompleteObjCProtocolReferences( 12262 ArrayRef<IdentifierLocPair> Protocols); 12263 void CodeCompleteObjCProtocolDecl(Scope *S); 12264 void CodeCompleteObjCInterfaceDecl(Scope *S); 12265 void CodeCompleteObjCSuperclass(Scope *S, 12266 IdentifierInfo *ClassName, 12267 SourceLocation ClassNameLoc); 12268 void CodeCompleteObjCImplementationDecl(Scope *S); 12269 void CodeCompleteObjCInterfaceCategory(Scope *S, 12270 IdentifierInfo *ClassName, 12271 SourceLocation ClassNameLoc); 12272 void CodeCompleteObjCImplementationCategory(Scope *S, 12273 IdentifierInfo *ClassName, 12274 SourceLocation ClassNameLoc); 12275 void CodeCompleteObjCPropertyDefinition(Scope *S); 12276 void CodeCompleteObjCPropertySynthesizeIvar(Scope *S, 12277 IdentifierInfo *PropertyName); 12278 void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod, 12279 ParsedType ReturnType); 12280 void CodeCompleteObjCMethodDeclSelector(Scope *S, 12281 bool IsInstanceMethod, 12282 bool AtParameterName, 12283 ParsedType ReturnType, 12284 ArrayRef<IdentifierInfo *> SelIdents); 12285 void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName, 12286 SourceLocation ClassNameLoc, 12287 bool IsBaseExprStatement); 12288 void CodeCompletePreprocessorDirective(bool InConditional); 12289 void CodeCompleteInPreprocessorConditionalExclusion(Scope *S); 12290 void CodeCompletePreprocessorMacroName(bool IsDefinition); 12291 void CodeCompletePreprocessorExpression(); 12292 void CodeCompletePreprocessorMacroArgument(Scope *S, 12293 IdentifierInfo *Macro, 12294 MacroInfo *MacroInfo, 12295 unsigned Argument); 12296 void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled); 12297 void CodeCompleteNaturalLanguage(); 12298 void CodeCompleteAvailabilityPlatformName(); 12299 void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator, 12300 CodeCompletionTUInfo &CCTUInfo, 12301 SmallVectorImpl<CodeCompletionResult> &Results); 12302 //@} 12303 12304 //===--------------------------------------------------------------------===// 12305 // Extra semantic analysis beyond the C type system 12306 12307 public: 12308 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, 12309 unsigned ByteNo) const; 12310 12311 private: 12312 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, 12313 const ArraySubscriptExpr *ASE=nullptr, 12314 bool AllowOnePastEnd=true, bool IndexNegated=false); 12315 void CheckArrayAccess(const Expr *E); 12316 // Used to grab the relevant information from a FormatAttr and a 12317 // FunctionDeclaration. 12318 struct FormatStringInfo { 12319 unsigned FormatIdx; 12320 unsigned FirstDataArg; 12321 bool HasVAListArg; 12322 }; 12323 12324 static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, 12325 FormatStringInfo *FSI); 12326 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, 12327 const FunctionProtoType *Proto); 12328 bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc, 12329 ArrayRef<const Expr *> Args); 12330 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall, 12331 const FunctionProtoType *Proto); 12332 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto); 12333 void CheckConstructorCall(FunctionDecl *FDecl, 12334 ArrayRef<const Expr *> Args, 12335 const FunctionProtoType *Proto, 12336 SourceLocation Loc); 12337 12338 void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, 12339 const Expr *ThisArg, ArrayRef<const Expr *> Args, 12340 bool IsMemberFunction, SourceLocation Loc, SourceRange Range, 12341 VariadicCallType CallType); 12342 12343 bool CheckObjCString(Expr *Arg); 12344 ExprResult CheckOSLogFormatStringArg(Expr *Arg); 12345 12346 ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl, 12347 unsigned BuiltinID, CallExpr *TheCall); 12348 12349 bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12350 CallExpr *TheCall); 12351 12352 void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall); 12353 12354 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall, 12355 unsigned MaxWidth); 12356 bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12357 CallExpr *TheCall); 12358 bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12359 bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12360 bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12361 CallExpr *TheCall); 12362 bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg, 12363 bool WantCDE); 12364 bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12365 CallExpr *TheCall); 12366 12367 bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12368 CallExpr *TheCall); 12369 bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12370 bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12371 bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall); 12372 bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12373 CallExpr *TheCall); 12374 bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID, 12375 CallExpr *TheCall); 12376 bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall); 12377 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12378 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall); 12379 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall); 12380 bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall); 12381 bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall, 12382 ArrayRef<int> ArgNums); 12383 bool CheckX86BuiltinTileDuplicate(CallExpr *TheCall, ArrayRef<int> ArgNums); 12384 bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall, 12385 ArrayRef<int> ArgNums); 12386 bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12387 CallExpr *TheCall); 12388 bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12389 CallExpr *TheCall); 12390 bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12391 12392 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall); 12393 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call); 12394 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall); 12395 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs); 12396 bool SemaBuiltinComplex(CallExpr *TheCall); 12397 bool SemaBuiltinVSX(CallExpr *TheCall); 12398 bool SemaBuiltinOSLogFormat(CallExpr *TheCall); 12399 12400 public: 12401 // Used by C++ template instantiation. 12402 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall); 12403 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, 12404 SourceLocation BuiltinLoc, 12405 SourceLocation RParenLoc); 12406 12407 private: 12408 bool SemaBuiltinPrefetch(CallExpr *TheCall); 12409 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall); 12410 bool SemaBuiltinAssume(CallExpr *TheCall); 12411 bool SemaBuiltinAssumeAligned(CallExpr *TheCall); 12412 bool SemaBuiltinLongjmp(CallExpr *TheCall); 12413 bool SemaBuiltinSetjmp(CallExpr *TheCall); 12414 ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult); 12415 ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult); 12416 ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult, 12417 AtomicExpr::AtomicOp Op); 12418 ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult, 12419 bool IsDelete); 12420 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum, 12421 llvm::APSInt &Result); 12422 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, 12423 int High, bool RangeIsError = true); 12424 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum, 12425 unsigned Multiple); 12426 bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum); 12427 bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum, 12428 unsigned ArgBits); 12429 bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum, 12430 unsigned ArgBits); 12431 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, 12432 int ArgNum, unsigned ExpectedFieldNum, 12433 bool AllowName); 12434 bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall); 12435 bool SemaBuiltinPPCMMACall(CallExpr *TheCall, const char *TypeDesc); 12436 12437 bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc); 12438 12439 // Matrix builtin handling. 12440 ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall, 12441 ExprResult CallResult); 12442 ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall, 12443 ExprResult CallResult); 12444 ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall, 12445 ExprResult CallResult); 12446 12447 public: 12448 enum FormatStringType { 12449 FST_Scanf, 12450 FST_Printf, 12451 FST_NSString, 12452 FST_Strftime, 12453 FST_Strfmon, 12454 FST_Kprintf, 12455 FST_FreeBSDKPrintf, 12456 FST_OSTrace, 12457 FST_OSLog, 12458 FST_Unknown 12459 }; 12460 static FormatStringType GetFormatStringType(const FormatAttr *Format); 12461 12462 bool FormatStringHasSArg(const StringLiteral *FExpr); 12463 12464 static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx); 12465 12466 private: 12467 bool CheckFormatArguments(const FormatAttr *Format, 12468 ArrayRef<const Expr *> Args, 12469 bool IsCXXMember, 12470 VariadicCallType CallType, 12471 SourceLocation Loc, SourceRange Range, 12472 llvm::SmallBitVector &CheckedVarArgs); 12473 bool CheckFormatArguments(ArrayRef<const Expr *> Args, 12474 bool HasVAListArg, unsigned format_idx, 12475 unsigned firstDataArg, FormatStringType Type, 12476 VariadicCallType CallType, 12477 SourceLocation Loc, SourceRange range, 12478 llvm::SmallBitVector &CheckedVarArgs); 12479 12480 void CheckAbsoluteValueFunction(const CallExpr *Call, 12481 const FunctionDecl *FDecl); 12482 12483 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl); 12484 12485 void CheckMemaccessArguments(const CallExpr *Call, 12486 unsigned BId, 12487 IdentifierInfo *FnName); 12488 12489 void CheckStrlcpycatArguments(const CallExpr *Call, 12490 IdentifierInfo *FnName); 12491 12492 void CheckStrncatArguments(const CallExpr *Call, 12493 IdentifierInfo *FnName); 12494 12495 void CheckFreeArguments(const CallExpr *E); 12496 12497 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType, 12498 SourceLocation ReturnLoc, 12499 bool isObjCMethod = false, 12500 const AttrVec *Attrs = nullptr, 12501 const FunctionDecl *FD = nullptr); 12502 12503 public: 12504 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS); 12505 12506 private: 12507 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation()); 12508 void CheckBoolLikeConversion(Expr *E, SourceLocation CC); 12509 void CheckForIntOverflow(Expr *E); 12510 void CheckUnsequencedOperations(const Expr *E); 12511 12512 /// Perform semantic checks on a completed expression. This will either 12513 /// be a full-expression or a default argument expression. 12514 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(), 12515 bool IsConstexpr = false); 12516 12517 void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field, 12518 Expr *Init); 12519 12520 /// Check if there is a field shadowing. 12521 void CheckShadowInheritedFields(const SourceLocation &Loc, 12522 DeclarationName FieldName, 12523 const CXXRecordDecl *RD, 12524 bool DeclIsField = true); 12525 12526 /// Check if the given expression contains 'break' or 'continue' 12527 /// statement that produces control flow different from GCC. 12528 void CheckBreakContinueBinding(Expr *E); 12529 12530 /// Check whether receiver is mutable ObjC container which 12531 /// attempts to add itself into the container 12532 void CheckObjCCircularContainer(ObjCMessageExpr *Message); 12533 12534 void CheckTCBEnforcement(const CallExpr *TheCall, const FunctionDecl *Callee); 12535 12536 void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE); 12537 void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc, 12538 bool DeleteWasArrayForm); 12539 public: 12540 /// Register a magic integral constant to be used as a type tag. 12541 void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, 12542 uint64_t MagicValue, QualType Type, 12543 bool LayoutCompatible, bool MustBeNull); 12544 12545 struct TypeTagData { TypeTagDataTypeTagData12546 TypeTagData() {} 12547 TypeTagDataTypeTagData12548 TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) : 12549 Type(Type), LayoutCompatible(LayoutCompatible), 12550 MustBeNull(MustBeNull) 12551 {} 12552 12553 QualType Type; 12554 12555 /// If true, \c Type should be compared with other expression's types for 12556 /// layout-compatibility. 12557 unsigned LayoutCompatible : 1; 12558 unsigned MustBeNull : 1; 12559 }; 12560 12561 /// A pair of ArgumentKind identifier and magic value. This uniquely 12562 /// identifies the magic value. 12563 typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue; 12564 12565 private: 12566 /// A map from magic value to type information. 12567 std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>> 12568 TypeTagForDatatypeMagicValues; 12569 12570 /// Peform checks on a call of a function with argument_with_type_tag 12571 /// or pointer_with_type_tag attributes. 12572 void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr, 12573 const ArrayRef<const Expr *> ExprArgs, 12574 SourceLocation CallSiteLoc); 12575 12576 /// Check if we are taking the address of a packed field 12577 /// as this may be a problem if the pointer value is dereferenced. 12578 void CheckAddressOfPackedMember(Expr *rhs); 12579 12580 /// The parser's current scope. 12581 /// 12582 /// The parser maintains this state here. 12583 Scope *CurScope; 12584 12585 mutable IdentifierInfo *Ident_super; 12586 mutable IdentifierInfo *Ident___float128; 12587 12588 /// Nullability type specifiers. 12589 IdentifierInfo *Ident__Nonnull = nullptr; 12590 IdentifierInfo *Ident__Nullable = nullptr; 12591 IdentifierInfo *Ident__Nullable_result = nullptr; 12592 IdentifierInfo *Ident__Null_unspecified = nullptr; 12593 12594 IdentifierInfo *Ident_NSError = nullptr; 12595 12596 /// The handler for the FileChanged preprocessor events. 12597 /// 12598 /// Used for diagnostics that implement custom semantic analysis for #include 12599 /// directives, like -Wpragma-pack. 12600 sema::SemaPPCallbacks *SemaPPCallbackHandler; 12601 12602 protected: 12603 friend class Parser; 12604 friend class InitializationSequence; 12605 friend class ASTReader; 12606 friend class ASTDeclReader; 12607 friend class ASTWriter; 12608 12609 public: 12610 /// Retrieve the keyword associated 12611 IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability); 12612 12613 /// The struct behind the CFErrorRef pointer. 12614 RecordDecl *CFError = nullptr; 12615 bool isCFError(RecordDecl *D); 12616 12617 /// Retrieve the identifier "NSError". 12618 IdentifierInfo *getNSErrorIdent(); 12619 12620 /// Retrieve the parser's current scope. 12621 /// 12622 /// This routine must only be used when it is certain that semantic analysis 12623 /// and the parser are in precisely the same context, which is not the case 12624 /// when, e.g., we are performing any kind of template instantiation. 12625 /// Therefore, the only safe places to use this scope are in the parser 12626 /// itself and in routines directly invoked from the parser and *never* from 12627 /// template substitution or instantiation. getCurScope()12628 Scope *getCurScope() const { return CurScope; } 12629 incrementMSManglingNumber()12630 void incrementMSManglingNumber() const { 12631 return CurScope->incrementMSManglingNumber(); 12632 } 12633 12634 IdentifierInfo *getSuperIdentifier() const; 12635 IdentifierInfo *getFloat128Identifier() const; 12636 12637 Decl *getObjCDeclContext() const; 12638 getCurLexicalContext()12639 DeclContext *getCurLexicalContext() const { 12640 return OriginalLexicalContext ? OriginalLexicalContext : CurContext; 12641 } 12642 getCurObjCLexicalContext()12643 const DeclContext *getCurObjCLexicalContext() const { 12644 const DeclContext *DC = getCurLexicalContext(); 12645 // A category implicitly has the attribute of the interface. 12646 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC)) 12647 DC = CatD->getClassInterface(); 12648 return DC; 12649 } 12650 12651 /// Determine the number of levels of enclosing template parameters. This is 12652 /// only usable while parsing. Note that this does not include dependent 12653 /// contexts in which no template parameters have yet been declared, such as 12654 /// in a terse function template or generic lambda before the first 'auto' is 12655 /// encountered. 12656 unsigned getTemplateDepth(Scope *S) const; 12657 12658 /// To be used for checking whether the arguments being passed to 12659 /// function exceeds the number of parameters expected for it. 12660 static bool TooManyArguments(size_t NumParams, size_t NumArgs, 12661 bool PartialOverloading = false) { 12662 // We check whether we're just after a comma in code-completion. 12663 if (NumArgs > 0 && PartialOverloading) 12664 return NumArgs + 1 > NumParams; // If so, we view as an extra argument. 12665 return NumArgs > NumParams; 12666 } 12667 12668 // Emitting members of dllexported classes is delayed until the class 12669 // (including field initializers) is fully parsed. 12670 SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses; 12671 SmallVector<CXXMethodDecl*, 4> DelayedDllExportMemberFunctions; 12672 12673 private: 12674 int ParsingClassDepth = 0; 12675 12676 class SavePendingParsedClassStateRAII { 12677 public: SavePendingParsedClassStateRAII(Sema & S)12678 SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); } 12679 ~SavePendingParsedClassStateRAII()12680 ~SavePendingParsedClassStateRAII() { 12681 assert(S.DelayedOverridingExceptionSpecChecks.empty() && 12682 "there shouldn't be any pending delayed exception spec checks"); 12683 assert(S.DelayedEquivalentExceptionSpecChecks.empty() && 12684 "there shouldn't be any pending delayed exception spec checks"); 12685 swapSavedState(); 12686 } 12687 12688 private: 12689 Sema &S; 12690 decltype(DelayedOverridingExceptionSpecChecks) 12691 SavedOverridingExceptionSpecChecks; 12692 decltype(DelayedEquivalentExceptionSpecChecks) 12693 SavedEquivalentExceptionSpecChecks; 12694 swapSavedState()12695 void swapSavedState() { 12696 SavedOverridingExceptionSpecChecks.swap( 12697 S.DelayedOverridingExceptionSpecChecks); 12698 SavedEquivalentExceptionSpecChecks.swap( 12699 S.DelayedEquivalentExceptionSpecChecks); 12700 } 12701 }; 12702 12703 /// Helper class that collects misaligned member designations and 12704 /// their location info for delayed diagnostics. 12705 struct MisalignedMember { 12706 Expr *E; 12707 RecordDecl *RD; 12708 ValueDecl *MD; 12709 CharUnits Alignment; 12710 MisalignedMemberMisalignedMember12711 MisalignedMember() : E(), RD(), MD(), Alignment() {} MisalignedMemberMisalignedMember12712 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD, 12713 CharUnits Alignment) 12714 : E(E), RD(RD), MD(MD), Alignment(Alignment) {} MisalignedMemberMisalignedMember12715 explicit MisalignedMember(Expr *E) 12716 : MisalignedMember(E, nullptr, nullptr, CharUnits()) {} 12717 12718 bool operator==(const MisalignedMember &m) { return this->E == m.E; } 12719 }; 12720 /// Small set of gathered accesses to potentially misaligned members 12721 /// due to the packed attribute. 12722 SmallVector<MisalignedMember, 4> MisalignedMembers; 12723 12724 /// Adds an expression to the set of gathered misaligned members. 12725 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD, 12726 CharUnits Alignment); 12727 12728 public: 12729 /// Diagnoses the current set of gathered accesses. This typically 12730 /// happens at full expression level. The set is cleared after emitting the 12731 /// diagnostics. 12732 void DiagnoseMisalignedMembers(); 12733 12734 /// This function checks if the expression is in the sef of potentially 12735 /// misaligned members and it is converted to some pointer type T with lower 12736 /// or equal alignment requirements. If so it removes it. This is used when 12737 /// we do not want to diagnose such misaligned access (e.g. in conversions to 12738 /// void*). 12739 void DiscardMisalignedMemberAddress(const Type *T, Expr *E); 12740 12741 /// This function calls Action when it determines that E designates a 12742 /// misaligned member due to the packed attribute. This is used to emit 12743 /// local diagnostics like in reference binding. 12744 void RefersToMemberWithReducedAlignment( 12745 Expr *E, 12746 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)> 12747 Action); 12748 12749 /// Describes the reason a calling convention specification was ignored, used 12750 /// for diagnostics. 12751 enum class CallingConventionIgnoredReason { 12752 ForThisTarget = 0, 12753 VariadicFunction, 12754 ConstructorDestructor, 12755 BuiltinFunction 12756 }; 12757 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 12758 /// context is "used as device code". 12759 /// 12760 /// - If CurLexicalContext is a kernel function or it is known that the 12761 /// function will be emitted for the device, emits the diagnostics 12762 /// immediately. 12763 /// - If CurLexicalContext is a function and we are compiling 12764 /// for the device, but we don't know that this function will be codegen'ed 12765 /// for devive yet, creates a diagnostic which is emitted if and when we 12766 /// realize that the function will be codegen'ed. 12767 /// 12768 /// Example usage: 12769 /// 12770 /// Diagnose __float128 type usage only from SYCL device code if the current 12771 /// target doesn't support it 12772 /// if (!S.Context.getTargetInfo().hasFloat128Type() && 12773 /// S.getLangOpts().SYCLIsDevice) 12774 /// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128"; 12775 SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc, 12776 unsigned DiagID); 12777 12778 /// Check whether we're allowed to call Callee from the current context. 12779 /// 12780 /// - If the call is never allowed in a semantically-correct program 12781 /// emits an error and returns false. 12782 /// 12783 /// - If the call is allowed in semantically-correct programs, but only if 12784 /// it's never codegen'ed, creates a deferred diagnostic to be emitted if 12785 /// and when the caller is codegen'ed, and returns true. 12786 /// 12787 /// - Otherwise, returns true without emitting any diagnostics. 12788 /// 12789 /// Adds Callee to DeviceCallGraph if we don't know if its caller will be 12790 /// codegen'ed yet. 12791 bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee); 12792 }; 12793 12794 /// RAII object that enters a new expression evaluation context. 12795 class EnterExpressionEvaluationContext { 12796 Sema &Actions; 12797 bool Entered = true; 12798 12799 public: 12800 EnterExpressionEvaluationContext( 12801 Sema &Actions, Sema::ExpressionEvaluationContext NewContext, 12802 Decl *LambdaContextDecl = nullptr, 12803 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext = 12804 Sema::ExpressionEvaluationContextRecord::EK_Other, 12805 bool ShouldEnter = true) Actions(Actions)12806 : Actions(Actions), Entered(ShouldEnter) { 12807 if (Entered) 12808 Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl, 12809 ExprContext); 12810 } 12811 EnterExpressionEvaluationContext( 12812 Sema &Actions, Sema::ExpressionEvaluationContext NewContext, 12813 Sema::ReuseLambdaContextDecl_t, 12814 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext = 12815 Sema::ExpressionEvaluationContextRecord::EK_Other) Actions(Actions)12816 : Actions(Actions) { 12817 Actions.PushExpressionEvaluationContext( 12818 NewContext, Sema::ReuseLambdaContextDecl, ExprContext); 12819 } 12820 12821 enum InitListTag { InitList }; 12822 EnterExpressionEvaluationContext(Sema &Actions, InitListTag, 12823 bool ShouldEnter = true) Actions(Actions)12824 : Actions(Actions), Entered(false) { 12825 // In C++11 onwards, narrowing checks are performed on the contents of 12826 // braced-init-lists, even when they occur within unevaluated operands. 12827 // Therefore we still need to instantiate constexpr functions used in such 12828 // a context. 12829 if (ShouldEnter && Actions.isUnevaluatedContext() && 12830 Actions.getLangOpts().CPlusPlus11) { 12831 Actions.PushExpressionEvaluationContext( 12832 Sema::ExpressionEvaluationContext::UnevaluatedList); 12833 Entered = true; 12834 } 12835 } 12836 ~EnterExpressionEvaluationContext()12837 ~EnterExpressionEvaluationContext() { 12838 if (Entered) 12839 Actions.PopExpressionEvaluationContext(); 12840 } 12841 }; 12842 12843 DeductionFailureInfo 12844 MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, 12845 sema::TemplateDeductionInfo &Info); 12846 12847 /// Contains a late templated function. 12848 /// Will be parsed at the end of the translation unit, used by Sema & Parser. 12849 struct LateParsedTemplate { 12850 CachedTokens Toks; 12851 /// The template function declaration to be late parsed. 12852 Decl *D; 12853 }; 12854 12855 template <> 12856 void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation, 12857 PragmaMsStackAction Action, 12858 llvm::StringRef StackSlotLabel, 12859 AlignPackInfo Value); 12860 12861 } // end namespace clang 12862 12863 namespace llvm { 12864 // Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its 12865 // SourceLocation. 12866 template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> { 12867 using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc; 12868 using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>; 12869 12870 static FunctionDeclAndLoc getEmptyKey() { 12871 return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()}; 12872 } 12873 12874 static FunctionDeclAndLoc getTombstoneKey() { 12875 return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()}; 12876 } 12877 12878 static unsigned getHashValue(const FunctionDeclAndLoc &FDL) { 12879 return hash_combine(FDBaseInfo::getHashValue(FDL.FD), 12880 FDL.Loc.getHashValue()); 12881 } 12882 12883 static bool isEqual(const FunctionDeclAndLoc &LHS, 12884 const FunctionDeclAndLoc &RHS) { 12885 return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc; 12886 } 12887 }; 12888 } // namespace llvm 12889 12890 #endif 12891