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/StmtOpenMP.h" 36 #include "clang/AST/TypeLoc.h" 37 #include "clang/AST/TypeOrdering.h" 38 #include "clang/Basic/BitmaskEnum.h" 39 #include "clang/Basic/Builtins.h" 40 #include "clang/Basic/DarwinSDKInfo.h" 41 #include "clang/Basic/ExpressionTraits.h" 42 #include "clang/Basic/Module.h" 43 #include "clang/Basic/OpenCLOptions.h" 44 #include "clang/Basic/OpenMPKinds.h" 45 #include "clang/Basic/PragmaKinds.h" 46 #include "clang/Basic/Specifiers.h" 47 #include "clang/Basic/TemplateKinds.h" 48 #include "clang/Basic/TypeTraits.h" 49 #include "clang/Sema/AnalysisBasedWarnings.h" 50 #include "clang/Sema/CleanupInfo.h" 51 #include "clang/Sema/DeclSpec.h" 52 #include "clang/Sema/ExternalSemaSource.h" 53 #include "clang/Sema/IdentifierResolver.h" 54 #include "clang/Sema/ObjCMethodList.h" 55 #include "clang/Sema/Ownership.h" 56 #include "clang/Sema/Scope.h" 57 #include "clang/Sema/SemaConcept.h" 58 #include "clang/Sema/TypoCorrection.h" 59 #include "clang/Sema/Weak.h" 60 #include "llvm/ADT/ArrayRef.h" 61 #include "llvm/ADT/Optional.h" 62 #include "llvm/ADT/SetVector.h" 63 #include "llvm/ADT/SmallBitVector.h" 64 #include "llvm/ADT/SmallPtrSet.h" 65 #include "llvm/ADT/SmallSet.h" 66 #include "llvm/ADT/SmallVector.h" 67 #include "llvm/ADT/TinyPtrVector.h" 68 #include "llvm/Frontend/OpenMP/OMPConstants.h" 69 #include <deque> 70 #include <memory> 71 #include <string> 72 #include <tuple> 73 #include <vector> 74 75 namespace llvm { 76 class APSInt; 77 template <typename ValueT> struct DenseMapInfo; 78 template <typename ValueT, typename ValueInfoT> class DenseSet; 79 class SmallBitVector; 80 struct InlineAsmIdentifierInfo; 81 } 82 83 namespace clang { 84 class ADLResult; 85 class ASTConsumer; 86 class ASTContext; 87 class ASTMutationListener; 88 class ASTReader; 89 class ASTWriter; 90 class ArrayType; 91 class ParsedAttr; 92 class BindingDecl; 93 class BlockDecl; 94 class CapturedDecl; 95 class CXXBasePath; 96 class CXXBasePaths; 97 class CXXBindTemporaryExpr; 98 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath; 99 class CXXConstructorDecl; 100 class CXXConversionDecl; 101 class CXXDeleteExpr; 102 class CXXDestructorDecl; 103 class CXXFieldCollector; 104 class CXXMemberCallExpr; 105 class CXXMethodDecl; 106 class CXXScopeSpec; 107 class CXXTemporary; 108 class CXXTryStmt; 109 class CallExpr; 110 class ClassTemplateDecl; 111 class ClassTemplatePartialSpecializationDecl; 112 class ClassTemplateSpecializationDecl; 113 class VarTemplatePartialSpecializationDecl; 114 class CodeCompleteConsumer; 115 class CodeCompletionAllocator; 116 class CodeCompletionTUInfo; 117 class CodeCompletionResult; 118 class CoroutineBodyStmt; 119 class Decl; 120 class DeclAccessPair; 121 class DeclContext; 122 class DeclRefExpr; 123 class DeclaratorDecl; 124 class DeducedTemplateArgument; 125 class DependentDiagnostic; 126 class DesignatedInitExpr; 127 class Designation; 128 class EnableIfAttr; 129 class EnumConstantDecl; 130 class Expr; 131 class ExtVectorType; 132 class FormatAttr; 133 class FriendDecl; 134 class FunctionDecl; 135 class FunctionProtoType; 136 class FunctionTemplateDecl; 137 class ImplicitConversionSequence; 138 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList; 139 class InitListExpr; 140 class InitializationKind; 141 class InitializationSequence; 142 class InitializedEntity; 143 class IntegerLiteral; 144 class LabelStmt; 145 class LambdaExpr; 146 class LangOptions; 147 class LocalInstantiationScope; 148 class LookupResult; 149 class MacroInfo; 150 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath; 151 class ModuleLoader; 152 class MultiLevelTemplateArgumentList; 153 class NamedDecl; 154 class ObjCCategoryDecl; 155 class ObjCCategoryImplDecl; 156 class ObjCCompatibleAliasDecl; 157 class ObjCContainerDecl; 158 class ObjCImplDecl; 159 class ObjCImplementationDecl; 160 class ObjCInterfaceDecl; 161 class ObjCIvarDecl; 162 template <class T> class ObjCList; 163 class ObjCMessageExpr; 164 class ObjCMethodDecl; 165 class ObjCPropertyDecl; 166 class ObjCProtocolDecl; 167 class OMPThreadPrivateDecl; 168 class OMPRequiresDecl; 169 class OMPDeclareReductionDecl; 170 class OMPDeclareSimdDecl; 171 class OMPClause; 172 struct OMPVarListLocTy; 173 struct OverloadCandidate; 174 enum class OverloadCandidateParamOrder : char; 175 enum OverloadCandidateRewriteKind : unsigned; 176 class OverloadCandidateSet; 177 class OverloadExpr; 178 class ParenListExpr; 179 class ParmVarDecl; 180 class Preprocessor; 181 class PseudoDestructorTypeStorage; 182 class PseudoObjectExpr; 183 class QualType; 184 class StandardConversionSequence; 185 class Stmt; 186 class StringLiteral; 187 class SwitchStmt; 188 class TemplateArgument; 189 class TemplateArgumentList; 190 class TemplateArgumentLoc; 191 class TemplateDecl; 192 class TemplateInstantiationCallback; 193 class TemplateParameterList; 194 class TemplatePartialOrderingContext; 195 class TemplateTemplateParmDecl; 196 class Token; 197 class TypeAliasDecl; 198 class TypedefDecl; 199 class TypedefNameDecl; 200 class TypeLoc; 201 class TypoCorrectionConsumer; 202 class UnqualifiedId; 203 class UnresolvedLookupExpr; 204 class UnresolvedMemberExpr; 205 class UnresolvedSetImpl; 206 class UnresolvedSetIterator; 207 class UsingDecl; 208 class UsingShadowDecl; 209 class ValueDecl; 210 class VarDecl; 211 class VarTemplateSpecializationDecl; 212 class VisibilityAttr; 213 class VisibleDeclConsumer; 214 class IndirectFieldDecl; 215 struct DeductionFailureInfo; 216 class TemplateSpecCandidateSet; 217 218 namespace sema { 219 class AccessedEntity; 220 class BlockScopeInfo; 221 class Capture; 222 class CapturedRegionScopeInfo; 223 class CapturingScopeInfo; 224 class CompoundScopeInfo; 225 class DelayedDiagnostic; 226 class DelayedDiagnosticPool; 227 class FunctionScopeInfo; 228 class LambdaScopeInfo; 229 class PossiblyUnreachableDiag; 230 class SemaPPCallbacks; 231 class TemplateDeductionInfo; 232 } 233 234 namespace threadSafety { 235 class BeforeSet; 236 void threadSafetyCleanup(BeforeSet* Cache); 237 } 238 239 // FIXME: No way to easily map from TemplateTypeParmTypes to 240 // TemplateTypeParmDecls, so we have this horrible PointerUnion. 241 typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>, 242 SourceLocation> UnexpandedParameterPack; 243 244 /// Describes whether we've seen any nullability information for the given 245 /// file. 246 struct FileNullability { 247 /// The first pointer declarator (of any pointer kind) in the file that does 248 /// not have a corresponding nullability annotation. 249 SourceLocation PointerLoc; 250 251 /// The end location for the first pointer declarator in the file. Used for 252 /// placing fix-its. 253 SourceLocation PointerEndLoc; 254 255 /// Which kind of pointer declarator we saw. 256 uint8_t PointerKind; 257 258 /// Whether we saw any type nullability annotations in the given file. 259 bool SawTypeNullability = false; 260 }; 261 262 /// A mapping from file IDs to a record of whether we've seen nullability 263 /// information in that file. 264 class FileNullabilityMap { 265 /// A mapping from file IDs to the nullability information for each file ID. 266 llvm::DenseMap<FileID, FileNullability> Map; 267 268 /// A single-element cache based on the file ID. 269 struct { 270 FileID File; 271 FileNullability Nullability; 272 } Cache; 273 274 public: 275 FileNullability &operator[](FileID file) { 276 // Check the single-element cache. 277 if (file == Cache.File) 278 return Cache.Nullability; 279 280 // It's not in the single-element cache; flush the cache if we have one. 281 if (!Cache.File.isInvalid()) { 282 Map[Cache.File] = Cache.Nullability; 283 } 284 285 // Pull this entry into the cache. 286 Cache.File = file; 287 Cache.Nullability = Map[file]; 288 return Cache.Nullability; 289 } 290 }; 291 292 /// Tracks expected type during expression parsing, for use in code completion. 293 /// The type is tied to a particular token, all functions that update or consume 294 /// the type take a start location of the token they are looking at as a 295 /// parameter. This avoids updating the type on hot paths in the parser. 296 class PreferredTypeBuilder { 297 public: 298 PreferredTypeBuilder(bool Enabled) : Enabled(Enabled) {} 299 300 void enterCondition(Sema &S, SourceLocation Tok); 301 void enterReturn(Sema &S, SourceLocation Tok); 302 void enterVariableInit(SourceLocation Tok, Decl *D); 303 /// Handles e.g. BaseType{ .D = Tok... 304 void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType, 305 const Designation &D); 306 /// Computing a type for the function argument may require running 307 /// overloading, so we postpone its computation until it is actually needed. 308 /// 309 /// Clients should be very careful when using this funciton, as it stores a 310 /// function_ref, clients should make sure all calls to get() with the same 311 /// location happen while function_ref is alive. 312 /// 313 /// The callback should also emit signature help as a side-effect, but only 314 /// if the completion point has been reached. 315 void enterFunctionArgument(SourceLocation Tok, 316 llvm::function_ref<QualType()> ComputeType); 317 318 void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc); 319 void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind, 320 SourceLocation OpLoc); 321 void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op); 322 void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base); 323 void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS); 324 /// Handles all type casts, including C-style cast, C++ casts, etc. 325 void enterTypeCast(SourceLocation Tok, QualType CastType); 326 327 /// Get the expected type associated with this location, if any. 328 /// 329 /// If the location is a function argument, determining the expected type 330 /// involves considering all function overloads and the arguments so far. 331 /// In this case, signature help for these function overloads will be reported 332 /// as a side-effect (only if the completion point has been reached). 333 QualType get(SourceLocation Tok) const { 334 if (!Enabled || Tok != ExpectedLoc) 335 return QualType(); 336 if (!Type.isNull()) 337 return Type; 338 if (ComputeType) 339 return ComputeType(); 340 return QualType(); 341 } 342 343 private: 344 bool Enabled; 345 /// Start position of a token for which we store expected type. 346 SourceLocation ExpectedLoc; 347 /// Expected type for a token starting at ExpectedLoc. 348 QualType Type; 349 /// A function to compute expected type at ExpectedLoc. It is only considered 350 /// if Type is null. 351 llvm::function_ref<QualType()> ComputeType; 352 }; 353 354 /// Sema - This implements semantic analysis and AST building for C. 355 class Sema final { 356 Sema(const Sema &) = delete; 357 void operator=(const Sema &) = delete; 358 359 ///Source of additional semantic information. 360 ExternalSemaSource *ExternalSource; 361 362 ///Whether Sema has generated a multiplexer and has to delete it. 363 bool isMultiplexExternalSource; 364 365 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD); 366 367 bool isVisibleSlow(const NamedDecl *D); 368 369 /// Determine whether two declarations should be linked together, given that 370 /// the old declaration might not be visible and the new declaration might 371 /// not have external linkage. 372 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old, 373 const NamedDecl *New) { 374 if (isVisible(Old)) 375 return true; 376 // See comment in below overload for why it's safe to compute the linkage 377 // of the new declaration here. 378 if (New->isExternallyDeclarable()) { 379 assert(Old->isExternallyDeclarable() && 380 "should not have found a non-externally-declarable previous decl"); 381 return true; 382 } 383 return false; 384 } 385 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New); 386 387 void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem, 388 QualType ResultTy, 389 ArrayRef<QualType> Args); 390 391 public: 392 /// The maximum alignment, same as in llvm::Value. We duplicate them here 393 /// because that allows us not to duplicate the constants in clang code, 394 /// which we must to since we can't directly use the llvm constants. 395 /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp 396 /// 397 /// This is the greatest alignment value supported by load, store, and alloca 398 /// instructions, and global values. 399 static const unsigned MaxAlignmentExponent = 29; 400 static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent; 401 402 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy; 403 typedef OpaquePtr<TemplateName> TemplateTy; 404 typedef OpaquePtr<QualType> TypeTy; 405 406 OpenCLOptions OpenCLFeatures; 407 FPOptions CurFPFeatures; 408 409 const LangOptions &LangOpts; 410 Preprocessor &PP; 411 ASTContext &Context; 412 ASTConsumer &Consumer; 413 DiagnosticsEngine &Diags; 414 SourceManager &SourceMgr; 415 416 /// Flag indicating whether or not to collect detailed statistics. 417 bool CollectStats; 418 419 /// Code-completion consumer. 420 CodeCompleteConsumer *CodeCompleter; 421 422 /// CurContext - This is the current declaration context of parsing. 423 DeclContext *CurContext; 424 425 /// Generally null except when we temporarily switch decl contexts, 426 /// like in \see ActOnObjCTemporaryExitContainerContext. 427 DeclContext *OriginalLexicalContext; 428 429 /// VAListTagName - The declaration name corresponding to __va_list_tag. 430 /// This is used as part of a hack to omit that class from ADL results. 431 DeclarationName VAListTagName; 432 433 bool MSStructPragmaOn; // True when \#pragma ms_struct on 434 435 /// Controls member pointer representation format under the MS ABI. 436 LangOptions::PragmaMSPointersToMembersKind 437 MSPointerToMemberRepresentationMethod; 438 439 /// Stack of active SEH __finally scopes. Can be empty. 440 SmallVector<Scope*, 2> CurrentSEHFinally; 441 442 /// Source location for newly created implicit MSInheritanceAttrs 443 SourceLocation ImplicitMSInheritanceAttrLoc; 444 445 /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by 446 /// `TransformTypos` in order to keep track of any TypoExprs that are created 447 /// recursively during typo correction and wipe them away if the correction 448 /// fails. 449 llvm::SmallVector<TypoExpr *, 2> TypoExprs; 450 451 /// pragma clang section kind 452 enum PragmaClangSectionKind { 453 PCSK_Invalid = 0, 454 PCSK_BSS = 1, 455 PCSK_Data = 2, 456 PCSK_Rodata = 3, 457 PCSK_Text = 4, 458 PCSK_Relro = 5 459 }; 460 461 enum PragmaClangSectionAction { 462 PCSA_Set = 0, 463 PCSA_Clear = 1 464 }; 465 466 struct PragmaClangSection { 467 std::string SectionName; 468 bool Valid = false; 469 SourceLocation PragmaLocation; 470 }; 471 472 PragmaClangSection PragmaClangBSSSection; 473 PragmaClangSection PragmaClangDataSection; 474 PragmaClangSection PragmaClangRodataSection; 475 PragmaClangSection PragmaClangRelroSection; 476 PragmaClangSection PragmaClangTextSection; 477 478 enum PragmaMsStackAction { 479 PSK_Reset = 0x0, // #pragma () 480 PSK_Set = 0x1, // #pragma (value) 481 PSK_Push = 0x2, // #pragma (push[, id]) 482 PSK_Pop = 0x4, // #pragma (pop[, id]) 483 PSK_Show = 0x8, // #pragma (show) -- only for "pack"! 484 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value) 485 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value) 486 }; 487 488 // #pragma pack and align. 489 class AlignPackInfo { 490 public: 491 // `Native` represents default align mode, which may vary based on the 492 // platform. 493 enum Mode : unsigned char { Native, Natural, Packed, Mac68k }; 494 495 // #pragma pack info constructor 496 AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL) 497 : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) { 498 assert(Num == PackNumber && "The pack number has been truncated."); 499 } 500 501 // #pragma align info constructor 502 AlignPackInfo(AlignPackInfo::Mode M, bool IsXL) 503 : PackAttr(false), AlignMode(M), 504 PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {} 505 506 explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {} 507 508 AlignPackInfo() : AlignPackInfo(Native, false) {} 509 510 // When a AlignPackInfo itself cannot be used, this returns an 32-bit 511 // integer encoding for it. This should only be passed to 512 // AlignPackInfo::getFromRawEncoding, it should not be inspected directly. 513 static uint32_t getRawEncoding(const AlignPackInfo &Info) { 514 std::uint32_t Encoding{}; 515 if (Info.IsXLStack()) 516 Encoding |= IsXLMask; 517 518 Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1; 519 520 if (Info.IsPackAttr()) 521 Encoding |= PackAttrMask; 522 523 Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4; 524 525 return Encoding; 526 } 527 528 static AlignPackInfo getFromRawEncoding(unsigned Encoding) { 529 bool IsXL = static_cast<bool>(Encoding & IsXLMask); 530 AlignPackInfo::Mode M = 531 static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1); 532 int PackNumber = (Encoding & PackNumMask) >> 4; 533 534 if (Encoding & PackAttrMask) 535 return AlignPackInfo(M, PackNumber, IsXL); 536 537 return AlignPackInfo(M, IsXL); 538 } 539 540 bool IsPackAttr() const { return PackAttr; } 541 542 bool IsAlignAttr() const { return !PackAttr; } 543 544 Mode getAlignMode() const { return AlignMode; } 545 546 unsigned getPackNumber() const { return PackNumber; } 547 548 bool IsPackSet() const { 549 // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack 550 // attriute on a decl. 551 return PackNumber != UninitPackVal && PackNumber != 0; 552 } 553 554 bool IsXLStack() const { return XLStack; } 555 556 bool operator==(const AlignPackInfo &Info) const { 557 return std::tie(AlignMode, PackNumber, PackAttr, XLStack) == 558 std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr, 559 Info.XLStack); 560 } 561 562 bool operator!=(const AlignPackInfo &Info) const { 563 return !(*this == Info); 564 } 565 566 private: 567 /// \brief True if this is a pragma pack attribute, 568 /// not a pragma align attribute. 569 bool PackAttr; 570 571 /// \brief The alignment mode that is in effect. 572 Mode AlignMode; 573 574 /// \brief The pack number of the stack. 575 unsigned char PackNumber; 576 577 /// \brief True if it is a XL #pragma align/pack stack. 578 bool XLStack; 579 580 /// \brief Uninitialized pack value. 581 static constexpr unsigned char UninitPackVal = -1; 582 583 // Masks to encode and decode an AlignPackInfo. 584 static constexpr uint32_t IsXLMask{0x0000'0001}; 585 static constexpr uint32_t AlignModeMask{0x0000'0006}; 586 static constexpr uint32_t PackAttrMask{0x00000'0008}; 587 static constexpr uint32_t PackNumMask{0x0000'01F0}; 588 }; 589 590 template<typename ValueType> 591 struct PragmaStack { 592 struct Slot { 593 llvm::StringRef StackSlotLabel; 594 ValueType Value; 595 SourceLocation PragmaLocation; 596 SourceLocation PragmaPushLocation; 597 Slot(llvm::StringRef StackSlotLabel, ValueType Value, 598 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation) 599 : StackSlotLabel(StackSlotLabel), Value(Value), 600 PragmaLocation(PragmaLocation), 601 PragmaPushLocation(PragmaPushLocation) {} 602 }; 603 604 void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, 605 llvm::StringRef StackSlotLabel, ValueType Value) { 606 if (Action == PSK_Reset) { 607 CurrentValue = DefaultValue; 608 CurrentPragmaLocation = PragmaLocation; 609 return; 610 } 611 if (Action & PSK_Push) 612 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, 613 PragmaLocation); 614 else if (Action & PSK_Pop) { 615 if (!StackSlotLabel.empty()) { 616 // If we've got a label, try to find it and jump there. 617 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { 618 return x.StackSlotLabel == StackSlotLabel; 619 }); 620 // If we found the label so pop from there. 621 if (I != Stack.rend()) { 622 CurrentValue = I->Value; 623 CurrentPragmaLocation = I->PragmaLocation; 624 Stack.erase(std::prev(I.base()), Stack.end()); 625 } 626 } else if (!Stack.empty()) { 627 // We do not have a label, just pop the last entry. 628 CurrentValue = Stack.back().Value; 629 CurrentPragmaLocation = Stack.back().PragmaLocation; 630 Stack.pop_back(); 631 } 632 } 633 if (Action & PSK_Set) { 634 CurrentValue = Value; 635 CurrentPragmaLocation = PragmaLocation; 636 } 637 } 638 639 // MSVC seems to add artificial slots to #pragma stacks on entering a C++ 640 // method body to restore the stacks on exit, so it works like this: 641 // 642 // struct S { 643 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>) 644 // void Method {} 645 // #pragma <name>(pop, InternalPragmaSlot) 646 // }; 647 // 648 // It works even with #pragma vtordisp, although MSVC doesn't support 649 // #pragma vtordisp(push [, id], n) 650 // syntax. 651 // 652 // Push / pop a named sentinel slot. 653 void SentinelAction(PragmaMsStackAction Action, StringRef Label) { 654 assert((Action == PSK_Push || Action == PSK_Pop) && 655 "Can only push / pop #pragma stack sentinels!"); 656 Act(CurrentPragmaLocation, Action, Label, CurrentValue); 657 } 658 659 // Constructors. 660 explicit PragmaStack(const ValueType &Default) 661 : DefaultValue(Default), CurrentValue(Default) {} 662 663 bool hasValue() const { return CurrentValue != DefaultValue; } 664 665 SmallVector<Slot, 2> Stack; 666 ValueType DefaultValue; // Value used for PSK_Reset action. 667 ValueType CurrentValue; 668 SourceLocation CurrentPragmaLocation; 669 }; 670 // FIXME: We should serialize / deserialize these if they occur in a PCH (but 671 // we shouldn't do so if they're in a module). 672 673 /// Whether to insert vtordisps prior to virtual bases in the Microsoft 674 /// C++ ABI. Possible values are 0, 1, and 2, which mean: 675 /// 676 /// 0: Suppress all vtordisps 677 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial 678 /// structors 679 /// 2: Always insert vtordisps to support RTTI on partially constructed 680 /// objects 681 PragmaStack<MSVtorDispMode> VtorDispStack; 682 PragmaStack<AlignPackInfo> AlignPackStack; 683 // The current #pragma align/pack values and locations at each #include. 684 struct AlignPackIncludeState { 685 AlignPackInfo CurrentValue; 686 SourceLocation CurrentPragmaLocation; 687 bool HasNonDefaultValue, ShouldWarnOnInclude; 688 }; 689 SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack; 690 // Segment #pragmas. 691 PragmaStack<StringLiteral *> DataSegStack; 692 PragmaStack<StringLiteral *> BSSSegStack; 693 PragmaStack<StringLiteral *> ConstSegStack; 694 PragmaStack<StringLiteral *> CodeSegStack; 695 696 // This stack tracks the current state of Sema.CurFPFeatures. 697 PragmaStack<FPOptionsOverride> FpPragmaStack; 698 FPOptionsOverride CurFPFeatureOverrides() { 699 FPOptionsOverride result; 700 if (!FpPragmaStack.hasValue()) { 701 result = FPOptionsOverride(); 702 } else { 703 result = FpPragmaStack.CurrentValue; 704 } 705 return result; 706 } 707 708 // RAII object to push / pop sentinel slots for all MS #pragma stacks. 709 // Actions should be performed only if we enter / exit a C++ method body. 710 class PragmaStackSentinelRAII { 711 public: 712 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct); 713 ~PragmaStackSentinelRAII(); 714 715 private: 716 Sema &S; 717 StringRef SlotLabel; 718 bool ShouldAct; 719 }; 720 721 /// A mapping that describes the nullability we've seen in each header file. 722 FileNullabilityMap NullabilityMap; 723 724 /// Last section used with #pragma init_seg. 725 StringLiteral *CurInitSeg; 726 SourceLocation CurInitSegLoc; 727 728 /// VisContext - Manages the stack for \#pragma GCC visibility. 729 void *VisContext; // Really a "PragmaVisStack*" 730 731 /// This an attribute introduced by \#pragma clang attribute. 732 struct PragmaAttributeEntry { 733 SourceLocation Loc; 734 ParsedAttr *Attribute; 735 SmallVector<attr::SubjectMatchRule, 4> MatchRules; 736 bool IsUsed; 737 }; 738 739 /// A push'd group of PragmaAttributeEntries. 740 struct PragmaAttributeGroup { 741 /// The location of the push attribute. 742 SourceLocation Loc; 743 /// The namespace of this push group. 744 const IdentifierInfo *Namespace; 745 SmallVector<PragmaAttributeEntry, 2> Entries; 746 }; 747 748 SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack; 749 750 /// The declaration that is currently receiving an attribute from the 751 /// #pragma attribute stack. 752 const Decl *PragmaAttributeCurrentTargetDecl; 753 754 /// This represents the last location of a "#pragma clang optimize off" 755 /// directive if such a directive has not been closed by an "on" yet. If 756 /// optimizations are currently "on", this is set to an invalid location. 757 SourceLocation OptimizeOffPragmaLocation; 758 759 /// Flag indicating if Sema is building a recovery call expression. 760 /// 761 /// This flag is used to avoid building recovery call expressions 762 /// if Sema is already doing so, which would cause infinite recursions. 763 bool IsBuildingRecoveryCallExpr; 764 765 /// Used to control the generation of ExprWithCleanups. 766 CleanupInfo Cleanup; 767 768 /// ExprCleanupObjects - This is the stack of objects requiring 769 /// cleanup that are created by the current full expression. 770 SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects; 771 772 /// Store a set of either DeclRefExprs or MemberExprs that contain a reference 773 /// to a variable (constant) that may or may not be odr-used in this Expr, and 774 /// we won't know until all lvalue-to-rvalue and discarded value conversions 775 /// have been applied to all subexpressions of the enclosing full expression. 776 /// This is cleared at the end of each full expression. 777 using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>, 778 llvm::SmallPtrSet<Expr *, 4>>; 779 MaybeODRUseExprSet MaybeODRUseExprs; 780 781 std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope; 782 783 /// Stack containing information about each of the nested 784 /// function, block, and method scopes that are currently active. 785 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes; 786 787 /// The index of the first FunctionScope that corresponds to the current 788 /// context. 789 unsigned FunctionScopesStart = 0; 790 791 ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const { 792 return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart, 793 FunctionScopes.end()); 794 } 795 796 /// Stack containing information needed when in C++2a an 'auto' is encountered 797 /// in a function declaration parameter type specifier in order to invent a 798 /// corresponding template parameter in the enclosing abbreviated function 799 /// template. This information is also present in LambdaScopeInfo, stored in 800 /// the FunctionScopes stack. 801 SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos; 802 803 /// The index of the first InventedParameterInfo that refers to the current 804 /// context. 805 unsigned InventedParameterInfosStart = 0; 806 807 ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const { 808 return llvm::makeArrayRef(InventedParameterInfos.begin() + 809 InventedParameterInfosStart, 810 InventedParameterInfos.end()); 811 } 812 813 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource, 814 &ExternalSemaSource::ReadExtVectorDecls, 2, 2> 815 ExtVectorDeclsType; 816 817 /// ExtVectorDecls - This is a list all the extended vector types. This allows 818 /// us to associate a raw vector type with one of the ext_vector type names. 819 /// This is only necessary for issuing pretty diagnostics. 820 ExtVectorDeclsType ExtVectorDecls; 821 822 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes. 823 std::unique_ptr<CXXFieldCollector> FieldCollector; 824 825 typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType; 826 827 /// Set containing all declared private fields that are not used. 828 NamedDeclSetType UnusedPrivateFields; 829 830 /// Set containing all typedefs that are likely unused. 831 llvm::SmallSetVector<const TypedefNameDecl *, 4> 832 UnusedLocalTypedefNameCandidates; 833 834 /// Delete-expressions to be analyzed at the end of translation unit 835 /// 836 /// This list contains class members, and locations of delete-expressions 837 /// that could not be proven as to whether they mismatch with new-expression 838 /// used in initializer of the field. 839 typedef std::pair<SourceLocation, bool> DeleteExprLoc; 840 typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs; 841 llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs; 842 843 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy; 844 845 /// PureVirtualClassDiagSet - a set of class declarations which we have 846 /// emitted a list of pure virtual functions. Used to prevent emitting the 847 /// same list more than once. 848 std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet; 849 850 /// ParsingInitForAutoVars - a set of declarations with auto types for which 851 /// we are currently parsing the initializer. 852 llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars; 853 854 /// Look for a locally scoped extern "C" declaration by the given name. 855 NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name); 856 857 typedef LazyVector<VarDecl *, ExternalSemaSource, 858 &ExternalSemaSource::ReadTentativeDefinitions, 2, 2> 859 TentativeDefinitionsType; 860 861 /// All the tentative definitions encountered in the TU. 862 TentativeDefinitionsType TentativeDefinitions; 863 864 /// All the external declarations encoutered and used in the TU. 865 SmallVector<VarDecl *, 4> ExternalDeclarations; 866 867 typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource, 868 &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2> 869 UnusedFileScopedDeclsType; 870 871 /// The set of file scoped decls seen so far that have not been used 872 /// and must warn if not used. Only contains the first declaration. 873 UnusedFileScopedDeclsType UnusedFileScopedDecls; 874 875 typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource, 876 &ExternalSemaSource::ReadDelegatingConstructors, 2, 2> 877 DelegatingCtorDeclsType; 878 879 /// All the delegating constructors seen so far in the file, used for 880 /// cycle detection at the end of the TU. 881 DelegatingCtorDeclsType DelegatingCtorDecls; 882 883 /// All the overriding functions seen during a class definition 884 /// that had their exception spec checks delayed, plus the overridden 885 /// function. 886 SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2> 887 DelayedOverridingExceptionSpecChecks; 888 889 /// All the function redeclarations seen during a class definition that had 890 /// their exception spec checks delayed, plus the prior declaration they 891 /// should be checked against. Except during error recovery, the new decl 892 /// should always be a friend declaration, as that's the only valid way to 893 /// redeclare a special member before its class is complete. 894 SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2> 895 DelayedEquivalentExceptionSpecChecks; 896 897 typedef llvm::MapVector<const FunctionDecl *, 898 std::unique_ptr<LateParsedTemplate>> 899 LateParsedTemplateMapT; 900 LateParsedTemplateMapT LateParsedTemplateMap; 901 902 /// Callback to the parser to parse templated functions when needed. 903 typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT); 904 typedef void LateTemplateParserCleanupCB(void *P); 905 LateTemplateParserCB *LateTemplateParser; 906 LateTemplateParserCleanupCB *LateTemplateParserCleanup; 907 void *OpaqueParser; 908 909 void SetLateTemplateParser(LateTemplateParserCB *LTP, 910 LateTemplateParserCleanupCB *LTPCleanup, 911 void *P) { 912 LateTemplateParser = LTP; 913 LateTemplateParserCleanup = LTPCleanup; 914 OpaqueParser = P; 915 } 916 917 // Does the work necessary to deal with a SYCL kernel lambda. At the moment, 918 // this just marks the list of lambdas required to name the kernel. 919 void AddSYCLKernelLambda(const FunctionDecl *FD); 920 921 class DelayedDiagnostics; 922 923 class DelayedDiagnosticsState { 924 sema::DelayedDiagnosticPool *SavedPool; 925 friend class Sema::DelayedDiagnostics; 926 }; 927 typedef DelayedDiagnosticsState ParsingDeclState; 928 typedef DelayedDiagnosticsState ProcessingContextState; 929 930 /// A class which encapsulates the logic for delaying diagnostics 931 /// during parsing and other processing. 932 class DelayedDiagnostics { 933 /// The current pool of diagnostics into which delayed 934 /// diagnostics should go. 935 sema::DelayedDiagnosticPool *CurPool; 936 937 public: 938 DelayedDiagnostics() : CurPool(nullptr) {} 939 940 /// Adds a delayed diagnostic. 941 void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h 942 943 /// Determines whether diagnostics should be delayed. 944 bool shouldDelayDiagnostics() { return CurPool != nullptr; } 945 946 /// Returns the current delayed-diagnostics pool. 947 sema::DelayedDiagnosticPool *getCurrentPool() const { 948 return CurPool; 949 } 950 951 /// Enter a new scope. Access and deprecation diagnostics will be 952 /// collected in this pool. 953 DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) { 954 DelayedDiagnosticsState state; 955 state.SavedPool = CurPool; 956 CurPool = &pool; 957 return state; 958 } 959 960 /// Leave a delayed-diagnostic state that was previously pushed. 961 /// Do not emit any of the diagnostics. This is performed as part 962 /// of the bookkeeping of popping a pool "properly". 963 void popWithoutEmitting(DelayedDiagnosticsState state) { 964 CurPool = state.SavedPool; 965 } 966 967 /// Enter a new scope where access and deprecation diagnostics are 968 /// not delayed. 969 DelayedDiagnosticsState pushUndelayed() { 970 DelayedDiagnosticsState state; 971 state.SavedPool = CurPool; 972 CurPool = nullptr; 973 return state; 974 } 975 976 /// Undo a previous pushUndelayed(). 977 void popUndelayed(DelayedDiagnosticsState state) { 978 assert(CurPool == nullptr); 979 CurPool = state.SavedPool; 980 } 981 } DelayedDiagnostics; 982 983 /// A RAII object to temporarily push a declaration context. 984 class ContextRAII { 985 private: 986 Sema &S; 987 DeclContext *SavedContext; 988 ProcessingContextState SavedContextState; 989 QualType SavedCXXThisTypeOverride; 990 unsigned SavedFunctionScopesStart; 991 unsigned SavedInventedParameterInfosStart; 992 993 public: 994 ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true) 995 : S(S), SavedContext(S.CurContext), 996 SavedContextState(S.DelayedDiagnostics.pushUndelayed()), 997 SavedCXXThisTypeOverride(S.CXXThisTypeOverride), 998 SavedFunctionScopesStart(S.FunctionScopesStart), 999 SavedInventedParameterInfosStart(S.InventedParameterInfosStart) 1000 { 1001 assert(ContextToPush && "pushing null context"); 1002 S.CurContext = ContextToPush; 1003 if (NewThisContext) 1004 S.CXXThisTypeOverride = QualType(); 1005 // Any saved FunctionScopes do not refer to this context. 1006 S.FunctionScopesStart = S.FunctionScopes.size(); 1007 S.InventedParameterInfosStart = S.InventedParameterInfos.size(); 1008 } 1009 1010 void pop() { 1011 if (!SavedContext) return; 1012 S.CurContext = SavedContext; 1013 S.DelayedDiagnostics.popUndelayed(SavedContextState); 1014 S.CXXThisTypeOverride = SavedCXXThisTypeOverride; 1015 S.FunctionScopesStart = SavedFunctionScopesStart; 1016 S.InventedParameterInfosStart = SavedInventedParameterInfosStart; 1017 SavedContext = nullptr; 1018 } 1019 1020 ~ContextRAII() { 1021 pop(); 1022 } 1023 }; 1024 1025 /// Whether the AST is currently being rebuilt to correct immediate 1026 /// invocations. Immediate invocation candidates and references to consteval 1027 /// functions aren't tracked when this is set. 1028 bool RebuildingImmediateInvocation = false; 1029 1030 /// Used to change context to isConstantEvaluated without pushing a heavy 1031 /// ExpressionEvaluationContextRecord object. 1032 bool isConstantEvaluatedOverride; 1033 1034 bool isConstantEvaluated() { 1035 return ExprEvalContexts.back().isConstantEvaluated() || 1036 isConstantEvaluatedOverride; 1037 } 1038 1039 /// RAII object to handle the state changes required to synthesize 1040 /// a function body. 1041 class SynthesizedFunctionScope { 1042 Sema &S; 1043 Sema::ContextRAII SavedContext; 1044 bool PushedCodeSynthesisContext = false; 1045 1046 public: 1047 SynthesizedFunctionScope(Sema &S, DeclContext *DC) 1048 : S(S), SavedContext(S, DC) { 1049 S.PushFunctionScope(); 1050 S.PushExpressionEvaluationContext( 1051 Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 1052 if (auto *FD = dyn_cast<FunctionDecl>(DC)) 1053 FD->setWillHaveBody(true); 1054 else 1055 assert(isa<ObjCMethodDecl>(DC)); 1056 } 1057 1058 void addContextNote(SourceLocation UseLoc) { 1059 assert(!PushedCodeSynthesisContext); 1060 1061 Sema::CodeSynthesisContext Ctx; 1062 Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction; 1063 Ctx.PointOfInstantiation = UseLoc; 1064 Ctx.Entity = cast<Decl>(S.CurContext); 1065 S.pushCodeSynthesisContext(Ctx); 1066 1067 PushedCodeSynthesisContext = true; 1068 } 1069 1070 ~SynthesizedFunctionScope() { 1071 if (PushedCodeSynthesisContext) 1072 S.popCodeSynthesisContext(); 1073 if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext)) 1074 FD->setWillHaveBody(false); 1075 S.PopExpressionEvaluationContext(); 1076 S.PopFunctionScopeInfo(); 1077 } 1078 }; 1079 1080 /// WeakUndeclaredIdentifiers - Identifiers contained in 1081 /// \#pragma weak before declared. rare. may alias another 1082 /// identifier, declared or undeclared 1083 llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers; 1084 1085 /// ExtnameUndeclaredIdentifiers - Identifiers contained in 1086 /// \#pragma redefine_extname before declared. Used in Solaris system headers 1087 /// to define functions that occur in multiple standards to call the version 1088 /// in the currently selected standard. 1089 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers; 1090 1091 1092 /// Load weak undeclared identifiers from the external source. 1093 void LoadExternalWeakUndeclaredIdentifiers(); 1094 1095 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by 1096 /// \#pragma weak during processing of other Decls. 1097 /// I couldn't figure out a clean way to generate these in-line, so 1098 /// we store them here and handle separately -- which is a hack. 1099 /// It would be best to refactor this. 1100 SmallVector<Decl*,2> WeakTopLevelDecl; 1101 1102 IdentifierResolver IdResolver; 1103 1104 /// Translation Unit Scope - useful to Objective-C actions that need 1105 /// to lookup file scope declarations in the "ordinary" C decl namespace. 1106 /// For example, user-defined classes, built-in "id" type, etc. 1107 Scope *TUScope; 1108 1109 /// The C++ "std" namespace, where the standard library resides. 1110 LazyDeclPtr StdNamespace; 1111 1112 /// The C++ "std::bad_alloc" class, which is defined by the C++ 1113 /// standard library. 1114 LazyDeclPtr StdBadAlloc; 1115 1116 /// The C++ "std::align_val_t" enum class, which is defined by the C++ 1117 /// standard library. 1118 LazyDeclPtr StdAlignValT; 1119 1120 /// The C++ "std::experimental" namespace, where the experimental parts 1121 /// of the standard library resides. 1122 NamespaceDecl *StdExperimentalNamespaceCache; 1123 1124 /// The C++ "std::initializer_list" template, which is defined in 1125 /// \<initializer_list>. 1126 ClassTemplateDecl *StdInitializerList; 1127 1128 /// The C++ "std::coroutine_traits" template, which is defined in 1129 /// \<coroutine_traits> 1130 ClassTemplateDecl *StdCoroutineTraitsCache; 1131 1132 /// The C++ "type_info" declaration, which is defined in \<typeinfo>. 1133 RecordDecl *CXXTypeInfoDecl; 1134 1135 /// The MSVC "_GUID" struct, which is defined in MSVC header files. 1136 RecordDecl *MSVCGuidDecl; 1137 1138 /// Caches identifiers/selectors for NSFoundation APIs. 1139 std::unique_ptr<NSAPI> NSAPIObj; 1140 1141 /// The declaration of the Objective-C NSNumber class. 1142 ObjCInterfaceDecl *NSNumberDecl; 1143 1144 /// The declaration of the Objective-C NSValue class. 1145 ObjCInterfaceDecl *NSValueDecl; 1146 1147 /// Pointer to NSNumber type (NSNumber *). 1148 QualType NSNumberPointer; 1149 1150 /// Pointer to NSValue type (NSValue *). 1151 QualType NSValuePointer; 1152 1153 /// The Objective-C NSNumber methods used to create NSNumber literals. 1154 ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]; 1155 1156 /// The declaration of the Objective-C NSString class. 1157 ObjCInterfaceDecl *NSStringDecl; 1158 1159 /// Pointer to NSString type (NSString *). 1160 QualType NSStringPointer; 1161 1162 /// The declaration of the stringWithUTF8String: method. 1163 ObjCMethodDecl *StringWithUTF8StringMethod; 1164 1165 /// The declaration of the valueWithBytes:objCType: method. 1166 ObjCMethodDecl *ValueWithBytesObjCTypeMethod; 1167 1168 /// The declaration of the Objective-C NSArray class. 1169 ObjCInterfaceDecl *NSArrayDecl; 1170 1171 /// The declaration of the arrayWithObjects:count: method. 1172 ObjCMethodDecl *ArrayWithObjectsMethod; 1173 1174 /// The declaration of the Objective-C NSDictionary class. 1175 ObjCInterfaceDecl *NSDictionaryDecl; 1176 1177 /// The declaration of the dictionaryWithObjects:forKeys:count: method. 1178 ObjCMethodDecl *DictionaryWithObjectsMethod; 1179 1180 /// id<NSCopying> type. 1181 QualType QIDNSCopying; 1182 1183 /// will hold 'respondsToSelector:' 1184 Selector RespondsToSelectorSel; 1185 1186 /// A flag to remember whether the implicit forms of operator new and delete 1187 /// have been declared. 1188 bool GlobalNewDeleteDeclared; 1189 1190 /// Describes how the expressions currently being parsed are 1191 /// evaluated at run-time, if at all. 1192 enum class ExpressionEvaluationContext { 1193 /// The current expression and its subexpressions occur within an 1194 /// unevaluated operand (C++11 [expr]p7), such as the subexpression of 1195 /// \c sizeof, where the type of the expression may be significant but 1196 /// no code will be generated to evaluate the value of the expression at 1197 /// run time. 1198 Unevaluated, 1199 1200 /// The current expression occurs within a braced-init-list within 1201 /// an unevaluated operand. This is mostly like a regular unevaluated 1202 /// context, except that we still instantiate constexpr functions that are 1203 /// referenced here so that we can perform narrowing checks correctly. 1204 UnevaluatedList, 1205 1206 /// The current expression occurs within a discarded statement. 1207 /// This behaves largely similarly to an unevaluated operand in preventing 1208 /// definitions from being required, but not in other ways. 1209 DiscardedStatement, 1210 1211 /// The current expression occurs within an unevaluated 1212 /// operand that unconditionally permits abstract references to 1213 /// fields, such as a SIZE operator in MS-style inline assembly. 1214 UnevaluatedAbstract, 1215 1216 /// The current context is "potentially evaluated" in C++11 terms, 1217 /// but the expression is evaluated at compile-time (like the values of 1218 /// cases in a switch statement). 1219 ConstantEvaluated, 1220 1221 /// The current expression is potentially evaluated at run time, 1222 /// which means that code may be generated to evaluate the value of the 1223 /// expression at run time. 1224 PotentiallyEvaluated, 1225 1226 /// The current expression is potentially evaluated, but any 1227 /// declarations referenced inside that expression are only used if 1228 /// in fact the current expression is used. 1229 /// 1230 /// This value is used when parsing default function arguments, for which 1231 /// we would like to provide diagnostics (e.g., passing non-POD arguments 1232 /// through varargs) but do not want to mark declarations as "referenced" 1233 /// until the default argument is used. 1234 PotentiallyEvaluatedIfUsed 1235 }; 1236 1237 using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>; 1238 1239 /// Data structure used to record current or nested 1240 /// expression evaluation contexts. 1241 struct ExpressionEvaluationContextRecord { 1242 /// The expression evaluation context. 1243 ExpressionEvaluationContext Context; 1244 1245 /// Whether the enclosing context needed a cleanup. 1246 CleanupInfo ParentCleanup; 1247 1248 /// The number of active cleanup objects when we entered 1249 /// this expression evaluation context. 1250 unsigned NumCleanupObjects; 1251 1252 /// The number of typos encountered during this expression evaluation 1253 /// context (i.e. the number of TypoExprs created). 1254 unsigned NumTypos; 1255 1256 MaybeODRUseExprSet SavedMaybeODRUseExprs; 1257 1258 /// The lambdas that are present within this context, if it 1259 /// is indeed an unevaluated context. 1260 SmallVector<LambdaExpr *, 2> Lambdas; 1261 1262 /// The declaration that provides context for lambda expressions 1263 /// and block literals if the normal declaration context does not 1264 /// suffice, e.g., in a default function argument. 1265 Decl *ManglingContextDecl; 1266 1267 /// If we are processing a decltype type, a set of call expressions 1268 /// for which we have deferred checking the completeness of the return type. 1269 SmallVector<CallExpr *, 8> DelayedDecltypeCalls; 1270 1271 /// If we are processing a decltype type, a set of temporary binding 1272 /// expressions for which we have deferred checking the destructor. 1273 SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds; 1274 1275 llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs; 1276 1277 /// Expressions appearing as the LHS of a volatile assignment in this 1278 /// context. We produce a warning for these when popping the context if 1279 /// they are not discarded-value expressions nor unevaluated operands. 1280 SmallVector<Expr*, 2> VolatileAssignmentLHSs; 1281 1282 /// Set of candidates for starting an immediate invocation. 1283 llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates; 1284 1285 /// Set of DeclRefExprs referencing a consteval function when used in a 1286 /// context not already known to be immediately invoked. 1287 llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval; 1288 1289 /// \brief Describes whether we are in an expression constext which we have 1290 /// to handle differently. 1291 enum ExpressionKind { 1292 EK_Decltype, EK_TemplateArgument, EK_Other 1293 } ExprContext; 1294 1295 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context, 1296 unsigned NumCleanupObjects, 1297 CleanupInfo ParentCleanup, 1298 Decl *ManglingContextDecl, 1299 ExpressionKind ExprContext) 1300 : Context(Context), ParentCleanup(ParentCleanup), 1301 NumCleanupObjects(NumCleanupObjects), NumTypos(0), 1302 ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {} 1303 1304 bool isUnevaluated() const { 1305 return Context == ExpressionEvaluationContext::Unevaluated || 1306 Context == ExpressionEvaluationContext::UnevaluatedAbstract || 1307 Context == ExpressionEvaluationContext::UnevaluatedList; 1308 } 1309 bool isConstantEvaluated() const { 1310 return Context == ExpressionEvaluationContext::ConstantEvaluated; 1311 } 1312 }; 1313 1314 /// A stack of expression evaluation contexts. 1315 SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts; 1316 1317 /// Emit a warning for all pending noderef expressions that we recorded. 1318 void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec); 1319 1320 /// Compute the mangling number context for a lambda expression or 1321 /// block literal. Also return the extra mangling decl if any. 1322 /// 1323 /// \param DC - The DeclContext containing the lambda expression or 1324 /// block literal. 1325 std::tuple<MangleNumberingContext *, Decl *> 1326 getCurrentMangleNumberContext(const DeclContext *DC); 1327 1328 1329 /// SpecialMemberOverloadResult - The overloading result for a special member 1330 /// function. 1331 /// 1332 /// This is basically a wrapper around PointerIntPair. The lowest bits of the 1333 /// integer are used to determine whether overload resolution succeeded. 1334 class SpecialMemberOverloadResult { 1335 public: 1336 enum Kind { 1337 NoMemberOrDeleted, 1338 Ambiguous, 1339 Success 1340 }; 1341 1342 private: 1343 llvm::PointerIntPair<CXXMethodDecl*, 2> Pair; 1344 1345 public: 1346 SpecialMemberOverloadResult() : Pair() {} 1347 SpecialMemberOverloadResult(CXXMethodDecl *MD) 1348 : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {} 1349 1350 CXXMethodDecl *getMethod() const { return Pair.getPointer(); } 1351 void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); } 1352 1353 Kind getKind() const { return static_cast<Kind>(Pair.getInt()); } 1354 void setKind(Kind K) { Pair.setInt(K); } 1355 }; 1356 1357 class SpecialMemberOverloadResultEntry 1358 : public llvm::FastFoldingSetNode, 1359 public SpecialMemberOverloadResult { 1360 public: 1361 SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID) 1362 : FastFoldingSetNode(ID) 1363 {} 1364 }; 1365 1366 /// A cache of special member function overload resolution results 1367 /// for C++ records. 1368 llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache; 1369 1370 /// A cache of the flags available in enumerations with the flag_bits 1371 /// attribute. 1372 mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache; 1373 1374 /// The kind of translation unit we are processing. 1375 /// 1376 /// When we're processing a complete translation unit, Sema will perform 1377 /// end-of-translation-unit semantic tasks (such as creating 1378 /// initializers for tentative definitions in C) once parsing has 1379 /// completed. Modules and precompiled headers perform different kinds of 1380 /// checks. 1381 const TranslationUnitKind TUKind; 1382 1383 llvm::BumpPtrAllocator BumpAlloc; 1384 1385 /// The number of SFINAE diagnostics that have been trapped. 1386 unsigned NumSFINAEErrors; 1387 1388 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>> 1389 UnparsedDefaultArgInstantiationsMap; 1390 1391 /// A mapping from parameters with unparsed default arguments to the 1392 /// set of instantiations of each parameter. 1393 /// 1394 /// This mapping is a temporary data structure used when parsing 1395 /// nested class templates or nested classes of class templates, 1396 /// where we might end up instantiating an inner class before the 1397 /// default arguments of its methods have been parsed. 1398 UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations; 1399 1400 // Contains the locations of the beginning of unparsed default 1401 // argument locations. 1402 llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs; 1403 1404 /// UndefinedInternals - all the used, undefined objects which require a 1405 /// definition in this translation unit. 1406 llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed; 1407 1408 /// Determine if VD, which must be a variable or function, is an external 1409 /// symbol that nonetheless can't be referenced from outside this translation 1410 /// unit because its type has no linkage and it's not extern "C". 1411 bool isExternalWithNoLinkageType(ValueDecl *VD); 1412 1413 /// Obtain a sorted list of functions that are undefined but ODR-used. 1414 void getUndefinedButUsed( 1415 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined); 1416 1417 /// Retrieves list of suspicious delete-expressions that will be checked at 1418 /// the end of translation unit. 1419 const llvm::MapVector<FieldDecl *, DeleteLocs> & 1420 getMismatchingDeleteExpressions() const; 1421 1422 typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods; 1423 typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool; 1424 1425 /// Method Pool - allows efficient lookup when typechecking messages to "id". 1426 /// We need to maintain a list, since selectors can have differing signatures 1427 /// across classes. In Cocoa, this happens to be extremely uncommon (only 1% 1428 /// of selectors are "overloaded"). 1429 /// At the head of the list it is recorded whether there were 0, 1, or >= 2 1430 /// methods inside categories with a particular selector. 1431 GlobalMethodPool MethodPool; 1432 1433 /// Method selectors used in a \@selector expression. Used for implementation 1434 /// of -Wselector. 1435 llvm::MapVector<Selector, SourceLocation> ReferencedSelectors; 1436 1437 /// List of SourceLocations where 'self' is implicitly retained inside a 1438 /// block. 1439 llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1> 1440 ImplicitlyRetainedSelfLocs; 1441 1442 /// Kinds of C++ special members. 1443 enum CXXSpecialMember { 1444 CXXDefaultConstructor, 1445 CXXCopyConstructor, 1446 CXXMoveConstructor, 1447 CXXCopyAssignment, 1448 CXXMoveAssignment, 1449 CXXDestructor, 1450 CXXInvalid 1451 }; 1452 1453 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember> 1454 SpecialMemberDecl; 1455 1456 /// The C++ special members which we are currently in the process of 1457 /// declaring. If this process recursively triggers the declaration of the 1458 /// same special member, we should act as if it is not yet declared. 1459 llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared; 1460 1461 /// Kinds of defaulted comparison operator functions. 1462 enum class DefaultedComparisonKind : unsigned char { 1463 /// This is not a defaultable comparison operator. 1464 None, 1465 /// This is an operator== that should be implemented as a series of 1466 /// subobject comparisons. 1467 Equal, 1468 /// This is an operator<=> that should be implemented as a series of 1469 /// subobject comparisons. 1470 ThreeWay, 1471 /// This is an operator!= that should be implemented as a rewrite in terms 1472 /// of a == comparison. 1473 NotEqual, 1474 /// This is an <, <=, >, or >= that should be implemented as a rewrite in 1475 /// terms of a <=> comparison. 1476 Relational, 1477 }; 1478 1479 /// The function definitions which were renamed as part of typo-correction 1480 /// to match their respective declarations. We want to keep track of them 1481 /// to ensure that we don't emit a "redefinition" error if we encounter a 1482 /// correctly named definition after the renamed definition. 1483 llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions; 1484 1485 /// Stack of types that correspond to the parameter entities that are 1486 /// currently being copy-initialized. Can be empty. 1487 llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes; 1488 1489 void ReadMethodPool(Selector Sel); 1490 void updateOutOfDateSelector(Selector Sel); 1491 1492 /// Private Helper predicate to check for 'self'. 1493 bool isSelfExpr(Expr *RExpr); 1494 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method); 1495 1496 /// Cause the active diagnostic on the DiagosticsEngine to be 1497 /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and 1498 /// should not be used elsewhere. 1499 void EmitCurrentDiagnostic(unsigned DiagID); 1500 1501 /// Records and restores the CurFPFeatures state on entry/exit of compound 1502 /// statements. 1503 class FPFeaturesStateRAII { 1504 public: 1505 FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) { 1506 OldOverrides = S.FpPragmaStack.CurrentValue; 1507 } 1508 ~FPFeaturesStateRAII() { 1509 S.CurFPFeatures = OldFPFeaturesState; 1510 S.FpPragmaStack.CurrentValue = OldOverrides; 1511 } 1512 FPOptionsOverride getOverrides() { return OldOverrides; } 1513 1514 private: 1515 Sema& S; 1516 FPOptions OldFPFeaturesState; 1517 FPOptionsOverride OldOverrides; 1518 }; 1519 1520 void addImplicitTypedef(StringRef Name, QualType T); 1521 1522 bool WarnedStackExhausted = false; 1523 1524 /// Increment when we find a reference; decrement when we find an ignored 1525 /// assignment. Ultimately the value is 0 if every reference is an ignored 1526 /// assignment. 1527 llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments; 1528 1529 Optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo; 1530 1531 public: 1532 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 1533 TranslationUnitKind TUKind = TU_Complete, 1534 CodeCompleteConsumer *CompletionConsumer = nullptr); 1535 ~Sema(); 1536 1537 /// Perform initialization that occurs after the parser has been 1538 /// initialized but before it parses anything. 1539 void Initialize(); 1540 1541 /// This virtual key function only exists to limit the emission of debug info 1542 /// describing the Sema class. GCC and Clang only emit debug info for a class 1543 /// with a vtable when the vtable is emitted. Sema is final and not 1544 /// polymorphic, but the debug info size savings are so significant that it is 1545 /// worth adding a vtable just to take advantage of this optimization. 1546 virtual void anchor(); 1547 1548 const LangOptions &getLangOpts() const { return LangOpts; } 1549 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; } 1550 FPOptions &getCurFPFeatures() { return CurFPFeatures; } 1551 1552 DiagnosticsEngine &getDiagnostics() const { return Diags; } 1553 SourceManager &getSourceManager() const { return SourceMgr; } 1554 Preprocessor &getPreprocessor() const { return PP; } 1555 ASTContext &getASTContext() const { return Context; } 1556 ASTConsumer &getASTConsumer() const { return Consumer; } 1557 ASTMutationListener *getASTMutationListener() const; 1558 ExternalSemaSource* getExternalSource() const { return ExternalSource; } 1559 DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc, 1560 StringRef Platform); 1561 1562 ///Registers an external source. If an external source already exists, 1563 /// creates a multiplex external source and appends to it. 1564 /// 1565 ///\param[in] E - A non-null external sema source. 1566 /// 1567 void addExternalSource(ExternalSemaSource *E); 1568 1569 void PrintStats() const; 1570 1571 /// Warn that the stack is nearly exhausted. 1572 void warnStackExhausted(SourceLocation Loc); 1573 1574 /// Run some code with "sufficient" stack space. (Currently, at least 256K is 1575 /// guaranteed). Produces a warning if we're low on stack space and allocates 1576 /// more in that case. Use this in code that may recurse deeply (for example, 1577 /// in template instantiation) to avoid stack overflow. 1578 void runWithSufficientStackSpace(SourceLocation Loc, 1579 llvm::function_ref<void()> Fn); 1580 1581 /// Helper class that creates diagnostics with optional 1582 /// template instantiation stacks. 1583 /// 1584 /// This class provides a wrapper around the basic DiagnosticBuilder 1585 /// class that emits diagnostics. ImmediateDiagBuilder is 1586 /// responsible for emitting the diagnostic (as DiagnosticBuilder 1587 /// does) and, if the diagnostic comes from inside a template 1588 /// instantiation, printing the template instantiation stack as 1589 /// well. 1590 class ImmediateDiagBuilder : public DiagnosticBuilder { 1591 Sema &SemaRef; 1592 unsigned DiagID; 1593 1594 public: 1595 ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID) 1596 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {} 1597 ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID) 1598 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {} 1599 1600 // This is a cunning lie. DiagnosticBuilder actually performs move 1601 // construction in its copy constructor (but due to varied uses, it's not 1602 // possible to conveniently express this as actual move construction). So 1603 // the default copy ctor here is fine, because the base class disables the 1604 // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op 1605 // in that case anwyay. 1606 ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default; 1607 1608 ~ImmediateDiagBuilder() { 1609 // If we aren't active, there is nothing to do. 1610 if (!isActive()) return; 1611 1612 // Otherwise, we need to emit the diagnostic. First clear the diagnostic 1613 // builder itself so it won't emit the diagnostic in its own destructor. 1614 // 1615 // This seems wasteful, in that as written the DiagnosticBuilder dtor will 1616 // do its own needless checks to see if the diagnostic needs to be 1617 // emitted. However, because we take care to ensure that the builder 1618 // objects never escape, a sufficiently smart compiler will be able to 1619 // eliminate that code. 1620 Clear(); 1621 1622 // Dispatch to Sema to emit the diagnostic. 1623 SemaRef.EmitCurrentDiagnostic(DiagID); 1624 } 1625 1626 /// Teach operator<< to produce an object of the correct type. 1627 template <typename T> 1628 friend const ImmediateDiagBuilder & 1629 operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { 1630 const DiagnosticBuilder &BaseDiag = Diag; 1631 BaseDiag << Value; 1632 return Diag; 1633 } 1634 1635 // It is necessary to limit this to rvalue reference to avoid calling this 1636 // function with a bitfield lvalue argument since non-const reference to 1637 // bitfield is not allowed. 1638 template <typename T, typename = typename std::enable_if< 1639 !std::is_lvalue_reference<T>::value>::type> 1640 const ImmediateDiagBuilder &operator<<(T &&V) const { 1641 const DiagnosticBuilder &BaseDiag = *this; 1642 BaseDiag << std::move(V); 1643 return *this; 1644 } 1645 }; 1646 1647 /// A generic diagnostic builder for errors which may or may not be deferred. 1648 /// 1649 /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch) 1650 /// which are not allowed to appear inside __device__ functions and are 1651 /// allowed to appear in __host__ __device__ functions only if the host+device 1652 /// function is never codegen'ed. 1653 /// 1654 /// To handle this, we use the notion of "deferred diagnostics", where we 1655 /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed. 1656 /// 1657 /// This class lets you emit either a regular diagnostic, a deferred 1658 /// diagnostic, or no diagnostic at all, according to an argument you pass to 1659 /// its constructor, thus simplifying the process of creating these "maybe 1660 /// deferred" diagnostics. 1661 class SemaDiagnosticBuilder { 1662 public: 1663 enum Kind { 1664 /// Emit no diagnostics. 1665 K_Nop, 1666 /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()). 1667 K_Immediate, 1668 /// Emit the diagnostic immediately, and, if it's a warning or error, also 1669 /// emit a call stack showing how this function can be reached by an a 1670 /// priori known-emitted function. 1671 K_ImmediateWithCallStack, 1672 /// Create a deferred diagnostic, which is emitted only if the function 1673 /// it's attached to is codegen'ed. Also emit a call stack as with 1674 /// K_ImmediateWithCallStack. 1675 K_Deferred 1676 }; 1677 1678 SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID, 1679 FunctionDecl *Fn, Sema &S); 1680 SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D); 1681 SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default; 1682 ~SemaDiagnosticBuilder(); 1683 1684 bool isImmediate() const { return ImmediateDiag.hasValue(); } 1685 1686 /// Convertible to bool: True if we immediately emitted an error, false if 1687 /// we didn't emit an error or we created a deferred error. 1688 /// 1689 /// Example usage: 1690 /// 1691 /// if (SemaDiagnosticBuilder(...) << foo << bar) 1692 /// return ExprError(); 1693 /// 1694 /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably 1695 /// want to use these instead of creating a SemaDiagnosticBuilder yourself. 1696 operator bool() const { return isImmediate(); } 1697 1698 template <typename T> 1699 friend const SemaDiagnosticBuilder & 1700 operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { 1701 if (Diag.ImmediateDiag.hasValue()) 1702 *Diag.ImmediateDiag << Value; 1703 else if (Diag.PartialDiagId.hasValue()) 1704 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second 1705 << Value; 1706 return Diag; 1707 } 1708 1709 // It is necessary to limit this to rvalue reference to avoid calling this 1710 // function with a bitfield lvalue argument since non-const reference to 1711 // bitfield is not allowed. 1712 template <typename T, typename = typename std::enable_if< 1713 !std::is_lvalue_reference<T>::value>::type> 1714 const SemaDiagnosticBuilder &operator<<(T &&V) const { 1715 if (ImmediateDiag.hasValue()) 1716 *ImmediateDiag << std::move(V); 1717 else if (PartialDiagId.hasValue()) 1718 S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V); 1719 return *this; 1720 } 1721 1722 friend const SemaDiagnosticBuilder & 1723 operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) { 1724 if (Diag.ImmediateDiag.hasValue()) 1725 PD.Emit(*Diag.ImmediateDiag); 1726 else if (Diag.PartialDiagId.hasValue()) 1727 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD; 1728 return Diag; 1729 } 1730 1731 void AddFixItHint(const FixItHint &Hint) const { 1732 if (ImmediateDiag.hasValue()) 1733 ImmediateDiag->AddFixItHint(Hint); 1734 else if (PartialDiagId.hasValue()) 1735 S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint); 1736 } 1737 1738 friend ExprResult ExprError(const SemaDiagnosticBuilder &) { 1739 return ExprError(); 1740 } 1741 friend StmtResult StmtError(const SemaDiagnosticBuilder &) { 1742 return StmtError(); 1743 } 1744 operator ExprResult() const { return ExprError(); } 1745 operator StmtResult() const { return StmtError(); } 1746 operator TypeResult() const { return TypeError(); } 1747 operator DeclResult() const { return DeclResult(true); } 1748 operator MemInitResult() const { return MemInitResult(true); } 1749 1750 private: 1751 Sema &S; 1752 SourceLocation Loc; 1753 unsigned DiagID; 1754 FunctionDecl *Fn; 1755 bool ShowCallStack; 1756 1757 // Invariant: At most one of these Optionals has a value. 1758 // FIXME: Switch these to a Variant once that exists. 1759 llvm::Optional<ImmediateDiagBuilder> ImmediateDiag; 1760 llvm::Optional<unsigned> PartialDiagId; 1761 }; 1762 1763 /// Is the last error level diagnostic immediate. This is used to determined 1764 /// whether the next info diagnostic should be immediate. 1765 bool IsLastErrorImmediate = true; 1766 1767 /// Emit a diagnostic. 1768 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, 1769 bool DeferHint = false); 1770 1771 /// Emit a partial diagnostic. 1772 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD, 1773 bool DeferHint = false); 1774 1775 /// Build a partial diagnostic. 1776 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h 1777 1778 /// Whether deferrable diagnostics should be deferred. 1779 bool DeferDiags = false; 1780 1781 /// RAII class to control scope of DeferDiags. 1782 class DeferDiagsRAII { 1783 Sema &S; 1784 bool SavedDeferDiags = false; 1785 1786 public: 1787 DeferDiagsRAII(Sema &S, bool DeferDiags) 1788 : S(S), SavedDeferDiags(S.DeferDiags) { 1789 S.DeferDiags = DeferDiags; 1790 } 1791 ~DeferDiagsRAII() { S.DeferDiags = SavedDeferDiags; } 1792 }; 1793 1794 /// Whether uncompilable error has occurred. This includes error happens 1795 /// in deferred diagnostics. 1796 bool hasUncompilableErrorOccurred() const; 1797 1798 bool findMacroSpelling(SourceLocation &loc, StringRef name); 1799 1800 /// Get a string to suggest for zero-initialization of a type. 1801 std::string 1802 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const; 1803 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const; 1804 1805 /// Calls \c Lexer::getLocForEndOfToken() 1806 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0); 1807 1808 /// Retrieve the module loader associated with the preprocessor. 1809 ModuleLoader &getModuleLoader() const; 1810 1811 /// Invent a new identifier for parameters of abbreviated templates. 1812 IdentifierInfo * 1813 InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName, 1814 unsigned Index); 1815 1816 void emitAndClearUnusedLocalTypedefWarnings(); 1817 1818 private: 1819 /// Function or variable declarations to be checked for whether the deferred 1820 /// diagnostics should be emitted. 1821 llvm::SmallSetVector<Decl *, 4> DeclsToCheckForDeferredDiags; 1822 1823 public: 1824 // Emit all deferred diagnostics. 1825 void emitDeferredDiags(); 1826 1827 enum TUFragmentKind { 1828 /// The global module fragment, between 'module;' and a module-declaration. 1829 Global, 1830 /// A normal translation unit fragment. For a non-module unit, this is the 1831 /// entire translation unit. Otherwise, it runs from the module-declaration 1832 /// to the private-module-fragment (if any) or the end of the TU (if not). 1833 Normal, 1834 /// The private module fragment, between 'module :private;' and the end of 1835 /// the translation unit. 1836 Private 1837 }; 1838 1839 void ActOnStartOfTranslationUnit(); 1840 void ActOnEndOfTranslationUnit(); 1841 void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind); 1842 1843 void CheckDelegatingCtorCycles(); 1844 1845 Scope *getScopeForContext(DeclContext *Ctx); 1846 1847 void PushFunctionScope(); 1848 void PushBlockScope(Scope *BlockScope, BlockDecl *Block); 1849 sema::LambdaScopeInfo *PushLambdaScope(); 1850 1851 /// This is used to inform Sema what the current TemplateParameterDepth 1852 /// is during Parsing. Currently it is used to pass on the depth 1853 /// when parsing generic lambda 'auto' parameters. 1854 void RecordParsingTemplateParameterDepth(unsigned Depth); 1855 1856 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, 1857 RecordDecl *RD, CapturedRegionKind K, 1858 unsigned OpenMPCaptureLevel = 0); 1859 1860 /// Custom deleter to allow FunctionScopeInfos to be kept alive for a short 1861 /// time after they've been popped. 1862 class PoppedFunctionScopeDeleter { 1863 Sema *Self; 1864 1865 public: 1866 explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {} 1867 void operator()(sema::FunctionScopeInfo *Scope) const; 1868 }; 1869 1870 using PoppedFunctionScopePtr = 1871 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>; 1872 1873 PoppedFunctionScopePtr 1874 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr, 1875 const Decl *D = nullptr, 1876 QualType BlockType = QualType()); 1877 1878 sema::FunctionScopeInfo *getCurFunction() const { 1879 return FunctionScopes.empty() ? nullptr : FunctionScopes.back(); 1880 } 1881 1882 sema::FunctionScopeInfo *getEnclosingFunction() const; 1883 1884 void setFunctionHasBranchIntoScope(); 1885 void setFunctionHasBranchProtectedScope(); 1886 void setFunctionHasIndirectGoto(); 1887 void setFunctionHasMustTail(); 1888 1889 void PushCompoundScope(bool IsStmtExpr); 1890 void PopCompoundScope(); 1891 1892 sema::CompoundScopeInfo &getCurCompoundScope() const; 1893 1894 bool hasAnyUnrecoverableErrorsInThisFunction() const; 1895 1896 /// Retrieve the current block, if any. 1897 sema::BlockScopeInfo *getCurBlock(); 1898 1899 /// Get the innermost lambda enclosing the current location, if any. This 1900 /// looks through intervening non-lambda scopes such as local functions and 1901 /// blocks. 1902 sema::LambdaScopeInfo *getEnclosingLambda() const; 1903 1904 /// Retrieve the current lambda scope info, if any. 1905 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most 1906 /// lambda scope info ignoring all inner capturing scopes that are not 1907 /// lambda scopes. 1908 sema::LambdaScopeInfo * 1909 getCurLambda(bool IgnoreNonLambdaCapturingScope = false); 1910 1911 /// Retrieve the current generic lambda info, if any. 1912 sema::LambdaScopeInfo *getCurGenericLambda(); 1913 1914 /// Retrieve the current captured region, if any. 1915 sema::CapturedRegionScopeInfo *getCurCapturedRegion(); 1916 1917 /// Retrieve the current function, if any, that should be analyzed for 1918 /// potential availability violations. 1919 sema::FunctionScopeInfo *getCurFunctionAvailabilityContext(); 1920 1921 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls 1922 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; } 1923 1924 /// Called before parsing a function declarator belonging to a function 1925 /// declaration. 1926 void ActOnStartFunctionDeclarationDeclarator(Declarator &D, 1927 unsigned TemplateParameterDepth); 1928 1929 /// Called after parsing a function declarator belonging to a function 1930 /// declaration. 1931 void ActOnFinishFunctionDeclarationDeclarator(Declarator &D); 1932 1933 void ActOnComment(SourceRange Comment); 1934 1935 //===--------------------------------------------------------------------===// 1936 // Type Analysis / Processing: SemaType.cpp. 1937 // 1938 1939 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, 1940 const DeclSpec *DS = nullptr); 1941 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA, 1942 const DeclSpec *DS = nullptr); 1943 QualType BuildPointerType(QualType T, 1944 SourceLocation Loc, DeclarationName Entity); 1945 QualType BuildReferenceType(QualType T, bool LValueRef, 1946 SourceLocation Loc, DeclarationName Entity); 1947 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, 1948 Expr *ArraySize, unsigned Quals, 1949 SourceRange Brackets, DeclarationName Entity); 1950 QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc); 1951 QualType BuildExtVectorType(QualType T, Expr *ArraySize, 1952 SourceLocation AttrLoc); 1953 QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns, 1954 SourceLocation AttrLoc); 1955 1956 QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, 1957 SourceLocation AttrLoc); 1958 1959 /// Same as above, but constructs the AddressSpace index if not provided. 1960 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace, 1961 SourceLocation AttrLoc); 1962 1963 bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc); 1964 1965 bool CheckFunctionReturnType(QualType T, SourceLocation Loc); 1966 1967 /// Build a function type. 1968 /// 1969 /// This routine checks the function type according to C++ rules and 1970 /// under the assumption that the result type and parameter types have 1971 /// just been instantiated from a template. It therefore duplicates 1972 /// some of the behavior of GetTypeForDeclarator, but in a much 1973 /// simpler form that is only suitable for this narrow use case. 1974 /// 1975 /// \param T The return type of the function. 1976 /// 1977 /// \param ParamTypes The parameter types of the function. This array 1978 /// will be modified to account for adjustments to the types of the 1979 /// function parameters. 1980 /// 1981 /// \param Loc The location of the entity whose type involves this 1982 /// function type or, if there is no such entity, the location of the 1983 /// type that will have function type. 1984 /// 1985 /// \param Entity The name of the entity that involves the function 1986 /// type, if known. 1987 /// 1988 /// \param EPI Extra information about the function type. Usually this will 1989 /// be taken from an existing function with the same prototype. 1990 /// 1991 /// \returns A suitable function type, if there are no errors. The 1992 /// unqualified type will always be a FunctionProtoType. 1993 /// Otherwise, returns a NULL type. 1994 QualType BuildFunctionType(QualType T, 1995 MutableArrayRef<QualType> ParamTypes, 1996 SourceLocation Loc, DeclarationName Entity, 1997 const FunctionProtoType::ExtProtoInfo &EPI); 1998 1999 QualType BuildMemberPointerType(QualType T, QualType Class, 2000 SourceLocation Loc, 2001 DeclarationName Entity); 2002 QualType BuildBlockPointerType(QualType T, 2003 SourceLocation Loc, DeclarationName Entity); 2004 QualType BuildParenType(QualType T); 2005 QualType BuildAtomicType(QualType T, SourceLocation Loc); 2006 QualType BuildReadPipeType(QualType T, 2007 SourceLocation Loc); 2008 QualType BuildWritePipeType(QualType T, 2009 SourceLocation Loc); 2010 QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc); 2011 2012 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S); 2013 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy); 2014 2015 /// Package the given type and TSI into a ParsedType. 2016 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo); 2017 DeclarationNameInfo GetNameForDeclarator(Declarator &D); 2018 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name); 2019 static QualType GetTypeFromParser(ParsedType Ty, 2020 TypeSourceInfo **TInfo = nullptr); 2021 CanThrowResult canThrow(const Stmt *E); 2022 /// Determine whether the callee of a particular function call can throw. 2023 /// E, D and Loc are all optional. 2024 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D, 2025 SourceLocation Loc = SourceLocation()); 2026 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc, 2027 const FunctionProtoType *FPT); 2028 void UpdateExceptionSpec(FunctionDecl *FD, 2029 const FunctionProtoType::ExceptionSpecInfo &ESI); 2030 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range); 2031 bool CheckDistantExceptionSpec(QualType T); 2032 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New); 2033 bool CheckEquivalentExceptionSpec( 2034 const FunctionProtoType *Old, SourceLocation OldLoc, 2035 const FunctionProtoType *New, SourceLocation NewLoc); 2036 bool CheckEquivalentExceptionSpec( 2037 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID, 2038 const FunctionProtoType *Old, SourceLocation OldLoc, 2039 const FunctionProtoType *New, SourceLocation NewLoc); 2040 bool handlerCanCatch(QualType HandlerType, QualType ExceptionType); 2041 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID, 2042 const PartialDiagnostic &NestedDiagID, 2043 const PartialDiagnostic &NoteID, 2044 const PartialDiagnostic &NoThrowDiagID, 2045 const FunctionProtoType *Superset, 2046 SourceLocation SuperLoc, 2047 const FunctionProtoType *Subset, 2048 SourceLocation SubLoc); 2049 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID, 2050 const PartialDiagnostic &NoteID, 2051 const FunctionProtoType *Target, 2052 SourceLocation TargetLoc, 2053 const FunctionProtoType *Source, 2054 SourceLocation SourceLoc); 2055 2056 TypeResult ActOnTypeName(Scope *S, Declarator &D); 2057 2058 /// The parser has parsed the context-sensitive type 'instancetype' 2059 /// in an Objective-C message declaration. Return the appropriate type. 2060 ParsedType ActOnObjCInstanceType(SourceLocation Loc); 2061 2062 /// Abstract class used to diagnose incomplete types. 2063 struct TypeDiagnoser { 2064 TypeDiagnoser() {} 2065 2066 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0; 2067 virtual ~TypeDiagnoser() {} 2068 }; 2069 2070 static int getPrintable(int I) { return I; } 2071 static unsigned getPrintable(unsigned I) { return I; } 2072 static bool getPrintable(bool B) { return B; } 2073 static const char * getPrintable(const char *S) { return S; } 2074 static StringRef getPrintable(StringRef S) { return S; } 2075 static const std::string &getPrintable(const std::string &S) { return S; } 2076 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) { 2077 return II; 2078 } 2079 static DeclarationName getPrintable(DeclarationName N) { return N; } 2080 static QualType getPrintable(QualType T) { return T; } 2081 static SourceRange getPrintable(SourceRange R) { return R; } 2082 static SourceRange getPrintable(SourceLocation L) { return L; } 2083 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); } 2084 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();} 2085 2086 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser { 2087 protected: 2088 unsigned DiagID; 2089 std::tuple<const Ts &...> Args; 2090 2091 template <std::size_t... Is> 2092 void emit(const SemaDiagnosticBuilder &DB, 2093 std::index_sequence<Is...>) const { 2094 // Apply all tuple elements to the builder in order. 2095 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...}; 2096 (void)Dummy; 2097 } 2098 2099 public: 2100 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args) 2101 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) { 2102 assert(DiagID != 0 && "no diagnostic for type diagnoser"); 2103 } 2104 2105 void diagnose(Sema &S, SourceLocation Loc, QualType T) override { 2106 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID); 2107 emit(DB, std::index_sequence_for<Ts...>()); 2108 DB << T; 2109 } 2110 }; 2111 2112 /// Do a check to make sure \p Name looks like a legal argument for the 2113 /// swift_name attribute applied to decl \p D. Raise a diagnostic if the name 2114 /// is invalid for the given declaration. 2115 /// 2116 /// \p AL is used to provide caret diagnostics in case of a malformed name. 2117 /// 2118 /// \returns true if the name is a valid swift name for \p D, false otherwise. 2119 bool DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, 2120 const ParsedAttr &AL, bool IsAsync); 2121 2122 /// A derivative of BoundTypeDiagnoser for which the diagnostic's type 2123 /// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless. 2124 /// For example, a diagnostic with no other parameters would generally have 2125 /// the form "...%select{incomplete|sizeless}0 type %1...". 2126 template <typename... Ts> 2127 class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> { 2128 public: 2129 SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args) 2130 : BoundTypeDiagnoser<Ts...>(DiagID, Args...) {} 2131 2132 void diagnose(Sema &S, SourceLocation Loc, QualType T) override { 2133 const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID); 2134 this->emit(DB, std::index_sequence_for<Ts...>()); 2135 DB << T->isSizelessType() << T; 2136 } 2137 }; 2138 2139 enum class CompleteTypeKind { 2140 /// Apply the normal rules for complete types. In particular, 2141 /// treat all sizeless types as incomplete. 2142 Normal, 2143 2144 /// Relax the normal rules for complete types so that they include 2145 /// sizeless built-in types. 2146 AcceptSizeless, 2147 2148 // FIXME: Eventually we should flip the default to Normal and opt in 2149 // to AcceptSizeless rather than opt out of it. 2150 Default = AcceptSizeless 2151 }; 2152 2153 private: 2154 /// Methods for marking which expressions involve dereferencing a pointer 2155 /// marked with the 'noderef' attribute. Expressions are checked bottom up as 2156 /// they are parsed, meaning that a noderef pointer may not be accessed. For 2157 /// example, in `&*p` where `p` is a noderef pointer, we will first parse the 2158 /// `*p`, but need to check that `address of` is called on it. This requires 2159 /// keeping a container of all pending expressions and checking if the address 2160 /// of them are eventually taken. 2161 void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E); 2162 void CheckAddressOfNoDeref(const Expr *E); 2163 void CheckMemberAccessOfNoDeref(const MemberExpr *E); 2164 2165 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T, 2166 CompleteTypeKind Kind, TypeDiagnoser *Diagnoser); 2167 2168 struct ModuleScope { 2169 SourceLocation BeginLoc; 2170 clang::Module *Module = nullptr; 2171 bool ModuleInterface = false; 2172 bool ImplicitGlobalModuleFragment = false; 2173 VisibleModuleSet OuterVisibleModules; 2174 }; 2175 /// The modules we're currently parsing. 2176 llvm::SmallVector<ModuleScope, 16> ModuleScopes; 2177 2178 /// Namespace definitions that we will export when they finish. 2179 llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces; 2180 2181 /// Get the module whose scope we are currently within. 2182 Module *getCurrentModule() const { 2183 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module; 2184 } 2185 2186 VisibleModuleSet VisibleModules; 2187 2188 public: 2189 /// Get the module owning an entity. 2190 Module *getOwningModule(const Decl *Entity) { 2191 return Entity->getOwningModule(); 2192 } 2193 2194 /// Make a merged definition of an existing hidden definition \p ND 2195 /// visible at the specified location. 2196 void makeMergedDefinitionVisible(NamedDecl *ND); 2197 2198 bool isModuleVisible(const Module *M, bool ModulePrivate = false); 2199 2200 // When loading a non-modular PCH files, this is used to restore module 2201 // visibility. 2202 void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) { 2203 VisibleModules.setVisible(Mod, ImportLoc); 2204 } 2205 2206 /// Determine whether a declaration is visible to name lookup. 2207 bool isVisible(const NamedDecl *D) { 2208 return D->isUnconditionallyVisible() || isVisibleSlow(D); 2209 } 2210 2211 /// Determine whether any declaration of an entity is visible. 2212 bool 2213 hasVisibleDeclaration(const NamedDecl *D, 2214 llvm::SmallVectorImpl<Module *> *Modules = nullptr) { 2215 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules); 2216 } 2217 bool hasVisibleDeclarationSlow(const NamedDecl *D, 2218 llvm::SmallVectorImpl<Module *> *Modules); 2219 2220 bool hasVisibleMergedDefinition(NamedDecl *Def); 2221 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def); 2222 2223 /// Determine if \p D and \p Suggested have a structurally compatible 2224 /// layout as described in C11 6.2.7/1. 2225 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested); 2226 2227 /// Determine if \p D has a visible definition. If not, suggest a declaration 2228 /// that should be made visible to expose the definition. 2229 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, 2230 bool OnlyNeedComplete = false); 2231 bool hasVisibleDefinition(const NamedDecl *D) { 2232 NamedDecl *Hidden; 2233 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden); 2234 } 2235 2236 /// Determine if the template parameter \p D has a visible default argument. 2237 bool 2238 hasVisibleDefaultArgument(const NamedDecl *D, 2239 llvm::SmallVectorImpl<Module *> *Modules = nullptr); 2240 2241 /// Determine if there is a visible declaration of \p D that is an explicit 2242 /// specialization declaration for a specialization of a template. (For a 2243 /// member specialization, use hasVisibleMemberSpecialization.) 2244 bool hasVisibleExplicitSpecialization( 2245 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr); 2246 2247 /// Determine if there is a visible declaration of \p D that is a member 2248 /// specialization declaration (as opposed to an instantiated declaration). 2249 bool hasVisibleMemberSpecialization( 2250 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr); 2251 2252 /// Determine if \p A and \p B are equivalent internal linkage declarations 2253 /// from different modules, and thus an ambiguity error can be downgraded to 2254 /// an extension warning. 2255 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A, 2256 const NamedDecl *B); 2257 void diagnoseEquivalentInternalLinkageDeclarations( 2258 SourceLocation Loc, const NamedDecl *D, 2259 ArrayRef<const NamedDecl *> Equiv); 2260 2261 bool isUsualDeallocationFunction(const CXXMethodDecl *FD); 2262 2263 bool isCompleteType(SourceLocation Loc, QualType T, 2264 CompleteTypeKind Kind = CompleteTypeKind::Default) { 2265 return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr); 2266 } 2267 bool RequireCompleteType(SourceLocation Loc, QualType T, 2268 CompleteTypeKind Kind, TypeDiagnoser &Diagnoser); 2269 bool RequireCompleteType(SourceLocation Loc, QualType T, 2270 CompleteTypeKind Kind, unsigned DiagID); 2271 2272 bool RequireCompleteType(SourceLocation Loc, QualType T, 2273 TypeDiagnoser &Diagnoser) { 2274 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser); 2275 } 2276 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) { 2277 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID); 2278 } 2279 2280 template <typename... Ts> 2281 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID, 2282 const Ts &...Args) { 2283 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2284 return RequireCompleteType(Loc, T, Diagnoser); 2285 } 2286 2287 template <typename... Ts> 2288 bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, 2289 const Ts &... Args) { 2290 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2291 return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser); 2292 } 2293 2294 /// Get the type of expression E, triggering instantiation to complete the 2295 /// type if necessary -- that is, if the expression refers to a templated 2296 /// static data member of incomplete array type. 2297 /// 2298 /// May still return an incomplete type if instantiation was not possible or 2299 /// if the type is incomplete for a different reason. Use 2300 /// RequireCompleteExprType instead if a diagnostic is expected for an 2301 /// incomplete expression type. 2302 QualType getCompletedType(Expr *E); 2303 2304 void completeExprArrayBound(Expr *E); 2305 bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, 2306 TypeDiagnoser &Diagnoser); 2307 bool RequireCompleteExprType(Expr *E, unsigned DiagID); 2308 2309 template <typename... Ts> 2310 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) { 2311 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2312 return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser); 2313 } 2314 2315 template <typename... Ts> 2316 bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID, 2317 const Ts &... Args) { 2318 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2319 return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser); 2320 } 2321 2322 bool RequireLiteralType(SourceLocation Loc, QualType T, 2323 TypeDiagnoser &Diagnoser); 2324 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID); 2325 2326 template <typename... Ts> 2327 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID, 2328 const Ts &...Args) { 2329 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 2330 return RequireLiteralType(Loc, T, Diagnoser); 2331 } 2332 2333 QualType getElaboratedType(ElaboratedTypeKeyword Keyword, 2334 const CXXScopeSpec &SS, QualType T, 2335 TagDecl *OwnedTagDecl = nullptr); 2336 2337 QualType getDecltypeForParenthesizedExpr(Expr *E); 2338 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc); 2339 /// If AsUnevaluated is false, E is treated as though it were an evaluated 2340 /// context, such as when building a type for decltype(auto). 2341 QualType BuildDecltypeType(Expr *E, SourceLocation Loc, 2342 bool AsUnevaluated = true); 2343 QualType BuildUnaryTransformType(QualType BaseType, 2344 UnaryTransformType::UTTKind UKind, 2345 SourceLocation Loc); 2346 2347 //===--------------------------------------------------------------------===// 2348 // Symbol table / Decl tracking callbacks: SemaDecl.cpp. 2349 // 2350 2351 struct SkipBodyInfo { 2352 SkipBodyInfo() 2353 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr), 2354 New(nullptr) {} 2355 bool ShouldSkip; 2356 bool CheckSameAsPrevious; 2357 NamedDecl *Previous; 2358 NamedDecl *New; 2359 }; 2360 2361 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr); 2362 2363 void DiagnoseUseOfUnimplementedSelectors(); 2364 2365 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const; 2366 2367 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 2368 Scope *S, CXXScopeSpec *SS = nullptr, 2369 bool isClassName = false, bool HasTrailingDot = false, 2370 ParsedType ObjectType = nullptr, 2371 bool IsCtorOrDtorName = false, 2372 bool WantNontrivialTypeSourceInfo = false, 2373 bool IsClassTemplateDeductionContext = true, 2374 IdentifierInfo **CorrectedII = nullptr); 2375 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S); 2376 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S); 2377 void DiagnoseUnknownTypeName(IdentifierInfo *&II, 2378 SourceLocation IILoc, 2379 Scope *S, 2380 CXXScopeSpec *SS, 2381 ParsedType &SuggestedType, 2382 bool IsTemplateName = false); 2383 2384 /// Attempt to behave like MSVC in situations where lookup of an unqualified 2385 /// type name has failed in a dependent context. In these situations, we 2386 /// automatically form a DependentTypeName that will retry lookup in a related 2387 /// scope during instantiation. 2388 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, 2389 SourceLocation NameLoc, 2390 bool IsTemplateTypeArg); 2391 2392 /// Describes the result of the name lookup and resolution performed 2393 /// by \c ClassifyName(). 2394 enum NameClassificationKind { 2395 /// This name is not a type or template in this context, but might be 2396 /// something else. 2397 NC_Unknown, 2398 /// Classification failed; an error has been produced. 2399 NC_Error, 2400 /// The name has been typo-corrected to a keyword. 2401 NC_Keyword, 2402 /// The name was classified as a type. 2403 NC_Type, 2404 /// The name was classified as a specific non-type, non-template 2405 /// declaration. ActOnNameClassifiedAsNonType should be called to 2406 /// convert the declaration to an expression. 2407 NC_NonType, 2408 /// The name was classified as an ADL-only function name. 2409 /// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the 2410 /// result to an expression. 2411 NC_UndeclaredNonType, 2412 /// The name denotes a member of a dependent type that could not be 2413 /// resolved. ActOnNameClassifiedAsDependentNonType should be called to 2414 /// convert the result to an expression. 2415 NC_DependentNonType, 2416 /// The name was classified as an overload set, and an expression 2417 /// representing that overload set has been formed. 2418 /// ActOnNameClassifiedAsOverloadSet should be called to form a suitable 2419 /// expression referencing the overload set. 2420 NC_OverloadSet, 2421 /// The name was classified as a template whose specializations are types. 2422 NC_TypeTemplate, 2423 /// The name was classified as a variable template name. 2424 NC_VarTemplate, 2425 /// The name was classified as a function template name. 2426 NC_FunctionTemplate, 2427 /// The name was classified as an ADL-only function template name. 2428 NC_UndeclaredTemplate, 2429 /// The name was classified as a concept name. 2430 NC_Concept, 2431 }; 2432 2433 class NameClassification { 2434 NameClassificationKind Kind; 2435 union { 2436 ExprResult Expr; 2437 NamedDecl *NonTypeDecl; 2438 TemplateName Template; 2439 ParsedType Type; 2440 }; 2441 2442 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {} 2443 2444 public: 2445 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {} 2446 2447 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {} 2448 2449 static NameClassification Error() { 2450 return NameClassification(NC_Error); 2451 } 2452 2453 static NameClassification Unknown() { 2454 return NameClassification(NC_Unknown); 2455 } 2456 2457 static NameClassification OverloadSet(ExprResult E) { 2458 NameClassification Result(NC_OverloadSet); 2459 Result.Expr = E; 2460 return Result; 2461 } 2462 2463 static NameClassification NonType(NamedDecl *D) { 2464 NameClassification Result(NC_NonType); 2465 Result.NonTypeDecl = D; 2466 return Result; 2467 } 2468 2469 static NameClassification UndeclaredNonType() { 2470 return NameClassification(NC_UndeclaredNonType); 2471 } 2472 2473 static NameClassification DependentNonType() { 2474 return NameClassification(NC_DependentNonType); 2475 } 2476 2477 static NameClassification TypeTemplate(TemplateName Name) { 2478 NameClassification Result(NC_TypeTemplate); 2479 Result.Template = Name; 2480 return Result; 2481 } 2482 2483 static NameClassification VarTemplate(TemplateName Name) { 2484 NameClassification Result(NC_VarTemplate); 2485 Result.Template = Name; 2486 return Result; 2487 } 2488 2489 static NameClassification FunctionTemplate(TemplateName Name) { 2490 NameClassification Result(NC_FunctionTemplate); 2491 Result.Template = Name; 2492 return Result; 2493 } 2494 2495 static NameClassification Concept(TemplateName Name) { 2496 NameClassification Result(NC_Concept); 2497 Result.Template = Name; 2498 return Result; 2499 } 2500 2501 static NameClassification UndeclaredTemplate(TemplateName Name) { 2502 NameClassification Result(NC_UndeclaredTemplate); 2503 Result.Template = Name; 2504 return Result; 2505 } 2506 2507 NameClassificationKind getKind() const { return Kind; } 2508 2509 ExprResult getExpression() const { 2510 assert(Kind == NC_OverloadSet); 2511 return Expr; 2512 } 2513 2514 ParsedType getType() const { 2515 assert(Kind == NC_Type); 2516 return Type; 2517 } 2518 2519 NamedDecl *getNonTypeDecl() const { 2520 assert(Kind == NC_NonType); 2521 return NonTypeDecl; 2522 } 2523 2524 TemplateName getTemplateName() const { 2525 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate || 2526 Kind == NC_VarTemplate || Kind == NC_Concept || 2527 Kind == NC_UndeclaredTemplate); 2528 return Template; 2529 } 2530 2531 TemplateNameKind getTemplateNameKind() const { 2532 switch (Kind) { 2533 case NC_TypeTemplate: 2534 return TNK_Type_template; 2535 case NC_FunctionTemplate: 2536 return TNK_Function_template; 2537 case NC_VarTemplate: 2538 return TNK_Var_template; 2539 case NC_Concept: 2540 return TNK_Concept_template; 2541 case NC_UndeclaredTemplate: 2542 return TNK_Undeclared_template; 2543 default: 2544 llvm_unreachable("unsupported name classification."); 2545 } 2546 } 2547 }; 2548 2549 /// Perform name lookup on the given name, classifying it based on 2550 /// the results of name lookup and the following token. 2551 /// 2552 /// This routine is used by the parser to resolve identifiers and help direct 2553 /// parsing. When the identifier cannot be found, this routine will attempt 2554 /// to correct the typo and classify based on the resulting name. 2555 /// 2556 /// \param S The scope in which we're performing name lookup. 2557 /// 2558 /// \param SS The nested-name-specifier that precedes the name. 2559 /// 2560 /// \param Name The identifier. If typo correction finds an alternative name, 2561 /// this pointer parameter will be updated accordingly. 2562 /// 2563 /// \param NameLoc The location of the identifier. 2564 /// 2565 /// \param NextToken The token following the identifier. Used to help 2566 /// disambiguate the name. 2567 /// 2568 /// \param CCC The correction callback, if typo correction is desired. 2569 NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, 2570 IdentifierInfo *&Name, SourceLocation NameLoc, 2571 const Token &NextToken, 2572 CorrectionCandidateCallback *CCC = nullptr); 2573 2574 /// Act on the result of classifying a name as an undeclared (ADL-only) 2575 /// non-type declaration. 2576 ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, 2577 SourceLocation NameLoc); 2578 /// Act on the result of classifying a name as an undeclared member of a 2579 /// dependent base class. 2580 ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, 2581 IdentifierInfo *Name, 2582 SourceLocation NameLoc, 2583 bool IsAddressOfOperand); 2584 /// Act on the result of classifying a name as a specific non-type 2585 /// declaration. 2586 ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, 2587 NamedDecl *Found, 2588 SourceLocation NameLoc, 2589 const Token &NextToken); 2590 /// Act on the result of classifying a name as an overload set. 2591 ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet); 2592 2593 /// Describes the detailed kind of a template name. Used in diagnostics. 2594 enum class TemplateNameKindForDiagnostics { 2595 ClassTemplate, 2596 FunctionTemplate, 2597 VarTemplate, 2598 AliasTemplate, 2599 TemplateTemplateParam, 2600 Concept, 2601 DependentTemplate 2602 }; 2603 TemplateNameKindForDiagnostics 2604 getTemplateNameKindForDiagnostics(TemplateName Name); 2605 2606 /// Determine whether it's plausible that E was intended to be a 2607 /// template-name. 2608 bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) { 2609 if (!getLangOpts().CPlusPlus || E.isInvalid()) 2610 return false; 2611 Dependent = false; 2612 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get())) 2613 return !DRE->hasExplicitTemplateArgs(); 2614 if (auto *ME = dyn_cast<MemberExpr>(E.get())) 2615 return !ME->hasExplicitTemplateArgs(); 2616 Dependent = true; 2617 if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get())) 2618 return !DSDRE->hasExplicitTemplateArgs(); 2619 if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get())) 2620 return !DSME->hasExplicitTemplateArgs(); 2621 // Any additional cases recognized here should also be handled by 2622 // diagnoseExprIntendedAsTemplateName. 2623 return false; 2624 } 2625 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, 2626 SourceLocation Less, 2627 SourceLocation Greater); 2628 2629 void warnOnReservedIdentifier(const NamedDecl *D); 2630 2631 Decl *ActOnDeclarator(Scope *S, Declarator &D); 2632 2633 NamedDecl *HandleDeclarator(Scope *S, Declarator &D, 2634 MultiTemplateParamsArg TemplateParameterLists); 2635 bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, 2636 QualType &T, SourceLocation Loc, 2637 unsigned FailedFoldDiagID); 2638 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S); 2639 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info); 2640 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 2641 DeclarationName Name, SourceLocation Loc, 2642 bool IsTemplateId); 2643 void 2644 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, 2645 SourceLocation FallbackLoc, 2646 SourceLocation ConstQualLoc = SourceLocation(), 2647 SourceLocation VolatileQualLoc = SourceLocation(), 2648 SourceLocation RestrictQualLoc = SourceLocation(), 2649 SourceLocation AtomicQualLoc = SourceLocation(), 2650 SourceLocation UnalignedQualLoc = SourceLocation()); 2651 2652 static bool adjustContextForLocalExternDecl(DeclContext *&DC); 2653 void DiagnoseFunctionSpecifiers(const DeclSpec &DS); 2654 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D, 2655 const LookupResult &R); 2656 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R); 2657 NamedDecl *getShadowedDeclaration(const BindingDecl *D, 2658 const LookupResult &R); 2659 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, 2660 const LookupResult &R); 2661 void CheckShadow(Scope *S, VarDecl *D); 2662 2663 /// Warn if 'E', which is an expression that is about to be modified, refers 2664 /// to a shadowing declaration. 2665 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc); 2666 2667 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI); 2668 2669 private: 2670 /// Map of current shadowing declarations to shadowed declarations. Warn if 2671 /// it looks like the user is trying to modify the shadowing declaration. 2672 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls; 2673 2674 public: 2675 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange); 2676 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope); 2677 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, 2678 TypedefNameDecl *NewTD); 2679 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D); 2680 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 2681 TypeSourceInfo *TInfo, 2682 LookupResult &Previous); 2683 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D, 2684 LookupResult &Previous, bool &Redeclaration); 2685 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 2686 TypeSourceInfo *TInfo, 2687 LookupResult &Previous, 2688 MultiTemplateParamsArg TemplateParamLists, 2689 bool &AddToScope, 2690 ArrayRef<BindingDecl *> Bindings = None); 2691 NamedDecl * 2692 ActOnDecompositionDeclarator(Scope *S, Declarator &D, 2693 MultiTemplateParamsArg TemplateParamLists); 2694 // Returns true if the variable declaration is a redeclaration 2695 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous); 2696 void CheckVariableDeclarationType(VarDecl *NewVD); 2697 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, 2698 Expr *Init); 2699 void CheckCompleteVariableDeclaration(VarDecl *VD); 2700 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD); 2701 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D); 2702 2703 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC, 2704 TypeSourceInfo *TInfo, 2705 LookupResult &Previous, 2706 MultiTemplateParamsArg TemplateParamLists, 2707 bool &AddToScope); 2708 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD); 2709 2710 enum class CheckConstexprKind { 2711 /// Diagnose issues that are non-constant or that are extensions. 2712 Diagnose, 2713 /// Identify whether this function satisfies the formal rules for constexpr 2714 /// functions in the current lanugage mode (with no extensions). 2715 CheckValid 2716 }; 2717 2718 bool CheckConstexprFunctionDefinition(const FunctionDecl *FD, 2719 CheckConstexprKind Kind); 2720 2721 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD); 2722 void FindHiddenVirtualMethods(CXXMethodDecl *MD, 2723 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods); 2724 void NoteHiddenVirtualMethods(CXXMethodDecl *MD, 2725 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods); 2726 // Returns true if the function declaration is a redeclaration 2727 bool CheckFunctionDeclaration(Scope *S, 2728 FunctionDecl *NewFD, LookupResult &Previous, 2729 bool IsMemberSpecialization); 2730 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl); 2731 bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, 2732 QualType NewT, QualType OldT); 2733 void CheckMain(FunctionDecl *FD, const DeclSpec &D); 2734 void CheckMSVCRTEntryPoint(FunctionDecl *FD); 2735 Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, 2736 bool IsDefinition); 2737 void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D); 2738 Decl *ActOnParamDeclarator(Scope *S, Declarator &D); 2739 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC, 2740 SourceLocation Loc, 2741 QualType T); 2742 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc, 2743 SourceLocation NameLoc, IdentifierInfo *Name, 2744 QualType T, TypeSourceInfo *TSInfo, 2745 StorageClass SC); 2746 void ActOnParamDefaultArgument(Decl *param, 2747 SourceLocation EqualLoc, 2748 Expr *defarg); 2749 void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, 2750 SourceLocation ArgLoc); 2751 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc); 2752 ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, 2753 SourceLocation EqualLoc); 2754 void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg, 2755 SourceLocation EqualLoc); 2756 2757 // Contexts where using non-trivial C union types can be disallowed. This is 2758 // passed to err_non_trivial_c_union_in_invalid_context. 2759 enum NonTrivialCUnionContext { 2760 // Function parameter. 2761 NTCUC_FunctionParam, 2762 // Function return. 2763 NTCUC_FunctionReturn, 2764 // Default-initialized object. 2765 NTCUC_DefaultInitializedObject, 2766 // Variable with automatic storage duration. 2767 NTCUC_AutoVar, 2768 // Initializer expression that might copy from another object. 2769 NTCUC_CopyInit, 2770 // Assignment. 2771 NTCUC_Assignment, 2772 // Compound literal. 2773 NTCUC_CompoundLiteral, 2774 // Block capture. 2775 NTCUC_BlockCapture, 2776 // lvalue-to-rvalue conversion of volatile type. 2777 NTCUC_LValueToRValueVolatile, 2778 }; 2779 2780 /// Emit diagnostics if the initializer or any of its explicit or 2781 /// implicitly-generated subexpressions require copying or 2782 /// default-initializing a type that is or contains a C union type that is 2783 /// non-trivial to copy or default-initialize. 2784 void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc); 2785 2786 // These flags are passed to checkNonTrivialCUnion. 2787 enum NonTrivialCUnionKind { 2788 NTCUK_Init = 0x1, 2789 NTCUK_Destruct = 0x2, 2790 NTCUK_Copy = 0x4, 2791 }; 2792 2793 /// Emit diagnostics if a non-trivial C union type or a struct that contains 2794 /// a non-trivial C union is used in an invalid context. 2795 void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, 2796 NonTrivialCUnionContext UseContext, 2797 unsigned NonTrivialKind); 2798 2799 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit); 2800 void ActOnUninitializedDecl(Decl *dcl); 2801 void ActOnInitializerError(Decl *Dcl); 2802 2803 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc); 2804 void ActOnCXXForRangeDecl(Decl *D); 2805 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, 2806 IdentifierInfo *Ident, 2807 ParsedAttributes &Attrs, 2808 SourceLocation AttrEnd); 2809 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc); 2810 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc); 2811 void CheckStaticLocalForDllExport(VarDecl *VD); 2812 void FinalizeDeclaration(Decl *D); 2813 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 2814 ArrayRef<Decl *> Group); 2815 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group); 2816 2817 /// Should be called on all declarations that might have attached 2818 /// documentation comments. 2819 void ActOnDocumentableDecl(Decl *D); 2820 void ActOnDocumentableDecls(ArrayRef<Decl *> Group); 2821 2822 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 2823 SourceLocation LocAfterDecls); 2824 void CheckForFunctionRedefinition( 2825 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr, 2826 SkipBodyInfo *SkipBody = nullptr); 2827 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D, 2828 MultiTemplateParamsArg TemplateParamLists, 2829 SkipBodyInfo *SkipBody = nullptr); 2830 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D, 2831 SkipBodyInfo *SkipBody = nullptr); 2832 void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D); 2833 ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr); 2834 ExprResult ActOnRequiresClause(ExprResult ConstraintExpr); 2835 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D); 2836 bool isObjCMethodDecl(Decl *D) { 2837 return D && isa<ObjCMethodDecl>(D); 2838 } 2839 2840 /// Determine whether we can delay parsing the body of a function or 2841 /// function template until it is used, assuming we don't care about emitting 2842 /// code for that function. 2843 /// 2844 /// This will be \c false if we may need the body of the function in the 2845 /// middle of parsing an expression (where it's impractical to switch to 2846 /// parsing a different function), for instance, if it's constexpr in C++11 2847 /// or has an 'auto' return type in C++14. These cases are essentially bugs. 2848 bool canDelayFunctionBody(const Declarator &D); 2849 2850 /// Determine whether we can skip parsing the body of a function 2851 /// definition, assuming we don't care about analyzing its body or emitting 2852 /// code for that function. 2853 /// 2854 /// This will be \c false only if we may need the body of the function in 2855 /// order to parse the rest of the program (for instance, if it is 2856 /// \c constexpr in C++11 or has an 'auto' return type in C++14). 2857 bool canSkipFunctionBody(Decl *D); 2858 2859 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope); 2860 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body); 2861 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation); 2862 Decl *ActOnSkippedFunctionBody(Decl *Decl); 2863 void ActOnFinishInlineFunctionDef(FunctionDecl *D); 2864 2865 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an 2866 /// attribute for which parsing is delayed. 2867 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs); 2868 2869 /// Diagnose any unused parameters in the given sequence of 2870 /// ParmVarDecl pointers. 2871 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters); 2872 2873 /// Diagnose whether the size of parameters or return value of a 2874 /// function or obj-c method definition is pass-by-value and larger than a 2875 /// specified threshold. 2876 void 2877 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters, 2878 QualType ReturnTy, NamedDecl *D); 2879 2880 void DiagnoseInvalidJumps(Stmt *Body); 2881 Decl *ActOnFileScopeAsmDecl(Expr *expr, 2882 SourceLocation AsmLoc, 2883 SourceLocation RParenLoc); 2884 2885 /// Handle a C++11 empty-declaration and attribute-declaration. 2886 Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, 2887 SourceLocation SemiLoc); 2888 2889 enum class ModuleDeclKind { 2890 Interface, ///< 'export module X;' 2891 Implementation, ///< 'module X;' 2892 }; 2893 2894 /// The parser has processed a module-declaration that begins the definition 2895 /// of a module interface or implementation. 2896 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc, 2897 SourceLocation ModuleLoc, ModuleDeclKind MDK, 2898 ModuleIdPath Path, bool IsFirstDecl); 2899 2900 /// The parser has processed a global-module-fragment declaration that begins 2901 /// the definition of the global module fragment of the current module unit. 2902 /// \param ModuleLoc The location of the 'module' keyword. 2903 DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc); 2904 2905 /// The parser has processed a private-module-fragment declaration that begins 2906 /// the definition of the private module fragment of the current module unit. 2907 /// \param ModuleLoc The location of the 'module' keyword. 2908 /// \param PrivateLoc The location of the 'private' keyword. 2909 DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, 2910 SourceLocation PrivateLoc); 2911 2912 /// The parser has processed a module import declaration. 2913 /// 2914 /// \param StartLoc The location of the first token in the declaration. This 2915 /// could be the location of an '@', 'export', or 'import'. 2916 /// \param ExportLoc The location of the 'export' keyword, if any. 2917 /// \param ImportLoc The location of the 'import' keyword. 2918 /// \param Path The module access path. 2919 DeclResult ActOnModuleImport(SourceLocation StartLoc, 2920 SourceLocation ExportLoc, 2921 SourceLocation ImportLoc, ModuleIdPath Path); 2922 DeclResult ActOnModuleImport(SourceLocation StartLoc, 2923 SourceLocation ExportLoc, 2924 SourceLocation ImportLoc, Module *M, 2925 ModuleIdPath Path = {}); 2926 2927 /// The parser has processed a module import translated from a 2928 /// #include or similar preprocessing directive. 2929 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod); 2930 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod); 2931 2932 /// The parsed has entered a submodule. 2933 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod); 2934 /// The parser has left a submodule. 2935 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod); 2936 2937 /// Create an implicit import of the given module at the given 2938 /// source location, for error recovery, if possible. 2939 /// 2940 /// This routine is typically used when an entity found by name lookup 2941 /// is actually hidden within a module that we know about but the user 2942 /// has forgotten to import. 2943 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, 2944 Module *Mod); 2945 2946 /// Kinds of missing import. Note, the values of these enumerators correspond 2947 /// to %select values in diagnostics. 2948 enum class MissingImportKind { 2949 Declaration, 2950 Definition, 2951 DefaultArgument, 2952 ExplicitSpecialization, 2953 PartialSpecialization 2954 }; 2955 2956 /// Diagnose that the specified declaration needs to be visible but 2957 /// isn't, and suggest a module import that would resolve the problem. 2958 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, 2959 MissingImportKind MIK, bool Recover = true); 2960 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, 2961 SourceLocation DeclLoc, ArrayRef<Module *> Modules, 2962 MissingImportKind MIK, bool Recover); 2963 2964 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, 2965 SourceLocation LBraceLoc); 2966 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl, 2967 SourceLocation RBraceLoc); 2968 2969 /// We've found a use of a templated declaration that would trigger an 2970 /// implicit instantiation. Check that any relevant explicit specializations 2971 /// and partial specializations are visible, and diagnose if not. 2972 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec); 2973 2974 /// Retrieve a suitable printing policy for diagnostics. 2975 PrintingPolicy getPrintingPolicy() const { 2976 return getPrintingPolicy(Context, PP); 2977 } 2978 2979 /// Retrieve a suitable printing policy for diagnostics. 2980 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx, 2981 const Preprocessor &PP); 2982 2983 /// Scope actions. 2984 void ActOnPopScope(SourceLocation Loc, Scope *S); 2985 void ActOnTranslationUnitScope(Scope *S); 2986 2987 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, 2988 RecordDecl *&AnonRecord); 2989 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, 2990 MultiTemplateParamsArg TemplateParams, 2991 bool IsExplicitInstantiation, 2992 RecordDecl *&AnonRecord); 2993 2994 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 2995 AccessSpecifier AS, 2996 RecordDecl *Record, 2997 const PrintingPolicy &Policy); 2998 2999 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 3000 RecordDecl *Record); 3001 3002 /// Common ways to introduce type names without a tag for use in diagnostics. 3003 /// Keep in sync with err_tag_reference_non_tag. 3004 enum NonTagKind { 3005 NTK_NonStruct, 3006 NTK_NonClass, 3007 NTK_NonUnion, 3008 NTK_NonEnum, 3009 NTK_Typedef, 3010 NTK_TypeAlias, 3011 NTK_Template, 3012 NTK_TypeAliasTemplate, 3013 NTK_TemplateTemplateArgument, 3014 }; 3015 3016 /// Given a non-tag type declaration, returns an enum useful for indicating 3017 /// what kind of non-tag type this is. 3018 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK); 3019 3020 bool isAcceptableTagRedeclaration(const TagDecl *Previous, 3021 TagTypeKind NewTag, bool isDefinition, 3022 SourceLocation NewTagLoc, 3023 const IdentifierInfo *Name); 3024 3025 enum TagUseKind { 3026 TUK_Reference, // Reference to a tag: 'struct foo *X;' 3027 TUK_Declaration, // Fwd decl of a tag: 'struct foo;' 3028 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;' 3029 TUK_Friend // Friend declaration: 'friend struct foo;' 3030 }; 3031 3032 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 3033 SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, 3034 SourceLocation NameLoc, const ParsedAttributesView &Attr, 3035 AccessSpecifier AS, SourceLocation ModulePrivateLoc, 3036 MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, 3037 bool &IsDependent, SourceLocation ScopedEnumKWLoc, 3038 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, 3039 bool IsTypeSpecifier, bool IsTemplateParamOrArg, 3040 SkipBodyInfo *SkipBody = nullptr); 3041 3042 Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc, 3043 unsigned TagSpec, SourceLocation TagLoc, 3044 CXXScopeSpec &SS, IdentifierInfo *Name, 3045 SourceLocation NameLoc, 3046 const ParsedAttributesView &Attr, 3047 MultiTemplateParamsArg TempParamLists); 3048 3049 TypeResult ActOnDependentTag(Scope *S, 3050 unsigned TagSpec, 3051 TagUseKind TUK, 3052 const CXXScopeSpec &SS, 3053 IdentifierInfo *Name, 3054 SourceLocation TagLoc, 3055 SourceLocation NameLoc); 3056 3057 void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, 3058 IdentifierInfo *ClassName, 3059 SmallVectorImpl<Decl *> &Decls); 3060 Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 3061 Declarator &D, Expr *BitfieldWidth); 3062 3063 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart, 3064 Declarator &D, Expr *BitfieldWidth, 3065 InClassInitStyle InitStyle, 3066 AccessSpecifier AS); 3067 MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD, 3068 SourceLocation DeclStart, Declarator &D, 3069 Expr *BitfieldWidth, 3070 InClassInitStyle InitStyle, 3071 AccessSpecifier AS, 3072 const ParsedAttr &MSPropertyAttr); 3073 3074 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T, 3075 TypeSourceInfo *TInfo, 3076 RecordDecl *Record, SourceLocation Loc, 3077 bool Mutable, Expr *BitfieldWidth, 3078 InClassInitStyle InitStyle, 3079 SourceLocation TSSL, 3080 AccessSpecifier AS, NamedDecl *PrevDecl, 3081 Declarator *D = nullptr); 3082 3083 bool CheckNontrivialField(FieldDecl *FD); 3084 void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM); 3085 3086 enum TrivialABIHandling { 3087 /// The triviality of a method unaffected by "trivial_abi". 3088 TAH_IgnoreTrivialABI, 3089 3090 /// The triviality of a method affected by "trivial_abi". 3091 TAH_ConsiderTrivialABI 3092 }; 3093 3094 bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, 3095 TrivialABIHandling TAH = TAH_IgnoreTrivialABI, 3096 bool Diagnose = false); 3097 3098 /// For a defaulted function, the kind of defaulted function that it is. 3099 class DefaultedFunctionKind { 3100 CXXSpecialMember SpecialMember : 8; 3101 DefaultedComparisonKind Comparison : 8; 3102 3103 public: 3104 DefaultedFunctionKind() 3105 : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) { 3106 } 3107 DefaultedFunctionKind(CXXSpecialMember CSM) 3108 : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {} 3109 DefaultedFunctionKind(DefaultedComparisonKind Comp) 3110 : SpecialMember(CXXInvalid), Comparison(Comp) {} 3111 3112 bool isSpecialMember() const { return SpecialMember != CXXInvalid; } 3113 bool isComparison() const { 3114 return Comparison != DefaultedComparisonKind::None; 3115 } 3116 3117 explicit operator bool() const { 3118 return isSpecialMember() || isComparison(); 3119 } 3120 3121 CXXSpecialMember asSpecialMember() const { return SpecialMember; } 3122 DefaultedComparisonKind asComparison() const { return Comparison; } 3123 3124 /// Get the index of this function kind for use in diagnostics. 3125 unsigned getDiagnosticIndex() const { 3126 static_assert(CXXInvalid > CXXDestructor, 3127 "invalid should have highest index"); 3128 static_assert((unsigned)DefaultedComparisonKind::None == 0, 3129 "none should be equal to zero"); 3130 return SpecialMember + (unsigned)Comparison; 3131 } 3132 }; 3133 3134 DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD); 3135 3136 CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) { 3137 return getDefaultedFunctionKind(MD).asSpecialMember(); 3138 } 3139 DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) { 3140 return getDefaultedFunctionKind(FD).asComparison(); 3141 } 3142 3143 void ActOnLastBitfield(SourceLocation DeclStart, 3144 SmallVectorImpl<Decl *> &AllIvarDecls); 3145 Decl *ActOnIvar(Scope *S, SourceLocation DeclStart, 3146 Declarator &D, Expr *BitfieldWidth, 3147 tok::ObjCKeywordKind visibility); 3148 3149 // This is used for both record definitions and ObjC interface declarations. 3150 void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, 3151 ArrayRef<Decl *> Fields, SourceLocation LBrac, 3152 SourceLocation RBrac, const ParsedAttributesView &AttrList); 3153 3154 /// ActOnTagStartDefinition - Invoked when we have entered the 3155 /// scope of a tag's definition (e.g., for an enumeration, class, 3156 /// struct, or union). 3157 void ActOnTagStartDefinition(Scope *S, Decl *TagDecl); 3158 3159 /// Perform ODR-like check for C/ObjC when merging tag types from modules. 3160 /// Differently from C++, actually parse the body and reject / error out 3161 /// in case of a structural mismatch. 3162 bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev, 3163 SkipBodyInfo &SkipBody); 3164 3165 typedef void *SkippedDefinitionContext; 3166 3167 /// Invoked when we enter a tag definition that we're skipping. 3168 SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD); 3169 3170 Decl *ActOnObjCContainerStartDefinition(Decl *IDecl); 3171 3172 /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a 3173 /// C++ record definition's base-specifiers clause and are starting its 3174 /// member declarations. 3175 void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl, 3176 SourceLocation FinalLoc, 3177 bool IsFinalSpelledSealed, 3178 bool IsAbstract, 3179 SourceLocation LBraceLoc); 3180 3181 /// ActOnTagFinishDefinition - Invoked once we have finished parsing 3182 /// the definition of a tag (enumeration, class, struct, or union). 3183 void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, 3184 SourceRange BraceRange); 3185 3186 void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context); 3187 3188 void ActOnObjCContainerFinishDefinition(); 3189 3190 /// Invoked when we must temporarily exit the objective-c container 3191 /// scope for parsing/looking-up C constructs. 3192 /// 3193 /// Must be followed by a call to \see ActOnObjCReenterContainerContext 3194 void ActOnObjCTemporaryExitContainerContext(DeclContext *DC); 3195 void ActOnObjCReenterContainerContext(DeclContext *DC); 3196 3197 /// ActOnTagDefinitionError - Invoked when there was an unrecoverable 3198 /// error parsing the definition of a tag. 3199 void ActOnTagDefinitionError(Scope *S, Decl *TagDecl); 3200 3201 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum, 3202 EnumConstantDecl *LastEnumConst, 3203 SourceLocation IdLoc, 3204 IdentifierInfo *Id, 3205 Expr *val); 3206 bool CheckEnumUnderlyingType(TypeSourceInfo *TI); 3207 bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 3208 QualType EnumUnderlyingTy, bool IsFixed, 3209 const EnumDecl *Prev); 3210 3211 /// Determine whether the body of an anonymous enumeration should be skipped. 3212 /// \param II The name of the first enumerator. 3213 SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, 3214 SourceLocation IILoc); 3215 3216 Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, 3217 SourceLocation IdLoc, IdentifierInfo *Id, 3218 const ParsedAttributesView &Attrs, 3219 SourceLocation EqualLoc, Expr *Val); 3220 void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, 3221 Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S, 3222 const ParsedAttributesView &Attr); 3223 3224 /// Set the current declaration context until it gets popped. 3225 void PushDeclContext(Scope *S, DeclContext *DC); 3226 void PopDeclContext(); 3227 3228 /// EnterDeclaratorContext - Used when we must lookup names in the context 3229 /// of a declarator's nested name specifier. 3230 void EnterDeclaratorContext(Scope *S, DeclContext *DC); 3231 void ExitDeclaratorContext(Scope *S); 3232 3233 /// Enter a template parameter scope, after it's been associated with a particular 3234 /// DeclContext. Causes lookup within the scope to chain through enclosing contexts 3235 /// in the correct order. 3236 void EnterTemplatedContext(Scope *S, DeclContext *DC); 3237 3238 /// Push the parameters of D, which must be a function, into scope. 3239 void ActOnReenterFunctionContext(Scope* S, Decl* D); 3240 void ActOnExitFunctionContext(); 3241 3242 DeclContext *getFunctionLevelDeclContext(); 3243 3244 /// getCurFunctionDecl - If inside of a function body, this returns a pointer 3245 /// to the function decl for the function being parsed. If we're currently 3246 /// in a 'block', this returns the containing context. 3247 FunctionDecl *getCurFunctionDecl(); 3248 3249 /// getCurMethodDecl - If inside of a method body, this returns a pointer to 3250 /// the method decl for the method being parsed. If we're currently 3251 /// in a 'block', this returns the containing context. 3252 ObjCMethodDecl *getCurMethodDecl(); 3253 3254 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method 3255 /// or C function we're in, otherwise return null. If we're currently 3256 /// in a 'block', this returns the containing context. 3257 NamedDecl *getCurFunctionOrMethodDecl(); 3258 3259 /// Add this decl to the scope shadowed decl chains. 3260 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true); 3261 3262 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true 3263 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns 3264 /// true if 'D' belongs to the given declaration context. 3265 /// 3266 /// \param AllowInlineNamespace If \c true, allow the declaration to be in the 3267 /// enclosing namespace set of the context, rather than contained 3268 /// directly within it. 3269 bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr, 3270 bool AllowInlineNamespace = false); 3271 3272 /// Finds the scope corresponding to the given decl context, if it 3273 /// happens to be an enclosing scope. Otherwise return NULL. 3274 static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC); 3275 3276 /// Subroutines of ActOnDeclarator(). 3277 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 3278 TypeSourceInfo *TInfo); 3279 bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New); 3280 3281 /// Describes the kind of merge to perform for availability 3282 /// attributes (including "deprecated", "unavailable", and "availability"). 3283 enum AvailabilityMergeKind { 3284 /// Don't merge availability attributes at all. 3285 AMK_None, 3286 /// Merge availability attributes for a redeclaration, which requires 3287 /// an exact match. 3288 AMK_Redeclaration, 3289 /// Merge availability attributes for an override, which requires 3290 /// an exact match or a weakening of constraints. 3291 AMK_Override, 3292 /// Merge availability attributes for an implementation of 3293 /// a protocol requirement. 3294 AMK_ProtocolImplementation, 3295 /// Merge availability attributes for an implementation of 3296 /// an optional protocol requirement. 3297 AMK_OptionalProtocolImplementation 3298 }; 3299 3300 /// Describes the kind of priority given to an availability attribute. 3301 /// 3302 /// The sum of priorities deteremines the final priority of the attribute. 3303 /// The final priority determines how the attribute will be merged. 3304 /// An attribute with a lower priority will always remove higher priority 3305 /// attributes for the specified platform when it is being applied. An 3306 /// attribute with a higher priority will not be applied if the declaration 3307 /// already has an availability attribute with a lower priority for the 3308 /// specified platform. The final prirority values are not expected to match 3309 /// the values in this enumeration, but instead should be treated as a plain 3310 /// integer value. This enumeration just names the priority weights that are 3311 /// used to calculate that final vaue. 3312 enum AvailabilityPriority : int { 3313 /// The availability attribute was specified explicitly next to the 3314 /// declaration. 3315 AP_Explicit = 0, 3316 3317 /// The availability attribute was applied using '#pragma clang attribute'. 3318 AP_PragmaClangAttribute = 1, 3319 3320 /// The availability attribute for a specific platform was inferred from 3321 /// an availability attribute for another platform. 3322 AP_InferredFromOtherPlatform = 2 3323 }; 3324 3325 /// Attribute merging methods. Return true if a new attribute was added. 3326 AvailabilityAttr * 3327 mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, 3328 IdentifierInfo *Platform, bool Implicit, 3329 VersionTuple Introduced, VersionTuple Deprecated, 3330 VersionTuple Obsoleted, bool IsUnavailable, 3331 StringRef Message, bool IsStrict, StringRef Replacement, 3332 AvailabilityMergeKind AMK, int Priority); 3333 TypeVisibilityAttr * 3334 mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, 3335 TypeVisibilityAttr::VisibilityType Vis); 3336 VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, 3337 VisibilityAttr::VisibilityType Vis); 3338 UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, 3339 StringRef UuidAsWritten, MSGuidDecl *GuidDecl); 3340 DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI); 3341 DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI); 3342 MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D, 3343 const AttributeCommonInfo &CI, 3344 bool BestCase, 3345 MSInheritanceModel Model); 3346 FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, 3347 IdentifierInfo *Format, int FormatIdx, 3348 int FirstArg); 3349 SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, 3350 StringRef Name); 3351 CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, 3352 StringRef Name); 3353 AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D, 3354 const AttributeCommonInfo &CI, 3355 const IdentifierInfo *Ident); 3356 MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI); 3357 SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, 3358 StringRef Name); 3359 OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D, 3360 const AttributeCommonInfo &CI); 3361 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL); 3362 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, 3363 const InternalLinkageAttr &AL); 3364 WebAssemblyImportNameAttr *mergeImportNameAttr( 3365 Decl *D, const WebAssemblyImportNameAttr &AL); 3366 WebAssemblyImportModuleAttr *mergeImportModuleAttr( 3367 Decl *D, const WebAssemblyImportModuleAttr &AL); 3368 EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL); 3369 EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D, 3370 const EnforceTCBLeafAttr &AL); 3371 3372 void mergeDeclAttributes(NamedDecl *New, Decl *Old, 3373 AvailabilityMergeKind AMK = AMK_Redeclaration); 3374 void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, 3375 LookupResult &OldDecls); 3376 bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S, 3377 bool MergeTypeWithOld); 3378 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 3379 Scope *S, bool MergeTypeWithOld); 3380 void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old); 3381 void MergeVarDecl(VarDecl *New, LookupResult &Previous); 3382 void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld); 3383 void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old); 3384 bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn); 3385 void notePreviousDefinition(const NamedDecl *Old, SourceLocation New); 3386 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S); 3387 3388 // AssignmentAction - This is used by all the assignment diagnostic functions 3389 // to represent what is actually causing the operation 3390 enum AssignmentAction { 3391 AA_Assigning, 3392 AA_Passing, 3393 AA_Returning, 3394 AA_Converting, 3395 AA_Initializing, 3396 AA_Sending, 3397 AA_Casting, 3398 AA_Passing_CFAudited 3399 }; 3400 3401 /// C++ Overloading. 3402 enum OverloadKind { 3403 /// This is a legitimate overload: the existing declarations are 3404 /// functions or function templates with different signatures. 3405 Ovl_Overload, 3406 3407 /// This is not an overload because the signature exactly matches 3408 /// an existing declaration. 3409 Ovl_Match, 3410 3411 /// This is not an overload because the lookup results contain a 3412 /// non-function. 3413 Ovl_NonFunction 3414 }; 3415 OverloadKind CheckOverload(Scope *S, 3416 FunctionDecl *New, 3417 const LookupResult &OldDecls, 3418 NamedDecl *&OldDecl, 3419 bool IsForUsingDecl); 3420 bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, 3421 bool ConsiderCudaAttrs = true, 3422 bool ConsiderRequiresClauses = true); 3423 3424 enum class AllowedExplicit { 3425 /// Allow no explicit functions to be used. 3426 None, 3427 /// Allow explicit conversion functions but not explicit constructors. 3428 Conversions, 3429 /// Allow both explicit conversion functions and explicit constructors. 3430 All 3431 }; 3432 3433 ImplicitConversionSequence 3434 TryImplicitConversion(Expr *From, QualType ToType, 3435 bool SuppressUserConversions, 3436 AllowedExplicit AllowExplicit, 3437 bool InOverloadResolution, 3438 bool CStyle, 3439 bool AllowObjCWritebackConversion); 3440 3441 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType); 3442 bool IsFloatingPointPromotion(QualType FromType, QualType ToType); 3443 bool IsComplexPromotion(QualType FromType, QualType ToType); 3444 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType, 3445 bool InOverloadResolution, 3446 QualType& ConvertedType, bool &IncompatibleObjC); 3447 bool isObjCPointerConversion(QualType FromType, QualType ToType, 3448 QualType& ConvertedType, bool &IncompatibleObjC); 3449 bool isObjCWritebackConversion(QualType FromType, QualType ToType, 3450 QualType &ConvertedType); 3451 bool IsBlockPointerConversion(QualType FromType, QualType ToType, 3452 QualType& ConvertedType); 3453 bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType, 3454 const FunctionProtoType *NewType, 3455 unsigned *ArgPos = nullptr); 3456 void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag, 3457 QualType FromType, QualType ToType); 3458 3459 void maybeExtendBlockObject(ExprResult &E); 3460 CastKind PrepareCastToObjCObjectPointer(ExprResult &E); 3461 bool CheckPointerConversion(Expr *From, QualType ToType, 3462 CastKind &Kind, 3463 CXXCastPath& BasePath, 3464 bool IgnoreBaseAccess, 3465 bool Diagnose = true); 3466 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType, 3467 bool InOverloadResolution, 3468 QualType &ConvertedType); 3469 bool CheckMemberPointerConversion(Expr *From, QualType ToType, 3470 CastKind &Kind, 3471 CXXCastPath &BasePath, 3472 bool IgnoreBaseAccess); 3473 bool IsQualificationConversion(QualType FromType, QualType ToType, 3474 bool CStyle, bool &ObjCLifetimeConversion); 3475 bool IsFunctionConversion(QualType FromType, QualType ToType, 3476 QualType &ResultTy); 3477 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType); 3478 bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg); 3479 3480 bool CanPerformAggregateInitializationForOverloadResolution( 3481 const InitializedEntity &Entity, InitListExpr *From); 3482 3483 bool IsStringInit(Expr *Init, const ArrayType *AT); 3484 3485 bool CanPerformCopyInitialization(const InitializedEntity &Entity, 3486 ExprResult Init); 3487 ExprResult PerformCopyInitialization(const InitializedEntity &Entity, 3488 SourceLocation EqualLoc, 3489 ExprResult Init, 3490 bool TopLevelOfInitList = false, 3491 bool AllowExplicit = false); 3492 ExprResult PerformObjectArgumentInitialization(Expr *From, 3493 NestedNameSpecifier *Qualifier, 3494 NamedDecl *FoundDecl, 3495 CXXMethodDecl *Method); 3496 3497 /// Check that the lifetime of the initializer (and its subobjects) is 3498 /// sufficient for initializing the entity, and perform lifetime extension 3499 /// (when permitted) if not. 3500 void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init); 3501 3502 ExprResult PerformContextuallyConvertToBool(Expr *From); 3503 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From); 3504 3505 /// Contexts in which a converted constant expression is required. 3506 enum CCEKind { 3507 CCEK_CaseValue, ///< Expression in a case label. 3508 CCEK_Enumerator, ///< Enumerator value with fixed underlying type. 3509 CCEK_TemplateArg, ///< Value of a non-type template parameter. 3510 CCEK_ArrayBound, ///< Array bound in array declarator or new-expression. 3511 CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier. 3512 }; 3513 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, 3514 llvm::APSInt &Value, CCEKind CCE); 3515 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, 3516 APValue &Value, CCEKind CCE, 3517 NamedDecl *Dest = nullptr); 3518 3519 /// Abstract base class used to perform a contextual implicit 3520 /// conversion from an expression to any type passing a filter. 3521 class ContextualImplicitConverter { 3522 public: 3523 bool Suppress; 3524 bool SuppressConversion; 3525 3526 ContextualImplicitConverter(bool Suppress = false, 3527 bool SuppressConversion = false) 3528 : Suppress(Suppress), SuppressConversion(SuppressConversion) {} 3529 3530 /// Determine whether the specified type is a valid destination type 3531 /// for this conversion. 3532 virtual bool match(QualType T) = 0; 3533 3534 /// Emits a diagnostic complaining that the expression does not have 3535 /// integral or enumeration type. 3536 virtual SemaDiagnosticBuilder 3537 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0; 3538 3539 /// Emits a diagnostic when the expression has incomplete class type. 3540 virtual SemaDiagnosticBuilder 3541 diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0; 3542 3543 /// Emits a diagnostic when the only matching conversion function 3544 /// is explicit. 3545 virtual SemaDiagnosticBuilder diagnoseExplicitConv( 3546 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0; 3547 3548 /// Emits a note for the explicit conversion function. 3549 virtual SemaDiagnosticBuilder 3550 noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0; 3551 3552 /// Emits a diagnostic when there are multiple possible conversion 3553 /// functions. 3554 virtual SemaDiagnosticBuilder 3555 diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0; 3556 3557 /// Emits a note for one of the candidate conversions. 3558 virtual SemaDiagnosticBuilder 3559 noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0; 3560 3561 /// Emits a diagnostic when we picked a conversion function 3562 /// (for cases when we are not allowed to pick a conversion function). 3563 virtual SemaDiagnosticBuilder diagnoseConversion( 3564 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0; 3565 3566 virtual ~ContextualImplicitConverter() {} 3567 }; 3568 3569 class ICEConvertDiagnoser : public ContextualImplicitConverter { 3570 bool AllowScopedEnumerations; 3571 3572 public: 3573 ICEConvertDiagnoser(bool AllowScopedEnumerations, 3574 bool Suppress, bool SuppressConversion) 3575 : ContextualImplicitConverter(Suppress, SuppressConversion), 3576 AllowScopedEnumerations(AllowScopedEnumerations) {} 3577 3578 /// Match an integral or (possibly scoped) enumeration type. 3579 bool match(QualType T) override; 3580 3581 SemaDiagnosticBuilder 3582 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override { 3583 return diagnoseNotInt(S, Loc, T); 3584 } 3585 3586 /// Emits a diagnostic complaining that the expression does not have 3587 /// integral or enumeration type. 3588 virtual SemaDiagnosticBuilder 3589 diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0; 3590 }; 3591 3592 /// Perform a contextual implicit conversion. 3593 ExprResult PerformContextualImplicitConversion( 3594 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter); 3595 3596 3597 enum ObjCSubscriptKind { 3598 OS_Array, 3599 OS_Dictionary, 3600 OS_Error 3601 }; 3602 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE); 3603 3604 // Note that LK_String is intentionally after the other literals, as 3605 // this is used for diagnostics logic. 3606 enum ObjCLiteralKind { 3607 LK_Array, 3608 LK_Dictionary, 3609 LK_Numeric, 3610 LK_Boxed, 3611 LK_String, 3612 LK_Block, 3613 LK_None 3614 }; 3615 ObjCLiteralKind CheckLiteralKind(Expr *FromE); 3616 3617 ExprResult PerformObjectMemberConversion(Expr *From, 3618 NestedNameSpecifier *Qualifier, 3619 NamedDecl *FoundDecl, 3620 NamedDecl *Member); 3621 3622 // Members have to be NamespaceDecl* or TranslationUnitDecl*. 3623 // TODO: make this is a typesafe union. 3624 typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet; 3625 typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet; 3626 3627 using ADLCallKind = CallExpr::ADLCallKind; 3628 3629 void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, 3630 ArrayRef<Expr *> Args, 3631 OverloadCandidateSet &CandidateSet, 3632 bool SuppressUserConversions = false, 3633 bool PartialOverloading = false, 3634 bool AllowExplicit = true, 3635 bool AllowExplicitConversion = false, 3636 ADLCallKind IsADLCandidate = ADLCallKind::NotADL, 3637 ConversionSequenceList EarlyConversions = None, 3638 OverloadCandidateParamOrder PO = {}); 3639 void AddFunctionCandidates(const UnresolvedSetImpl &Functions, 3640 ArrayRef<Expr *> Args, 3641 OverloadCandidateSet &CandidateSet, 3642 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr, 3643 bool SuppressUserConversions = false, 3644 bool PartialOverloading = false, 3645 bool FirstArgumentIsBase = false); 3646 void AddMethodCandidate(DeclAccessPair FoundDecl, 3647 QualType ObjectType, 3648 Expr::Classification ObjectClassification, 3649 ArrayRef<Expr *> Args, 3650 OverloadCandidateSet& CandidateSet, 3651 bool SuppressUserConversion = false, 3652 OverloadCandidateParamOrder PO = {}); 3653 void AddMethodCandidate(CXXMethodDecl *Method, 3654 DeclAccessPair FoundDecl, 3655 CXXRecordDecl *ActingContext, QualType ObjectType, 3656 Expr::Classification ObjectClassification, 3657 ArrayRef<Expr *> Args, 3658 OverloadCandidateSet& CandidateSet, 3659 bool SuppressUserConversions = false, 3660 bool PartialOverloading = false, 3661 ConversionSequenceList EarlyConversions = None, 3662 OverloadCandidateParamOrder PO = {}); 3663 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, 3664 DeclAccessPair FoundDecl, 3665 CXXRecordDecl *ActingContext, 3666 TemplateArgumentListInfo *ExplicitTemplateArgs, 3667 QualType ObjectType, 3668 Expr::Classification ObjectClassification, 3669 ArrayRef<Expr *> Args, 3670 OverloadCandidateSet& CandidateSet, 3671 bool SuppressUserConversions = false, 3672 bool PartialOverloading = false, 3673 OverloadCandidateParamOrder PO = {}); 3674 void AddTemplateOverloadCandidate( 3675 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, 3676 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, 3677 OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false, 3678 bool PartialOverloading = false, bool AllowExplicit = true, 3679 ADLCallKind IsADLCandidate = ADLCallKind::NotADL, 3680 OverloadCandidateParamOrder PO = {}); 3681 bool CheckNonDependentConversions( 3682 FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes, 3683 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet, 3684 ConversionSequenceList &Conversions, bool SuppressUserConversions, 3685 CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(), 3686 Expr::Classification ObjectClassification = {}, 3687 OverloadCandidateParamOrder PO = {}); 3688 void AddConversionCandidate( 3689 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl, 3690 CXXRecordDecl *ActingContext, Expr *From, QualType ToType, 3691 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, 3692 bool AllowExplicit, bool AllowResultConversion = true); 3693 void AddTemplateConversionCandidate( 3694 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, 3695 CXXRecordDecl *ActingContext, Expr *From, QualType ToType, 3696 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit, 3697 bool AllowExplicit, bool AllowResultConversion = true); 3698 void AddSurrogateCandidate(CXXConversionDecl *Conversion, 3699 DeclAccessPair FoundDecl, 3700 CXXRecordDecl *ActingContext, 3701 const FunctionProtoType *Proto, 3702 Expr *Object, ArrayRef<Expr *> Args, 3703 OverloadCandidateSet& CandidateSet); 3704 void AddNonMemberOperatorCandidates( 3705 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args, 3706 OverloadCandidateSet &CandidateSet, 3707 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr); 3708 void AddMemberOperatorCandidates(OverloadedOperatorKind Op, 3709 SourceLocation OpLoc, ArrayRef<Expr *> Args, 3710 OverloadCandidateSet &CandidateSet, 3711 OverloadCandidateParamOrder PO = {}); 3712 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args, 3713 OverloadCandidateSet& CandidateSet, 3714 bool IsAssignmentOperator = false, 3715 unsigned NumContextualBoolArguments = 0); 3716 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, 3717 SourceLocation OpLoc, ArrayRef<Expr *> Args, 3718 OverloadCandidateSet& CandidateSet); 3719 void AddArgumentDependentLookupCandidates(DeclarationName Name, 3720 SourceLocation Loc, 3721 ArrayRef<Expr *> Args, 3722 TemplateArgumentListInfo *ExplicitTemplateArgs, 3723 OverloadCandidateSet& CandidateSet, 3724 bool PartialOverloading = false); 3725 3726 // Emit as a 'note' the specific overload candidate 3727 void NoteOverloadCandidate( 3728 NamedDecl *Found, FunctionDecl *Fn, 3729 OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(), 3730 QualType DestType = QualType(), bool TakingAddress = false); 3731 3732 // Emit as a series of 'note's all template and non-templates identified by 3733 // the expression Expr 3734 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(), 3735 bool TakingAddress = false); 3736 3737 /// Check the enable_if expressions on the given function. Returns the first 3738 /// failing attribute, or NULL if they were all successful. 3739 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc, 3740 ArrayRef<Expr *> Args, 3741 bool MissingImplicitThis = false); 3742 3743 /// Find the failed Boolean condition within a given Boolean 3744 /// constant expression, and describe it with a string. 3745 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond); 3746 3747 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any 3748 /// non-ArgDependent DiagnoseIfAttrs. 3749 /// 3750 /// Argument-dependent diagnose_if attributes should be checked each time a 3751 /// function is used as a direct callee of a function call. 3752 /// 3753 /// Returns true if any errors were emitted. 3754 bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, 3755 const Expr *ThisArg, 3756 ArrayRef<const Expr *> Args, 3757 SourceLocation Loc); 3758 3759 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any 3760 /// ArgDependent DiagnoseIfAttrs. 3761 /// 3762 /// Argument-independent diagnose_if attributes should be checked on every use 3763 /// of a function. 3764 /// 3765 /// Returns true if any errors were emitted. 3766 bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, 3767 SourceLocation Loc); 3768 3769 /// Returns whether the given function's address can be taken or not, 3770 /// optionally emitting a diagnostic if the address can't be taken. 3771 /// 3772 /// Returns false if taking the address of the function is illegal. 3773 bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, 3774 bool Complain = false, 3775 SourceLocation Loc = SourceLocation()); 3776 3777 // [PossiblyAFunctionType] --> [Return] 3778 // NonFunctionType --> NonFunctionType 3779 // R (A) --> R(A) 3780 // R (*)(A) --> R (A) 3781 // R (&)(A) --> R (A) 3782 // R (S::*)(A) --> R (A) 3783 QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType); 3784 3785 FunctionDecl * 3786 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, 3787 QualType TargetType, 3788 bool Complain, 3789 DeclAccessPair &Found, 3790 bool *pHadMultipleCandidates = nullptr); 3791 3792 FunctionDecl * 3793 resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult); 3794 3795 bool resolveAndFixAddressOfSingleOverloadCandidate( 3796 ExprResult &SrcExpr, bool DoFunctionPointerConversion = false); 3797 3798 FunctionDecl * 3799 ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, 3800 bool Complain = false, 3801 DeclAccessPair *Found = nullptr); 3802 3803 bool ResolveAndFixSingleFunctionTemplateSpecialization( 3804 ExprResult &SrcExpr, 3805 bool DoFunctionPointerConverion = false, 3806 bool Complain = false, 3807 SourceRange OpRangeForComplaining = SourceRange(), 3808 QualType DestTypeForComplaining = QualType(), 3809 unsigned DiagIDForComplaining = 0); 3810 3811 3812 Expr *FixOverloadedFunctionReference(Expr *E, 3813 DeclAccessPair FoundDecl, 3814 FunctionDecl *Fn); 3815 ExprResult FixOverloadedFunctionReference(ExprResult, 3816 DeclAccessPair FoundDecl, 3817 FunctionDecl *Fn); 3818 3819 void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, 3820 ArrayRef<Expr *> Args, 3821 OverloadCandidateSet &CandidateSet, 3822 bool PartialOverloading = false); 3823 void AddOverloadedCallCandidates( 3824 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs, 3825 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet); 3826 3827 // An enum used to represent the different possible results of building a 3828 // range-based for loop. 3829 enum ForRangeStatus { 3830 FRS_Success, 3831 FRS_NoViableFunction, 3832 FRS_DiagnosticIssued 3833 }; 3834 3835 ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, 3836 SourceLocation RangeLoc, 3837 const DeclarationNameInfo &NameInfo, 3838 LookupResult &MemberLookup, 3839 OverloadCandidateSet *CandidateSet, 3840 Expr *Range, ExprResult *CallExpr); 3841 3842 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn, 3843 UnresolvedLookupExpr *ULE, 3844 SourceLocation LParenLoc, 3845 MultiExprArg Args, 3846 SourceLocation RParenLoc, 3847 Expr *ExecConfig, 3848 bool AllowTypoCorrection=true, 3849 bool CalleesAddressIsTaken=false); 3850 3851 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, 3852 MultiExprArg Args, SourceLocation RParenLoc, 3853 OverloadCandidateSet *CandidateSet, 3854 ExprResult *Result); 3855 3856 ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass, 3857 NestedNameSpecifierLoc NNSLoc, 3858 DeclarationNameInfo DNI, 3859 const UnresolvedSetImpl &Fns, 3860 bool PerformADL = true); 3861 3862 ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, 3863 UnaryOperatorKind Opc, 3864 const UnresolvedSetImpl &Fns, 3865 Expr *input, bool RequiresADL = true); 3866 3867 void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet, 3868 OverloadedOperatorKind Op, 3869 const UnresolvedSetImpl &Fns, 3870 ArrayRef<Expr *> Args, bool RequiresADL = true); 3871 ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, 3872 BinaryOperatorKind Opc, 3873 const UnresolvedSetImpl &Fns, 3874 Expr *LHS, Expr *RHS, 3875 bool RequiresADL = true, 3876 bool AllowRewrittenCandidates = true, 3877 FunctionDecl *DefaultedFn = nullptr); 3878 ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc, 3879 const UnresolvedSetImpl &Fns, 3880 Expr *LHS, Expr *RHS, 3881 FunctionDecl *DefaultedFn); 3882 3883 ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, 3884 SourceLocation RLoc, 3885 Expr *Base,Expr *Idx); 3886 3887 ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, 3888 SourceLocation LParenLoc, 3889 MultiExprArg Args, 3890 SourceLocation RParenLoc, 3891 bool AllowRecovery = false); 3892 ExprResult 3893 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc, 3894 MultiExprArg Args, 3895 SourceLocation RParenLoc); 3896 3897 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, 3898 SourceLocation OpLoc, 3899 bool *NoArrowOperatorFound = nullptr); 3900 3901 /// CheckCallReturnType - Checks that a call expression's return type is 3902 /// complete. Returns true on failure. The location passed in is the location 3903 /// that best represents the call. 3904 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, 3905 CallExpr *CE, FunctionDecl *FD); 3906 3907 /// Helpers for dealing with blocks and functions. 3908 bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters, 3909 bool CheckParameterNames); 3910 void CheckCXXDefaultArguments(FunctionDecl *FD); 3911 void CheckExtraCXXDefaultArguments(Declarator &D); 3912 Scope *getNonFieldDeclScope(Scope *S); 3913 3914 /// \name Name lookup 3915 /// 3916 /// These routines provide name lookup that is used during semantic 3917 /// analysis to resolve the various kinds of names (identifiers, 3918 /// overloaded operator names, constructor names, etc.) into zero or 3919 /// more declarations within a particular scope. The major entry 3920 /// points are LookupName, which performs unqualified name lookup, 3921 /// and LookupQualifiedName, which performs qualified name lookup. 3922 /// 3923 /// All name lookup is performed based on some specific criteria, 3924 /// which specify what names will be visible to name lookup and how 3925 /// far name lookup should work. These criteria are important both 3926 /// for capturing language semantics (certain lookups will ignore 3927 /// certain names, for example) and for performance, since name 3928 /// lookup is often a bottleneck in the compilation of C++. Name 3929 /// lookup criteria is specified via the LookupCriteria enumeration. 3930 /// 3931 /// The results of name lookup can vary based on the kind of name 3932 /// lookup performed, the current language, and the translation 3933 /// unit. In C, for example, name lookup will either return nothing 3934 /// (no entity found) or a single declaration. In C++, name lookup 3935 /// can additionally refer to a set of overloaded functions or 3936 /// result in an ambiguity. All of the possible results of name 3937 /// lookup are captured by the LookupResult class, which provides 3938 /// the ability to distinguish among them. 3939 //@{ 3940 3941 /// Describes the kind of name lookup to perform. 3942 enum LookupNameKind { 3943 /// Ordinary name lookup, which finds ordinary names (functions, 3944 /// variables, typedefs, etc.) in C and most kinds of names 3945 /// (functions, variables, members, types, etc.) in C++. 3946 LookupOrdinaryName = 0, 3947 /// Tag name lookup, which finds the names of enums, classes, 3948 /// structs, and unions. 3949 LookupTagName, 3950 /// Label name lookup. 3951 LookupLabel, 3952 /// Member name lookup, which finds the names of 3953 /// class/struct/union members. 3954 LookupMemberName, 3955 /// Look up of an operator name (e.g., operator+) for use with 3956 /// operator overloading. This lookup is similar to ordinary name 3957 /// lookup, but will ignore any declarations that are class members. 3958 LookupOperatorName, 3959 /// Look up a name following ~ in a destructor name. This is an ordinary 3960 /// lookup, but prefers tags to typedefs. 3961 LookupDestructorName, 3962 /// Look up of a name that precedes the '::' scope resolution 3963 /// operator in C++. This lookup completely ignores operator, object, 3964 /// function, and enumerator names (C++ [basic.lookup.qual]p1). 3965 LookupNestedNameSpecifierName, 3966 /// Look up a namespace name within a C++ using directive or 3967 /// namespace alias definition, ignoring non-namespace names (C++ 3968 /// [basic.lookup.udir]p1). 3969 LookupNamespaceName, 3970 /// Look up all declarations in a scope with the given name, 3971 /// including resolved using declarations. This is appropriate 3972 /// for checking redeclarations for a using declaration. 3973 LookupUsingDeclName, 3974 /// Look up an ordinary name that is going to be redeclared as a 3975 /// name with linkage. This lookup ignores any declarations that 3976 /// are outside of the current scope unless they have linkage. See 3977 /// C99 6.2.2p4-5 and C++ [basic.link]p6. 3978 LookupRedeclarationWithLinkage, 3979 /// Look up a friend of a local class. This lookup does not look 3980 /// outside the innermost non-class scope. See C++11 [class.friend]p11. 3981 LookupLocalFriendName, 3982 /// Look up the name of an Objective-C protocol. 3983 LookupObjCProtocolName, 3984 /// Look up implicit 'self' parameter of an objective-c method. 3985 LookupObjCImplicitSelfParam, 3986 /// Look up the name of an OpenMP user-defined reduction operation. 3987 LookupOMPReductionName, 3988 /// Look up the name of an OpenMP user-defined mapper. 3989 LookupOMPMapperName, 3990 /// Look up any declaration with any name. 3991 LookupAnyName 3992 }; 3993 3994 /// Specifies whether (or how) name lookup is being performed for a 3995 /// redeclaration (vs. a reference). 3996 enum RedeclarationKind { 3997 /// The lookup is a reference to this name that is not for the 3998 /// purpose of redeclaring the name. 3999 NotForRedeclaration = 0, 4000 /// The lookup results will be used for redeclaration of a name, 4001 /// if an entity by that name already exists and is visible. 4002 ForVisibleRedeclaration, 4003 /// The lookup results will be used for redeclaration of a name 4004 /// with external linkage; non-visible lookup results with external linkage 4005 /// may also be found. 4006 ForExternalRedeclaration 4007 }; 4008 4009 RedeclarationKind forRedeclarationInCurContext() { 4010 // A declaration with an owning module for linkage can never link against 4011 // anything that is not visible. We don't need to check linkage here; if 4012 // the context has internal linkage, redeclaration lookup won't find things 4013 // from other TUs, and we can't safely compute linkage yet in general. 4014 if (cast<Decl>(CurContext) 4015 ->getOwningModuleForLinkage(/*IgnoreLinkage*/true)) 4016 return ForVisibleRedeclaration; 4017 return ForExternalRedeclaration; 4018 } 4019 4020 /// The possible outcomes of name lookup for a literal operator. 4021 enum LiteralOperatorLookupResult { 4022 /// The lookup resulted in an error. 4023 LOLR_Error, 4024 /// The lookup found no match but no diagnostic was issued. 4025 LOLR_ErrorNoDiagnostic, 4026 /// The lookup found a single 'cooked' literal operator, which 4027 /// expects a normal literal to be built and passed to it. 4028 LOLR_Cooked, 4029 /// The lookup found a single 'raw' literal operator, which expects 4030 /// a string literal containing the spelling of the literal token. 4031 LOLR_Raw, 4032 /// The lookup found an overload set of literal operator templates, 4033 /// which expect the characters of the spelling of the literal token to be 4034 /// passed as a non-type template argument pack. 4035 LOLR_Template, 4036 /// The lookup found an overload set of literal operator templates, 4037 /// which expect the character type and characters of the spelling of the 4038 /// string literal token to be passed as template arguments. 4039 LOLR_StringTemplatePack, 4040 }; 4041 4042 SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, 4043 CXXSpecialMember SM, 4044 bool ConstArg, 4045 bool VolatileArg, 4046 bool RValueThis, 4047 bool ConstThis, 4048 bool VolatileThis); 4049 4050 typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator; 4051 typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)> 4052 TypoRecoveryCallback; 4053 4054 private: 4055 bool CppLookupName(LookupResult &R, Scope *S); 4056 4057 struct TypoExprState { 4058 std::unique_ptr<TypoCorrectionConsumer> Consumer; 4059 TypoDiagnosticGenerator DiagHandler; 4060 TypoRecoveryCallback RecoveryHandler; 4061 TypoExprState(); 4062 TypoExprState(TypoExprState &&other) noexcept; 4063 TypoExprState &operator=(TypoExprState &&other) noexcept; 4064 }; 4065 4066 /// The set of unhandled TypoExprs and their associated state. 4067 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos; 4068 4069 /// Creates a new TypoExpr AST node. 4070 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC, 4071 TypoDiagnosticGenerator TDG, 4072 TypoRecoveryCallback TRC, SourceLocation TypoLoc); 4073 4074 // The set of known/encountered (unique, canonicalized) NamespaceDecls. 4075 // 4076 // The boolean value will be true to indicate that the namespace was loaded 4077 // from an AST/PCH file, or false otherwise. 4078 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces; 4079 4080 /// Whether we have already loaded known namespaces from an extenal 4081 /// source. 4082 bool LoadedExternalKnownNamespaces; 4083 4084 /// Helper for CorrectTypo and CorrectTypoDelayed used to create and 4085 /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction 4086 /// should be skipped entirely. 4087 std::unique_ptr<TypoCorrectionConsumer> 4088 makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo, 4089 Sema::LookupNameKind LookupKind, Scope *S, 4090 CXXScopeSpec *SS, 4091 CorrectionCandidateCallback &CCC, 4092 DeclContext *MemberContext, bool EnteringContext, 4093 const ObjCObjectPointerType *OPT, 4094 bool ErrorRecovery); 4095 4096 public: 4097 const TypoExprState &getTypoExprState(TypoExpr *TE) const; 4098 4099 /// Clears the state of the given TypoExpr. 4100 void clearDelayedTypo(TypoExpr *TE); 4101 4102 /// Look up a name, looking for a single declaration. Return 4103 /// null if the results were absent, ambiguous, or overloaded. 4104 /// 4105 /// It is preferable to use the elaborated form and explicitly handle 4106 /// ambiguity and overloaded. 4107 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name, 4108 SourceLocation Loc, 4109 LookupNameKind NameKind, 4110 RedeclarationKind Redecl 4111 = NotForRedeclaration); 4112 bool LookupBuiltin(LookupResult &R); 4113 void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID); 4114 bool LookupName(LookupResult &R, Scope *S, 4115 bool AllowBuiltinCreation = false); 4116 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, 4117 bool InUnqualifiedLookup = false); 4118 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, 4119 CXXScopeSpec &SS); 4120 bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, 4121 bool AllowBuiltinCreation = false, 4122 bool EnteringContext = false); 4123 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc, 4124 RedeclarationKind Redecl 4125 = NotForRedeclaration); 4126 bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class); 4127 4128 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, 4129 UnresolvedSetImpl &Functions); 4130 4131 LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, 4132 SourceLocation GnuLabelLoc = SourceLocation()); 4133 4134 DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class); 4135 CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class); 4136 CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class, 4137 unsigned Quals); 4138 CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals, 4139 bool RValueThis, unsigned ThisQuals); 4140 CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class, 4141 unsigned Quals); 4142 CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals, 4143 bool RValueThis, unsigned ThisQuals); 4144 CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class); 4145 4146 bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id, 4147 bool IsUDSuffix); 4148 LiteralOperatorLookupResult 4149 LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys, 4150 bool AllowRaw, bool AllowTemplate, 4151 bool AllowStringTemplate, bool DiagnoseMissing, 4152 StringLiteral *StringLit = nullptr); 4153 bool isKnownName(StringRef name); 4154 4155 /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs. 4156 enum class FunctionEmissionStatus { 4157 Emitted, 4158 CUDADiscarded, // Discarded due to CUDA/HIP hostness 4159 OMPDiscarded, // Discarded due to OpenMP hostness 4160 TemplateDiscarded, // Discarded due to uninstantiated templates 4161 Unknown, 4162 }; 4163 FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl, 4164 bool Final = false); 4165 4166 // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check. 4167 bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee); 4168 4169 void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, 4170 ArrayRef<Expr *> Args, ADLResult &Functions); 4171 4172 void LookupVisibleDecls(Scope *S, LookupNameKind Kind, 4173 VisibleDeclConsumer &Consumer, 4174 bool IncludeGlobalScope = true, 4175 bool LoadExternal = true); 4176 void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind, 4177 VisibleDeclConsumer &Consumer, 4178 bool IncludeGlobalScope = true, 4179 bool IncludeDependentBases = false, 4180 bool LoadExternal = true); 4181 4182 enum CorrectTypoKind { 4183 CTK_NonError, // CorrectTypo used in a non error recovery situation. 4184 CTK_ErrorRecovery // CorrectTypo used in normal error recovery. 4185 }; 4186 4187 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, 4188 Sema::LookupNameKind LookupKind, 4189 Scope *S, CXXScopeSpec *SS, 4190 CorrectionCandidateCallback &CCC, 4191 CorrectTypoKind Mode, 4192 DeclContext *MemberContext = nullptr, 4193 bool EnteringContext = false, 4194 const ObjCObjectPointerType *OPT = nullptr, 4195 bool RecordFailure = true); 4196 4197 TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo, 4198 Sema::LookupNameKind LookupKind, Scope *S, 4199 CXXScopeSpec *SS, 4200 CorrectionCandidateCallback &CCC, 4201 TypoDiagnosticGenerator TDG, 4202 TypoRecoveryCallback TRC, CorrectTypoKind Mode, 4203 DeclContext *MemberContext = nullptr, 4204 bool EnteringContext = false, 4205 const ObjCObjectPointerType *OPT = nullptr); 4206 4207 /// Process any TypoExprs in the given Expr and its children, 4208 /// generating diagnostics as appropriate and returning a new Expr if there 4209 /// were typos that were all successfully corrected and ExprError if one or 4210 /// more typos could not be corrected. 4211 /// 4212 /// \param E The Expr to check for TypoExprs. 4213 /// 4214 /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its 4215 /// initializer. 4216 /// 4217 /// \param RecoverUncorrectedTypos If true, when typo correction fails, it 4218 /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs. 4219 /// 4220 /// \param Filter A function applied to a newly rebuilt Expr to determine if 4221 /// it is an acceptable/usable result from a single combination of typo 4222 /// corrections. As long as the filter returns ExprError, different 4223 /// combinations of corrections will be tried until all are exhausted. 4224 ExprResult CorrectDelayedTyposInExpr( 4225 Expr *E, VarDecl *InitDecl = nullptr, 4226 bool RecoverUncorrectedTypos = false, 4227 llvm::function_ref<ExprResult(Expr *)> Filter = 4228 [](Expr *E) -> ExprResult { return E; }); 4229 4230 ExprResult CorrectDelayedTyposInExpr( 4231 ExprResult ER, VarDecl *InitDecl = nullptr, 4232 bool RecoverUncorrectedTypos = false, 4233 llvm::function_ref<ExprResult(Expr *)> Filter = 4234 [](Expr *E) -> ExprResult { return E; }) { 4235 return ER.isInvalid() 4236 ? ER 4237 : CorrectDelayedTyposInExpr(ER.get(), InitDecl, 4238 RecoverUncorrectedTypos, Filter); 4239 } 4240 4241 void diagnoseTypo(const TypoCorrection &Correction, 4242 const PartialDiagnostic &TypoDiag, 4243 bool ErrorRecovery = true); 4244 4245 void diagnoseTypo(const TypoCorrection &Correction, 4246 const PartialDiagnostic &TypoDiag, 4247 const PartialDiagnostic &PrevNote, 4248 bool ErrorRecovery = true); 4249 4250 void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F); 4251 4252 void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc, 4253 ArrayRef<Expr *> Args, 4254 AssociatedNamespaceSet &AssociatedNamespaces, 4255 AssociatedClassSet &AssociatedClasses); 4256 4257 void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, 4258 bool ConsiderLinkage, bool AllowInlineNamespace); 4259 4260 bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old); 4261 4262 void DiagnoseAmbiguousLookup(LookupResult &Result); 4263 //@} 4264 4265 /// Attempts to produce a RecoveryExpr after some AST node cannot be created. 4266 ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, 4267 ArrayRef<Expr *> SubExprs, 4268 QualType T = QualType()); 4269 4270 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id, 4271 SourceLocation IdLoc, 4272 bool TypoCorrection = false); 4273 FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, 4274 SourceLocation Loc); 4275 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, 4276 Scope *S, bool ForRedeclaration, 4277 SourceLocation Loc); 4278 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, 4279 Scope *S); 4280 void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction( 4281 FunctionDecl *FD); 4282 void AddKnownFunctionAttributes(FunctionDecl *FD); 4283 4284 // More parsing and symbol table subroutines. 4285 4286 void ProcessPragmaWeak(Scope *S, Decl *D); 4287 // Decl attributes - this routine is the top level dispatcher. 4288 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD); 4289 // Helper for delayed processing of attributes. 4290 void ProcessDeclAttributeDelayed(Decl *D, 4291 const ParsedAttributesView &AttrList); 4292 void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL, 4293 bool IncludeCXX11Attributes = true); 4294 bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, 4295 const ParsedAttributesView &AttrList); 4296 4297 void checkUnusedDeclAttributes(Declarator &D); 4298 4299 /// Handles semantic checking for features that are common to all attributes, 4300 /// such as checking whether a parameter was properly specified, or the 4301 /// correct number of arguments were passed, etc. Returns true if the 4302 /// attribute has been diagnosed. 4303 bool checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A); 4304 bool checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A); 4305 4306 /// Determine if type T is a valid subject for a nonnull and similar 4307 /// attributes. By default, we look through references (the behavior used by 4308 /// nonnull), but if the second parameter is true, then we treat a reference 4309 /// type as valid. 4310 bool isValidPointerAttrType(QualType T, bool RefOkay = false); 4311 4312 bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value); 4313 bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, 4314 const FunctionDecl *FD = nullptr); 4315 bool CheckAttrTarget(const ParsedAttr &CurrAttr); 4316 bool CheckAttrNoArgs(const ParsedAttr &CurrAttr); 4317 bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum, 4318 StringRef &Str, 4319 SourceLocation *ArgLocation = nullptr); 4320 llvm::Error isValidSectionSpecifier(StringRef Str); 4321 bool checkSectionName(SourceLocation LiteralLoc, StringRef Str); 4322 bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str); 4323 bool checkMSInheritanceAttrOnDefinition( 4324 CXXRecordDecl *RD, SourceRange Range, bool BestCase, 4325 MSInheritanceModel SemanticSpelling); 4326 4327 void CheckAlignasUnderalignment(Decl *D); 4328 4329 /// Adjust the calling convention of a method to be the ABI default if it 4330 /// wasn't specified explicitly. This handles method types formed from 4331 /// function type typedefs and typename template arguments. 4332 void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, 4333 SourceLocation Loc); 4334 4335 // Check if there is an explicit attribute, but only look through parens. 4336 // The intent is to look for an attribute on the current declarator, but not 4337 // one that came from a typedef. 4338 bool hasExplicitCallingConv(QualType T); 4339 4340 /// Get the outermost AttributedType node that sets a calling convention. 4341 /// Valid types should not have multiple attributes with different CCs. 4342 const AttributedType *getCallingConvAttributedType(QualType T) const; 4343 4344 /// Process the attributes before creating an attributed statement. Returns 4345 /// the semantic attributes that have been processed. 4346 void ProcessStmtAttributes(Stmt *Stmt, 4347 const ParsedAttributesWithRange &InAttrs, 4348 SmallVectorImpl<const Attr *> &OutAttrs); 4349 4350 void WarnConflictingTypedMethods(ObjCMethodDecl *Method, 4351 ObjCMethodDecl *MethodDecl, 4352 bool IsProtocolMethodDecl); 4353 4354 void CheckConflictingOverridingMethod(ObjCMethodDecl *Method, 4355 ObjCMethodDecl *Overridden, 4356 bool IsProtocolMethodDecl); 4357 4358 /// WarnExactTypedMethods - This routine issues a warning if method 4359 /// implementation declaration matches exactly that of its declaration. 4360 void WarnExactTypedMethods(ObjCMethodDecl *Method, 4361 ObjCMethodDecl *MethodDecl, 4362 bool IsProtocolMethodDecl); 4363 4364 typedef llvm::SmallPtrSet<Selector, 8> SelectorSet; 4365 4366 /// CheckImplementationIvars - This routine checks if the instance variables 4367 /// listed in the implelementation match those listed in the interface. 4368 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, 4369 ObjCIvarDecl **Fields, unsigned nIvars, 4370 SourceLocation Loc); 4371 4372 /// ImplMethodsVsClassMethods - This is main routine to warn if any method 4373 /// remains unimplemented in the class or category \@implementation. 4374 void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl, 4375 ObjCContainerDecl* IDecl, 4376 bool IncompleteImpl = false); 4377 4378 /// DiagnoseUnimplementedProperties - This routine warns on those properties 4379 /// which must be implemented by this implementation. 4380 void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl, 4381 ObjCContainerDecl *CDecl, 4382 bool SynthesizeProperties); 4383 4384 /// Diagnose any null-resettable synthesized setters. 4385 void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl); 4386 4387 /// DefaultSynthesizeProperties - This routine default synthesizes all 4388 /// properties which must be synthesized in the class's \@implementation. 4389 void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, 4390 ObjCInterfaceDecl *IDecl, 4391 SourceLocation AtEnd); 4392 void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd); 4393 4394 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is 4395 /// an ivar synthesized for 'Method' and 'Method' is a property accessor 4396 /// declared in class 'IFace'. 4397 bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, 4398 ObjCMethodDecl *Method, ObjCIvarDecl *IV); 4399 4400 /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which 4401 /// backs the property is not used in the property's accessor. 4402 void DiagnoseUnusedBackingIvarInAccessor(Scope *S, 4403 const ObjCImplementationDecl *ImplD); 4404 4405 /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and 4406 /// it property has a backing ivar, returns this ivar; otherwise, returns NULL. 4407 /// It also returns ivar's property on success. 4408 ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method, 4409 const ObjCPropertyDecl *&PDecl) const; 4410 4411 /// Called by ActOnProperty to handle \@property declarations in 4412 /// class extensions. 4413 ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S, 4414 SourceLocation AtLoc, 4415 SourceLocation LParenLoc, 4416 FieldDeclarator &FD, 4417 Selector GetterSel, 4418 SourceLocation GetterNameLoc, 4419 Selector SetterSel, 4420 SourceLocation SetterNameLoc, 4421 const bool isReadWrite, 4422 unsigned &Attributes, 4423 const unsigned AttributesAsWritten, 4424 QualType T, 4425 TypeSourceInfo *TSI, 4426 tok::ObjCKeywordKind MethodImplKind); 4427 4428 /// Called by ActOnProperty and HandlePropertyInClassExtension to 4429 /// handle creating the ObjcPropertyDecl for a category or \@interface. 4430 ObjCPropertyDecl *CreatePropertyDecl(Scope *S, 4431 ObjCContainerDecl *CDecl, 4432 SourceLocation AtLoc, 4433 SourceLocation LParenLoc, 4434 FieldDeclarator &FD, 4435 Selector GetterSel, 4436 SourceLocation GetterNameLoc, 4437 Selector SetterSel, 4438 SourceLocation SetterNameLoc, 4439 const bool isReadWrite, 4440 const unsigned Attributes, 4441 const unsigned AttributesAsWritten, 4442 QualType T, 4443 TypeSourceInfo *TSI, 4444 tok::ObjCKeywordKind MethodImplKind, 4445 DeclContext *lexicalDC = nullptr); 4446 4447 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via 4448 /// warning) when atomic property has one but not the other user-declared 4449 /// setter or getter. 4450 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl, 4451 ObjCInterfaceDecl* IDecl); 4452 4453 void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D); 4454 4455 void DiagnoseMissingDesignatedInitOverrides( 4456 const ObjCImplementationDecl *ImplD, 4457 const ObjCInterfaceDecl *IFD); 4458 4459 void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID); 4460 4461 enum MethodMatchStrategy { 4462 MMS_loose, 4463 MMS_strict 4464 }; 4465 4466 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns 4467 /// true, or false, accordingly. 4468 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, 4469 const ObjCMethodDecl *PrevMethod, 4470 MethodMatchStrategy strategy = MMS_strict); 4471 4472 /// MatchAllMethodDeclarations - Check methods declaraed in interface or 4473 /// or protocol against those declared in their implementations. 4474 void MatchAllMethodDeclarations(const SelectorSet &InsMap, 4475 const SelectorSet &ClsMap, 4476 SelectorSet &InsMapSeen, 4477 SelectorSet &ClsMapSeen, 4478 ObjCImplDecl* IMPDecl, 4479 ObjCContainerDecl* IDecl, 4480 bool &IncompleteImpl, 4481 bool ImmediateClass, 4482 bool WarnCategoryMethodImpl=false); 4483 4484 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in 4485 /// category matches with those implemented in its primary class and 4486 /// warns each time an exact match is found. 4487 void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP); 4488 4489 /// Add the given method to the list of globally-known methods. 4490 void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method); 4491 4492 /// Returns default addr space for method qualifiers. 4493 LangAS getDefaultCXXMethodAddrSpace() const; 4494 4495 private: 4496 /// AddMethodToGlobalPool - Add an instance or factory method to the global 4497 /// pool. See descriptoin of AddInstanceMethodToGlobalPool. 4498 void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance); 4499 4500 /// LookupMethodInGlobalPool - Returns the instance or factory method and 4501 /// optionally warns if there are multiple signatures. 4502 ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R, 4503 bool receiverIdOrClass, 4504 bool instance); 4505 4506 public: 4507 /// - Returns instance or factory methods in global method pool for 4508 /// given selector. It checks the desired kind first, if none is found, and 4509 /// parameter checkTheOther is set, it then checks the other kind. If no such 4510 /// method or only one method is found, function returns false; otherwise, it 4511 /// returns true. 4512 bool 4513 CollectMultipleMethodsInGlobalPool(Selector Sel, 4514 SmallVectorImpl<ObjCMethodDecl*>& Methods, 4515 bool InstanceFirst, bool CheckTheOther, 4516 const ObjCObjectType *TypeBound = nullptr); 4517 4518 bool 4519 AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod, 4520 SourceRange R, bool receiverIdOrClass, 4521 SmallVectorImpl<ObjCMethodDecl*>& Methods); 4522 4523 void 4524 DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods, 4525 Selector Sel, SourceRange R, 4526 bool receiverIdOrClass); 4527 4528 private: 4529 /// - Returns a selector which best matches given argument list or 4530 /// nullptr if none could be found 4531 ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args, 4532 bool IsInstance, 4533 SmallVectorImpl<ObjCMethodDecl*>& Methods); 4534 4535 4536 /// Record the typo correction failure and return an empty correction. 4537 TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc, 4538 bool RecordFailure = true) { 4539 if (RecordFailure) 4540 TypoCorrectionFailures[Typo].insert(TypoLoc); 4541 return TypoCorrection(); 4542 } 4543 4544 public: 4545 /// AddInstanceMethodToGlobalPool - All instance methods in a translation 4546 /// unit are added to a global pool. This allows us to efficiently associate 4547 /// a selector with a method declaraation for purposes of typechecking 4548 /// messages sent to "id" (where the class of the object is unknown). 4549 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) { 4550 AddMethodToGlobalPool(Method, impl, /*instance*/true); 4551 } 4552 4553 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods. 4554 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) { 4555 AddMethodToGlobalPool(Method, impl, /*instance*/false); 4556 } 4557 4558 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global 4559 /// pool. 4560 void AddAnyMethodToGlobalPool(Decl *D); 4561 4562 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if 4563 /// there are multiple signatures. 4564 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, 4565 bool receiverIdOrClass=false) { 4566 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass, 4567 /*instance*/true); 4568 } 4569 4570 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if 4571 /// there are multiple signatures. 4572 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R, 4573 bool receiverIdOrClass=false) { 4574 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass, 4575 /*instance*/false); 4576 } 4577 4578 const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel, 4579 QualType ObjectType=QualType()); 4580 /// LookupImplementedMethodInGlobalPool - Returns the method which has an 4581 /// implementation. 4582 ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel); 4583 4584 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require 4585 /// initialization. 4586 void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, 4587 SmallVectorImpl<ObjCIvarDecl*> &Ivars); 4588 4589 //===--------------------------------------------------------------------===// 4590 // Statement Parsing Callbacks: SemaStmt.cpp. 4591 public: 4592 class FullExprArg { 4593 public: 4594 FullExprArg() : E(nullptr) { } 4595 FullExprArg(Sema &actions) : E(nullptr) { } 4596 4597 ExprResult release() { 4598 return E; 4599 } 4600 4601 Expr *get() const { return E; } 4602 4603 Expr *operator->() { 4604 return E; 4605 } 4606 4607 private: 4608 // FIXME: No need to make the entire Sema class a friend when it's just 4609 // Sema::MakeFullExpr that needs access to the constructor below. 4610 friend class Sema; 4611 4612 explicit FullExprArg(Expr *expr) : E(expr) {} 4613 4614 Expr *E; 4615 }; 4616 4617 FullExprArg MakeFullExpr(Expr *Arg) { 4618 return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation()); 4619 } 4620 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) { 4621 return FullExprArg( 4622 ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get()); 4623 } 4624 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) { 4625 ExprResult FE = 4626 ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(), 4627 /*DiscardedValue*/ true); 4628 return FullExprArg(FE.get()); 4629 } 4630 4631 StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true); 4632 StmtResult ActOnExprStmtError(); 4633 4634 StmtResult ActOnNullStmt(SourceLocation SemiLoc, 4635 bool HasLeadingEmptyMacro = false); 4636 4637 void ActOnStartOfCompoundStmt(bool IsStmtExpr); 4638 void ActOnAfterCompoundStatementLeadingPragmas(); 4639 void ActOnFinishOfCompoundStmt(); 4640 StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, 4641 ArrayRef<Stmt *> Elts, bool isStmtExpr); 4642 4643 /// A RAII object to enter scope of a compound statement. 4644 class CompoundScopeRAII { 4645 public: 4646 CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) { 4647 S.ActOnStartOfCompoundStmt(IsStmtExpr); 4648 } 4649 4650 ~CompoundScopeRAII() { 4651 S.ActOnFinishOfCompoundStmt(); 4652 } 4653 4654 private: 4655 Sema &S; 4656 }; 4657 4658 /// An RAII helper that pops function a function scope on exit. 4659 struct FunctionScopeRAII { 4660 Sema &S; 4661 bool Active; 4662 FunctionScopeRAII(Sema &S) : S(S), Active(true) {} 4663 ~FunctionScopeRAII() { 4664 if (Active) 4665 S.PopFunctionScopeInfo(); 4666 } 4667 void disable() { Active = false; } 4668 }; 4669 4670 StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, 4671 SourceLocation StartLoc, 4672 SourceLocation EndLoc); 4673 void ActOnForEachDeclStmt(DeclGroupPtrTy Decl); 4674 StmtResult ActOnForEachLValueExpr(Expr *E); 4675 ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val); 4676 StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, 4677 SourceLocation DotDotDotLoc, ExprResult RHS, 4678 SourceLocation ColonLoc); 4679 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt); 4680 4681 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, 4682 SourceLocation ColonLoc, 4683 Stmt *SubStmt, Scope *CurScope); 4684 StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, 4685 SourceLocation ColonLoc, Stmt *SubStmt); 4686 4687 StmtResult BuildAttributedStmt(SourceLocation AttrsLoc, 4688 ArrayRef<const Attr *> Attrs, Stmt *SubStmt); 4689 StmtResult ActOnAttributedStmt(const ParsedAttributesWithRange &AttrList, 4690 Stmt *SubStmt); 4691 4692 class ConditionResult; 4693 StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr, 4694 SourceLocation LParenLoc, Stmt *InitStmt, 4695 ConditionResult Cond, SourceLocation RParenLoc, 4696 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal); 4697 StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr, 4698 SourceLocation LParenLoc, Stmt *InitStmt, 4699 ConditionResult Cond, SourceLocation RParenLoc, 4700 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal); 4701 StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, 4702 SourceLocation LParenLoc, Stmt *InitStmt, 4703 ConditionResult Cond, 4704 SourceLocation RParenLoc); 4705 StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, 4706 Stmt *Switch, Stmt *Body); 4707 StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, 4708 ConditionResult Cond, SourceLocation RParenLoc, 4709 Stmt *Body); 4710 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, 4711 SourceLocation WhileLoc, SourceLocation CondLParen, 4712 Expr *Cond, SourceLocation CondRParen); 4713 4714 StmtResult ActOnForStmt(SourceLocation ForLoc, 4715 SourceLocation LParenLoc, 4716 Stmt *First, 4717 ConditionResult Second, 4718 FullExprArg Third, 4719 SourceLocation RParenLoc, 4720 Stmt *Body); 4721 ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc, 4722 Expr *collection); 4723 StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, 4724 Stmt *First, Expr *collection, 4725 SourceLocation RParenLoc); 4726 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body); 4727 4728 enum BuildForRangeKind { 4729 /// Initial building of a for-range statement. 4730 BFRK_Build, 4731 /// Instantiation or recovery rebuild of a for-range statement. Don't 4732 /// attempt any typo-correction. 4733 BFRK_Rebuild, 4734 /// Determining whether a for-range statement could be built. Avoid any 4735 /// unnecessary or irreversible actions. 4736 BFRK_Check 4737 }; 4738 4739 StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, 4740 SourceLocation CoawaitLoc, 4741 Stmt *InitStmt, 4742 Stmt *LoopVar, 4743 SourceLocation ColonLoc, Expr *Collection, 4744 SourceLocation RParenLoc, 4745 BuildForRangeKind Kind); 4746 StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc, 4747 SourceLocation CoawaitLoc, 4748 Stmt *InitStmt, 4749 SourceLocation ColonLoc, 4750 Stmt *RangeDecl, Stmt *Begin, Stmt *End, 4751 Expr *Cond, Expr *Inc, 4752 Stmt *LoopVarDecl, 4753 SourceLocation RParenLoc, 4754 BuildForRangeKind Kind); 4755 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body); 4756 4757 StmtResult ActOnGotoStmt(SourceLocation GotoLoc, 4758 SourceLocation LabelLoc, 4759 LabelDecl *TheDecl); 4760 StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, 4761 SourceLocation StarLoc, 4762 Expr *DestExp); 4763 StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope); 4764 StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope); 4765 4766 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, 4767 CapturedRegionKind Kind, unsigned NumParams); 4768 typedef std::pair<StringRef, QualType> CapturedParamNameType; 4769 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, 4770 CapturedRegionKind Kind, 4771 ArrayRef<CapturedParamNameType> Params, 4772 unsigned OpenMPCaptureLevel = 0); 4773 StmtResult ActOnCapturedRegionEnd(Stmt *S); 4774 void ActOnCapturedRegionError(); 4775 RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD, 4776 SourceLocation Loc, 4777 unsigned NumParams); 4778 4779 struct NamedReturnInfo { 4780 const VarDecl *Candidate; 4781 4782 enum Status : uint8_t { None, MoveEligible, MoveEligibleAndCopyElidable }; 4783 Status S; 4784 4785 bool isMoveEligible() const { return S != None; }; 4786 bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; } 4787 }; 4788 enum class SimplerImplicitMoveMode { ForceOff, Normal, ForceOn }; 4789 NamedReturnInfo getNamedReturnInfo( 4790 Expr *&E, SimplerImplicitMoveMode Mode = SimplerImplicitMoveMode::Normal); 4791 NamedReturnInfo getNamedReturnInfo(const VarDecl *VD); 4792 const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info, 4793 QualType ReturnType); 4794 4795 ExprResult 4796 PerformMoveOrCopyInitialization(const InitializedEntity &Entity, 4797 const NamedReturnInfo &NRInfo, Expr *Value, 4798 bool SupressSimplerImplicitMoves = false); 4799 4800 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, 4801 Scope *CurScope); 4802 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp); 4803 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, 4804 NamedReturnInfo &NRInfo, 4805 bool SupressSimplerImplicitMoves); 4806 4807 StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, 4808 bool IsVolatile, unsigned NumOutputs, 4809 unsigned NumInputs, IdentifierInfo **Names, 4810 MultiExprArg Constraints, MultiExprArg Exprs, 4811 Expr *AsmString, MultiExprArg Clobbers, 4812 unsigned NumLabels, 4813 SourceLocation RParenLoc); 4814 4815 void FillInlineAsmIdentifierInfo(Expr *Res, 4816 llvm::InlineAsmIdentifierInfo &Info); 4817 ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS, 4818 SourceLocation TemplateKWLoc, 4819 UnqualifiedId &Id, 4820 bool IsUnevaluatedContext); 4821 bool LookupInlineAsmField(StringRef Base, StringRef Member, 4822 unsigned &Offset, SourceLocation AsmLoc); 4823 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member, 4824 SourceLocation AsmLoc); 4825 StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, 4826 ArrayRef<Token> AsmToks, 4827 StringRef AsmString, 4828 unsigned NumOutputs, unsigned NumInputs, 4829 ArrayRef<StringRef> Constraints, 4830 ArrayRef<StringRef> Clobbers, 4831 ArrayRef<Expr*> Exprs, 4832 SourceLocation EndLoc); 4833 LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName, 4834 SourceLocation Location, 4835 bool AlwaysCreate); 4836 4837 VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType, 4838 SourceLocation StartLoc, 4839 SourceLocation IdLoc, IdentifierInfo *Id, 4840 bool Invalid = false); 4841 4842 Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D); 4843 4844 StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen, 4845 Decl *Parm, Stmt *Body); 4846 4847 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body); 4848 4849 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try, 4850 MultiStmtArg Catch, Stmt *Finally); 4851 4852 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw); 4853 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw, 4854 Scope *CurScope); 4855 ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, 4856 Expr *operand); 4857 StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, 4858 Expr *SynchExpr, 4859 Stmt *SynchBody); 4860 4861 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body); 4862 4863 VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, 4864 SourceLocation StartLoc, 4865 SourceLocation IdLoc, 4866 IdentifierInfo *Id); 4867 4868 Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D); 4869 4870 StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc, 4871 Decl *ExDecl, Stmt *HandlerBlock); 4872 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, 4873 ArrayRef<Stmt *> Handlers); 4874 4875 StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ? 4876 SourceLocation TryLoc, Stmt *TryBlock, 4877 Stmt *Handler); 4878 StmtResult ActOnSEHExceptBlock(SourceLocation Loc, 4879 Expr *FilterExpr, 4880 Stmt *Block); 4881 void ActOnStartSEHFinallyBlock(); 4882 void ActOnAbortSEHFinallyBlock(); 4883 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block); 4884 StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope); 4885 4886 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock); 4887 4888 bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const; 4889 4890 /// If it's a file scoped decl that must warn if not used, keep track 4891 /// of it. 4892 void MarkUnusedFileScopedDecl(const DeclaratorDecl *D); 4893 4894 /// DiagnoseUnusedExprResult - If the statement passed in is an expression 4895 /// whose result is unused, warn. 4896 void DiagnoseUnusedExprResult(const Stmt *S); 4897 void DiagnoseUnusedNestedTypedefs(const RecordDecl *D); 4898 void DiagnoseUnusedDecl(const NamedDecl *ND); 4899 4900 /// If VD is set but not otherwise used, diagnose, for a parameter or a 4901 /// variable. 4902 void DiagnoseUnusedButSetDecl(const VarDecl *VD); 4903 4904 /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null 4905 /// statement as a \p Body, and it is located on the same line. 4906 /// 4907 /// This helps prevent bugs due to typos, such as: 4908 /// if (condition); 4909 /// do_stuff(); 4910 void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, 4911 const Stmt *Body, 4912 unsigned DiagID); 4913 4914 /// Warn if a for/while loop statement \p S, which is followed by 4915 /// \p PossibleBody, has a suspicious null statement as a body. 4916 void DiagnoseEmptyLoopBody(const Stmt *S, 4917 const Stmt *PossibleBody); 4918 4919 /// Warn if a value is moved to itself. 4920 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, 4921 SourceLocation OpLoc); 4922 4923 /// Warn if we're implicitly casting from a _Nullable pointer type to a 4924 /// _Nonnull one. 4925 void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, 4926 SourceLocation Loc); 4927 4928 /// Warn when implicitly casting 0 to nullptr. 4929 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E); 4930 4931 ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) { 4932 return DelayedDiagnostics.push(pool); 4933 } 4934 void PopParsingDeclaration(ParsingDeclState state, Decl *decl); 4935 4936 typedef ProcessingContextState ParsingClassState; 4937 ParsingClassState PushParsingClass() { 4938 ParsingClassDepth++; 4939 return DelayedDiagnostics.pushUndelayed(); 4940 } 4941 void PopParsingClass(ParsingClassState state) { 4942 ParsingClassDepth--; 4943 DelayedDiagnostics.popUndelayed(state); 4944 } 4945 4946 void redelayDiagnostics(sema::DelayedDiagnosticPool &pool); 4947 4948 void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, 4949 const ObjCInterfaceDecl *UnknownObjCClass, 4950 bool ObjCPropertyAccess, 4951 bool AvoidPartialAvailabilityChecks = false, 4952 ObjCInterfaceDecl *ClassReceiver = nullptr); 4953 4954 bool makeUnavailableInSystemHeader(SourceLocation loc, 4955 UnavailableAttr::ImplicitReason reason); 4956 4957 /// Issue any -Wunguarded-availability warnings in \c FD 4958 void DiagnoseUnguardedAvailabilityViolations(Decl *FD); 4959 4960 void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx); 4961 4962 //===--------------------------------------------------------------------===// 4963 // Expression Parsing Callbacks: SemaExpr.cpp. 4964 4965 bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid); 4966 bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, 4967 const ObjCInterfaceDecl *UnknownObjCClass = nullptr, 4968 bool ObjCPropertyAccess = false, 4969 bool AvoidPartialAvailabilityChecks = false, 4970 ObjCInterfaceDecl *ClassReciever = nullptr); 4971 void NoteDeletedFunction(FunctionDecl *FD); 4972 void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD); 4973 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD, 4974 ObjCMethodDecl *Getter, 4975 SourceLocation Loc); 4976 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 4977 ArrayRef<Expr *> Args); 4978 4979 void PushExpressionEvaluationContext( 4980 ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr, 4981 ExpressionEvaluationContextRecord::ExpressionKind Type = 4982 ExpressionEvaluationContextRecord::EK_Other); 4983 enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl }; 4984 void PushExpressionEvaluationContext( 4985 ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t, 4986 ExpressionEvaluationContextRecord::ExpressionKind Type = 4987 ExpressionEvaluationContextRecord::EK_Other); 4988 void PopExpressionEvaluationContext(); 4989 4990 void DiscardCleanupsInEvaluationContext(); 4991 4992 ExprResult TransformToPotentiallyEvaluated(Expr *E); 4993 ExprResult HandleExprEvaluationContextForTypeof(Expr *E); 4994 4995 ExprResult CheckUnevaluatedOperand(Expr *E); 4996 void CheckUnusedVolatileAssignment(Expr *E); 4997 4998 ExprResult ActOnConstantExpression(ExprResult Res); 4999 5000 // Functions for marking a declaration referenced. These functions also 5001 // contain the relevant logic for marking if a reference to a function or 5002 // variable is an odr-use (in the C++11 sense). There are separate variants 5003 // for expressions referring to a decl; these exist because odr-use marking 5004 // needs to be delayed for some constant variables when we build one of the 5005 // named expressions. 5006 // 5007 // MightBeOdrUse indicates whether the use could possibly be an odr-use, and 5008 // should usually be true. This only needs to be set to false if the lack of 5009 // odr-use cannot be determined from the current context (for instance, 5010 // because the name denotes a virtual function and was written without an 5011 // explicit nested-name-specifier). 5012 void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse); 5013 void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, 5014 bool MightBeOdrUse = true); 5015 void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var); 5016 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr); 5017 void MarkMemberReferenced(MemberExpr *E); 5018 void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E); 5019 void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc, 5020 unsigned CapturingScopeIndex); 5021 5022 ExprResult CheckLValueToRValueConversionOperand(Expr *E); 5023 void CleanupVarDeclMarking(); 5024 5025 enum TryCaptureKind { 5026 TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef 5027 }; 5028 5029 /// Try to capture the given variable. 5030 /// 5031 /// \param Var The variable to capture. 5032 /// 5033 /// \param Loc The location at which the capture occurs. 5034 /// 5035 /// \param Kind The kind of capture, which may be implicit (for either a 5036 /// block or a lambda), or explicit by-value or by-reference (for a lambda). 5037 /// 5038 /// \param EllipsisLoc The location of the ellipsis, if one is provided in 5039 /// an explicit lambda capture. 5040 /// 5041 /// \param BuildAndDiagnose Whether we are actually supposed to add the 5042 /// captures or diagnose errors. If false, this routine merely check whether 5043 /// the capture can occur without performing the capture itself or complaining 5044 /// if the variable cannot be captured. 5045 /// 5046 /// \param CaptureType Will be set to the type of the field used to capture 5047 /// this variable in the innermost block or lambda. Only valid when the 5048 /// variable can be captured. 5049 /// 5050 /// \param DeclRefType Will be set to the type of a reference to the capture 5051 /// from within the current scope. Only valid when the variable can be 5052 /// captured. 5053 /// 5054 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index 5055 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture. 5056 /// This is useful when enclosing lambdas must speculatively capture 5057 /// variables that may or may not be used in certain specializations of 5058 /// a nested generic lambda. 5059 /// 5060 /// \returns true if an error occurred (i.e., the variable cannot be 5061 /// captured) and false if the capture succeeded. 5062 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, 5063 SourceLocation EllipsisLoc, bool BuildAndDiagnose, 5064 QualType &CaptureType, 5065 QualType &DeclRefType, 5066 const unsigned *const FunctionScopeIndexToStopAt); 5067 5068 /// Try to capture the given variable. 5069 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, 5070 TryCaptureKind Kind = TryCapture_Implicit, 5071 SourceLocation EllipsisLoc = SourceLocation()); 5072 5073 /// Checks if the variable must be captured. 5074 bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc); 5075 5076 /// Given a variable, determine the type that a reference to that 5077 /// variable will have in the given scope. 5078 QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc); 5079 5080 /// Mark all of the declarations referenced within a particular AST node as 5081 /// referenced. Used when template instantiation instantiates a non-dependent 5082 /// type -- entities referenced by the type are now referenced. 5083 void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T); 5084 void MarkDeclarationsReferencedInExpr(Expr *E, 5085 bool SkipLocalVariables = false); 5086 5087 /// Try to recover by turning the given expression into a 5088 /// call. Returns true if recovery was attempted or an error was 5089 /// emitted; this may also leave the ExprResult invalid. 5090 bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, 5091 bool ForceComplain = false, 5092 bool (*IsPlausibleResult)(QualType) = nullptr); 5093 5094 /// Figure out if an expression could be turned into a call. 5095 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, 5096 UnresolvedSetImpl &NonTemplateOverloads); 5097 5098 /// Try to convert an expression \p E to type \p Ty. Returns the result of the 5099 /// conversion. 5100 ExprResult tryConvertExprToType(Expr *E, QualType Ty); 5101 5102 /// Conditionally issue a diagnostic based on the current 5103 /// evaluation context. 5104 /// 5105 /// \param Statement If Statement is non-null, delay reporting the 5106 /// diagnostic until the function body is parsed, and then do a basic 5107 /// reachability analysis to determine if the statement is reachable. 5108 /// If it is unreachable, the diagnostic will not be emitted. 5109 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, 5110 const PartialDiagnostic &PD); 5111 /// Similar, but diagnostic is only produced if all the specified statements 5112 /// are reachable. 5113 bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts, 5114 const PartialDiagnostic &PD); 5115 5116 // Primary Expressions. 5117 SourceRange getExprRange(Expr *E) const; 5118 5119 ExprResult ActOnIdExpression( 5120 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 5121 UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, 5122 CorrectionCandidateCallback *CCC = nullptr, 5123 bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr); 5124 5125 void DecomposeUnqualifiedId(const UnqualifiedId &Id, 5126 TemplateArgumentListInfo &Buffer, 5127 DeclarationNameInfo &NameInfo, 5128 const TemplateArgumentListInfo *&TemplateArgs); 5129 5130 bool DiagnoseDependentMemberLookup(LookupResult &R); 5131 5132 bool 5133 DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 5134 CorrectionCandidateCallback &CCC, 5135 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr, 5136 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr); 5137 5138 DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, 5139 IdentifierInfo *II); 5140 ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV); 5141 5142 ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, 5143 IdentifierInfo *II, 5144 bool AllowBuiltinCreation=false); 5145 5146 ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, 5147 SourceLocation TemplateKWLoc, 5148 const DeclarationNameInfo &NameInfo, 5149 bool isAddressOfOperand, 5150 const TemplateArgumentListInfo *TemplateArgs); 5151 5152 /// If \p D cannot be odr-used in the current expression evaluation context, 5153 /// return a reason explaining why. Otherwise, return NOUR_None. 5154 NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D); 5155 5156 DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 5157 SourceLocation Loc, 5158 const CXXScopeSpec *SS = nullptr); 5159 DeclRefExpr * 5160 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 5161 const DeclarationNameInfo &NameInfo, 5162 const CXXScopeSpec *SS = nullptr, 5163 NamedDecl *FoundD = nullptr, 5164 SourceLocation TemplateKWLoc = SourceLocation(), 5165 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5166 DeclRefExpr * 5167 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 5168 const DeclarationNameInfo &NameInfo, 5169 NestedNameSpecifierLoc NNS, 5170 NamedDecl *FoundD = nullptr, 5171 SourceLocation TemplateKWLoc = SourceLocation(), 5172 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5173 5174 ExprResult 5175 BuildAnonymousStructUnionMemberReference( 5176 const CXXScopeSpec &SS, 5177 SourceLocation nameLoc, 5178 IndirectFieldDecl *indirectField, 5179 DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none), 5180 Expr *baseObjectExpr = nullptr, 5181 SourceLocation opLoc = SourceLocation()); 5182 5183 ExprResult BuildPossibleImplicitMemberExpr( 5184 const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, 5185 const TemplateArgumentListInfo *TemplateArgs, const Scope *S, 5186 UnresolvedLookupExpr *AsULE = nullptr); 5187 ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS, 5188 SourceLocation TemplateKWLoc, 5189 LookupResult &R, 5190 const TemplateArgumentListInfo *TemplateArgs, 5191 bool IsDefiniteInstance, 5192 const Scope *S); 5193 bool UseArgumentDependentLookup(const CXXScopeSpec &SS, 5194 const LookupResult &R, 5195 bool HasTrailingLParen); 5196 5197 ExprResult 5198 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 5199 const DeclarationNameInfo &NameInfo, 5200 bool IsAddressOfOperand, const Scope *S, 5201 TypeSourceInfo **RecoveryTSI = nullptr); 5202 5203 ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, 5204 SourceLocation TemplateKWLoc, 5205 const DeclarationNameInfo &NameInfo, 5206 const TemplateArgumentListInfo *TemplateArgs); 5207 5208 ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, 5209 LookupResult &R, 5210 bool NeedsADL, 5211 bool AcceptInvalidDecl = false); 5212 ExprResult BuildDeclarationNameExpr( 5213 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D, 5214 NamedDecl *FoundD = nullptr, 5215 const TemplateArgumentListInfo *TemplateArgs = nullptr, 5216 bool AcceptInvalidDecl = false); 5217 5218 ExprResult BuildLiteralOperatorCall(LookupResult &R, 5219 DeclarationNameInfo &SuffixInfo, 5220 ArrayRef<Expr *> Args, 5221 SourceLocation LitEndLoc, 5222 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr); 5223 5224 ExprResult BuildPredefinedExpr(SourceLocation Loc, 5225 PredefinedExpr::IdentKind IK); 5226 ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind); 5227 ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val); 5228 5229 ExprResult BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc, 5230 SourceLocation LParen, 5231 SourceLocation RParen, 5232 TypeSourceInfo *TSI); 5233 ExprResult ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc, 5234 SourceLocation LParen, 5235 SourceLocation RParen, 5236 ParsedType ParsedTy); 5237 5238 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc); 5239 5240 ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr); 5241 ExprResult ActOnCharacterConstant(const Token &Tok, 5242 Scope *UDLScope = nullptr); 5243 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E); 5244 ExprResult ActOnParenListExpr(SourceLocation L, 5245 SourceLocation R, 5246 MultiExprArg Val); 5247 5248 /// ActOnStringLiteral - The specified tokens were lexed as pasted string 5249 /// fragments (e.g. "foo" "bar" L"baz"). 5250 ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks, 5251 Scope *UDLScope = nullptr); 5252 5253 ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, 5254 SourceLocation DefaultLoc, 5255 SourceLocation RParenLoc, 5256 Expr *ControllingExpr, 5257 ArrayRef<ParsedType> ArgTypes, 5258 ArrayRef<Expr *> ArgExprs); 5259 ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, 5260 SourceLocation DefaultLoc, 5261 SourceLocation RParenLoc, 5262 Expr *ControllingExpr, 5263 ArrayRef<TypeSourceInfo *> Types, 5264 ArrayRef<Expr *> Exprs); 5265 5266 // Binary/Unary Operators. 'Tok' is the token for the operator. 5267 ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, 5268 Expr *InputExpr); 5269 ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, 5270 UnaryOperatorKind Opc, Expr *Input); 5271 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 5272 tok::TokenKind Op, Expr *Input); 5273 5274 bool isQualifiedMemberAccess(Expr *E); 5275 QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc); 5276 5277 ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 5278 SourceLocation OpLoc, 5279 UnaryExprOrTypeTrait ExprKind, 5280 SourceRange R); 5281 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 5282 UnaryExprOrTypeTrait ExprKind); 5283 ExprResult 5284 ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 5285 UnaryExprOrTypeTrait ExprKind, 5286 bool IsType, void *TyOrEx, 5287 SourceRange ArgRange); 5288 5289 ExprResult CheckPlaceholderExpr(Expr *E); 5290 bool CheckVecStepExpr(Expr *E); 5291 5292 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind); 5293 bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc, 5294 SourceRange ExprRange, 5295 UnaryExprOrTypeTrait ExprKind); 5296 ExprResult ActOnSizeofParameterPackExpr(Scope *S, 5297 SourceLocation OpLoc, 5298 IdentifierInfo &Name, 5299 SourceLocation NameLoc, 5300 SourceLocation RParenLoc); 5301 ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 5302 tok::TokenKind Kind, Expr *Input); 5303 5304 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 5305 Expr *Idx, SourceLocation RLoc); 5306 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 5307 Expr *Idx, SourceLocation RLoc); 5308 5309 ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx, 5310 Expr *ColumnIdx, 5311 SourceLocation RBLoc); 5312 5313 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, 5314 Expr *LowerBound, 5315 SourceLocation ColonLocFirst, 5316 SourceLocation ColonLocSecond, 5317 Expr *Length, Expr *Stride, 5318 SourceLocation RBLoc); 5319 ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc, 5320 SourceLocation RParenLoc, 5321 ArrayRef<Expr *> Dims, 5322 ArrayRef<SourceRange> Brackets); 5323 5324 /// Data structure for iterator expression. 5325 struct OMPIteratorData { 5326 IdentifierInfo *DeclIdent = nullptr; 5327 SourceLocation DeclIdentLoc; 5328 ParsedType Type; 5329 OMPIteratorExpr::IteratorRange Range; 5330 SourceLocation AssignLoc; 5331 SourceLocation ColonLoc; 5332 SourceLocation SecColonLoc; 5333 }; 5334 5335 ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc, 5336 SourceLocation LLoc, SourceLocation RLoc, 5337 ArrayRef<OMPIteratorData> Data); 5338 5339 // This struct is for use by ActOnMemberAccess to allow 5340 // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after 5341 // changing the access operator from a '.' to a '->' (to see if that is the 5342 // change needed to fix an error about an unknown member, e.g. when the class 5343 // defines a custom operator->). 5344 struct ActOnMemberAccessExtraArgs { 5345 Scope *S; 5346 UnqualifiedId &Id; 5347 Decl *ObjCImpDecl; 5348 }; 5349 5350 ExprResult BuildMemberReferenceExpr( 5351 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, 5352 CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 5353 NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, 5354 const TemplateArgumentListInfo *TemplateArgs, 5355 const Scope *S, 5356 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr); 5357 5358 ExprResult 5359 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, 5360 bool IsArrow, const CXXScopeSpec &SS, 5361 SourceLocation TemplateKWLoc, 5362 NamedDecl *FirstQualifierInScope, LookupResult &R, 5363 const TemplateArgumentListInfo *TemplateArgs, 5364 const Scope *S, 5365 bool SuppressQualifierCheck = false, 5366 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr); 5367 5368 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, 5369 SourceLocation OpLoc, 5370 const CXXScopeSpec &SS, FieldDecl *Field, 5371 DeclAccessPair FoundDecl, 5372 const DeclarationNameInfo &MemberNameInfo); 5373 5374 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow); 5375 5376 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType, 5377 const CXXScopeSpec &SS, 5378 const LookupResult &R); 5379 5380 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType, 5381 bool IsArrow, SourceLocation OpLoc, 5382 const CXXScopeSpec &SS, 5383 SourceLocation TemplateKWLoc, 5384 NamedDecl *FirstQualifierInScope, 5385 const DeclarationNameInfo &NameInfo, 5386 const TemplateArgumentListInfo *TemplateArgs); 5387 5388 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base, 5389 SourceLocation OpLoc, 5390 tok::TokenKind OpKind, 5391 CXXScopeSpec &SS, 5392 SourceLocation TemplateKWLoc, 5393 UnqualifiedId &Member, 5394 Decl *ObjCImpDecl); 5395 5396 MemberExpr * 5397 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, 5398 const CXXScopeSpec *SS, SourceLocation TemplateKWLoc, 5399 ValueDecl *Member, DeclAccessPair FoundDecl, 5400 bool HadMultipleCandidates, 5401 const DeclarationNameInfo &MemberNameInfo, QualType Ty, 5402 ExprValueKind VK, ExprObjectKind OK, 5403 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5404 MemberExpr * 5405 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, 5406 NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, 5407 ValueDecl *Member, DeclAccessPair FoundDecl, 5408 bool HadMultipleCandidates, 5409 const DeclarationNameInfo &MemberNameInfo, QualType Ty, 5410 ExprValueKind VK, ExprObjectKind OK, 5411 const TemplateArgumentListInfo *TemplateArgs = nullptr); 5412 5413 void ActOnDefaultCtorInitializers(Decl *CDtorDecl); 5414 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 5415 FunctionDecl *FDecl, 5416 const FunctionProtoType *Proto, 5417 ArrayRef<Expr *> Args, 5418 SourceLocation RParenLoc, 5419 bool ExecConfig = false); 5420 void CheckStaticArrayArgument(SourceLocation CallLoc, 5421 ParmVarDecl *Param, 5422 const Expr *ArgExpr); 5423 5424 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 5425 /// This provides the location of the left/right parens and a list of comma 5426 /// locations. 5427 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 5428 MultiExprArg ArgExprs, SourceLocation RParenLoc, 5429 Expr *ExecConfig = nullptr); 5430 ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 5431 MultiExprArg ArgExprs, SourceLocation RParenLoc, 5432 Expr *ExecConfig = nullptr, 5433 bool IsExecConfig = false, 5434 bool AllowRecovery = false); 5435 Expr *BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id, 5436 MultiExprArg CallArgs); 5437 enum class AtomicArgumentOrder { API, AST }; 5438 ExprResult 5439 BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, 5440 SourceLocation RParenLoc, MultiExprArg Args, 5441 AtomicExpr::AtomicOp Op, 5442 AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API); 5443 ExprResult 5444 BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, 5445 ArrayRef<Expr *> Arg, SourceLocation RParenLoc, 5446 Expr *Config = nullptr, bool IsExecConfig = false, 5447 ADLCallKind UsesADL = ADLCallKind::NotADL); 5448 5449 ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 5450 MultiExprArg ExecConfig, 5451 SourceLocation GGGLoc); 5452 5453 ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 5454 Declarator &D, ParsedType &Ty, 5455 SourceLocation RParenLoc, Expr *CastExpr); 5456 ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, 5457 TypeSourceInfo *Ty, 5458 SourceLocation RParenLoc, 5459 Expr *Op); 5460 CastKind PrepareScalarCast(ExprResult &src, QualType destType); 5461 5462 /// Build an altivec or OpenCL literal. 5463 ExprResult BuildVectorLiteral(SourceLocation LParenLoc, 5464 SourceLocation RParenLoc, Expr *E, 5465 TypeSourceInfo *TInfo); 5466 5467 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME); 5468 5469 ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, 5470 ParsedType Ty, 5471 SourceLocation RParenLoc, 5472 Expr *InitExpr); 5473 5474 ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, 5475 TypeSourceInfo *TInfo, 5476 SourceLocation RParenLoc, 5477 Expr *LiteralExpr); 5478 5479 ExprResult ActOnInitList(SourceLocation LBraceLoc, 5480 MultiExprArg InitArgList, 5481 SourceLocation RBraceLoc); 5482 5483 ExprResult BuildInitList(SourceLocation LBraceLoc, 5484 MultiExprArg InitArgList, 5485 SourceLocation RBraceLoc); 5486 5487 ExprResult ActOnDesignatedInitializer(Designation &Desig, 5488 SourceLocation EqualOrColonLoc, 5489 bool GNUSyntax, 5490 ExprResult Init); 5491 5492 private: 5493 static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind); 5494 5495 public: 5496 ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, 5497 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr); 5498 ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, 5499 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr); 5500 ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, 5501 Expr *LHSExpr, Expr *RHSExpr); 5502 void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, 5503 UnresolvedSetImpl &Functions); 5504 5505 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc); 5506 5507 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 5508 /// in the case of a the GNU conditional expr extension. 5509 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, 5510 SourceLocation ColonLoc, 5511 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr); 5512 5513 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 5514 ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 5515 LabelDecl *TheDecl); 5516 5517 void ActOnStartStmtExpr(); 5518 ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt, 5519 SourceLocation RPLoc); 5520 ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 5521 SourceLocation RPLoc, unsigned TemplateDepth); 5522 // Handle the final expression in a statement expression. 5523 ExprResult ActOnStmtExprResult(ExprResult E); 5524 void ActOnStmtExprError(); 5525 5526 // __builtin_offsetof(type, identifier(.identifier|[expr])*) 5527 struct OffsetOfComponent { 5528 SourceLocation LocStart, LocEnd; 5529 bool isBrackets; // true if [expr], false if .ident 5530 union { 5531 IdentifierInfo *IdentInfo; 5532 Expr *E; 5533 } U; 5534 }; 5535 5536 /// __builtin_offsetof(type, a.b[123][456].c) 5537 ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 5538 TypeSourceInfo *TInfo, 5539 ArrayRef<OffsetOfComponent> Components, 5540 SourceLocation RParenLoc); 5541 ExprResult ActOnBuiltinOffsetOf(Scope *S, 5542 SourceLocation BuiltinLoc, 5543 SourceLocation TypeLoc, 5544 ParsedType ParsedArgTy, 5545 ArrayRef<OffsetOfComponent> Components, 5546 SourceLocation RParenLoc); 5547 5548 // __builtin_choose_expr(constExpr, expr1, expr2) 5549 ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, 5550 Expr *CondExpr, Expr *LHSExpr, 5551 Expr *RHSExpr, SourceLocation RPLoc); 5552 5553 // __builtin_va_arg(expr, type) 5554 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, 5555 SourceLocation RPLoc); 5556 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, 5557 TypeSourceInfo *TInfo, SourceLocation RPLoc); 5558 5559 // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(), 5560 // __builtin_COLUMN() 5561 ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind, 5562 SourceLocation BuiltinLoc, 5563 SourceLocation RPLoc); 5564 5565 // Build a potentially resolved SourceLocExpr. 5566 ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind, 5567 SourceLocation BuiltinLoc, SourceLocation RPLoc, 5568 DeclContext *ParentContext); 5569 5570 // __null 5571 ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc); 5572 5573 bool CheckCaseExpression(Expr *E); 5574 5575 /// Describes the result of an "if-exists" condition check. 5576 enum IfExistsResult { 5577 /// The symbol exists. 5578 IER_Exists, 5579 5580 /// The symbol does not exist. 5581 IER_DoesNotExist, 5582 5583 /// The name is a dependent name, so the results will differ 5584 /// from one instantiation to the next. 5585 IER_Dependent, 5586 5587 /// An error occurred. 5588 IER_Error 5589 }; 5590 5591 IfExistsResult 5592 CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, 5593 const DeclarationNameInfo &TargetNameInfo); 5594 5595 IfExistsResult 5596 CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc, 5597 bool IsIfExists, CXXScopeSpec &SS, 5598 UnqualifiedId &Name); 5599 5600 StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc, 5601 bool IsIfExists, 5602 NestedNameSpecifierLoc QualifierLoc, 5603 DeclarationNameInfo NameInfo, 5604 Stmt *Nested); 5605 StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, 5606 bool IsIfExists, 5607 CXXScopeSpec &SS, UnqualifiedId &Name, 5608 Stmt *Nested); 5609 5610 //===------------------------- "Block" Extension ------------------------===// 5611 5612 /// ActOnBlockStart - This callback is invoked when a block literal is 5613 /// started. 5614 void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope); 5615 5616 /// ActOnBlockArguments - This callback allows processing of block arguments. 5617 /// If there are no arguments, this is still invoked. 5618 void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, 5619 Scope *CurScope); 5620 5621 /// ActOnBlockError - If there is an error parsing a block, this callback 5622 /// is invoked to pop the information about the block from the action impl. 5623 void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope); 5624 5625 /// ActOnBlockStmtExpr - This is called when the body of a block statement 5626 /// literal was successfully completed. ^(int x){...} 5627 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, 5628 Scope *CurScope); 5629 5630 //===---------------------------- Clang Extensions ----------------------===// 5631 5632 /// __builtin_convertvector(...) 5633 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, 5634 SourceLocation BuiltinLoc, 5635 SourceLocation RParenLoc); 5636 5637 //===---------------------------- OpenCL Features -----------------------===// 5638 5639 /// __builtin_astype(...) 5640 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 5641 SourceLocation BuiltinLoc, 5642 SourceLocation RParenLoc); 5643 ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy, 5644 SourceLocation BuiltinLoc, 5645 SourceLocation RParenLoc); 5646 5647 //===---------------------------- C++ Features --------------------------===// 5648 5649 // Act on C++ namespaces 5650 Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc, 5651 SourceLocation NamespaceLoc, 5652 SourceLocation IdentLoc, IdentifierInfo *Ident, 5653 SourceLocation LBrace, 5654 const ParsedAttributesView &AttrList, 5655 UsingDirectiveDecl *&UsingDecl); 5656 void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace); 5657 5658 NamespaceDecl *getStdNamespace() const; 5659 NamespaceDecl *getOrCreateStdNamespace(); 5660 5661 NamespaceDecl *lookupStdExperimentalNamespace(); 5662 5663 CXXRecordDecl *getStdBadAlloc() const; 5664 EnumDecl *getStdAlignValT() const; 5665 5666 private: 5667 // A cache representing if we've fully checked the various comparison category 5668 // types stored in ASTContext. The bit-index corresponds to the integer value 5669 // of a ComparisonCategoryType enumerator. 5670 llvm::SmallBitVector FullyCheckedComparisonCategories; 5671 5672 ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl, 5673 CXXScopeSpec &SS, 5674 ParsedType TemplateTypeTy, 5675 IdentifierInfo *MemberOrBase); 5676 5677 public: 5678 enum class ComparisonCategoryUsage { 5679 /// The '<=>' operator was used in an expression and a builtin operator 5680 /// was selected. 5681 OperatorInExpression, 5682 /// A defaulted 'operator<=>' needed the comparison category. This 5683 /// typically only applies to 'std::strong_ordering', due to the implicit 5684 /// fallback return value. 5685 DefaultedOperator, 5686 }; 5687 5688 /// Lookup the specified comparison category types in the standard 5689 /// library, an check the VarDecls possibly returned by the operator<=> 5690 /// builtins for that type. 5691 /// 5692 /// \return The type of the comparison category type corresponding to the 5693 /// specified Kind, or a null type if an error occurs 5694 QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, 5695 SourceLocation Loc, 5696 ComparisonCategoryUsage Usage); 5697 5698 /// Tests whether Ty is an instance of std::initializer_list and, if 5699 /// it is and Element is not NULL, assigns the element type to Element. 5700 bool isStdInitializerList(QualType Ty, QualType *Element); 5701 5702 /// Looks for the std::initializer_list template and instantiates it 5703 /// with Element, or emits an error if it's not found. 5704 /// 5705 /// \returns The instantiated template, or null on error. 5706 QualType BuildStdInitializerList(QualType Element, SourceLocation Loc); 5707 5708 /// Determine whether Ctor is an initializer-list constructor, as 5709 /// defined in [dcl.init.list]p2. 5710 bool isInitListConstructor(const FunctionDecl *Ctor); 5711 5712 Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc, 5713 SourceLocation NamespcLoc, CXXScopeSpec &SS, 5714 SourceLocation IdentLoc, 5715 IdentifierInfo *NamespcName, 5716 const ParsedAttributesView &AttrList); 5717 5718 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir); 5719 5720 Decl *ActOnNamespaceAliasDef(Scope *CurScope, 5721 SourceLocation NamespaceLoc, 5722 SourceLocation AliasLoc, 5723 IdentifierInfo *Alias, 5724 CXXScopeSpec &SS, 5725 SourceLocation IdentLoc, 5726 IdentifierInfo *Ident); 5727 5728 void FilterUsingLookup(Scope *S, LookupResult &lookup); 5729 void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow); 5730 bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target, 5731 const LookupResult &PreviousDecls, 5732 UsingShadowDecl *&PrevShadow); 5733 UsingShadowDecl *BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD, 5734 NamedDecl *Target, 5735 UsingShadowDecl *PrevDecl); 5736 5737 bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, 5738 bool HasTypenameKeyword, 5739 const CXXScopeSpec &SS, 5740 SourceLocation NameLoc, 5741 const LookupResult &Previous); 5742 bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, 5743 const CXXScopeSpec &SS, 5744 const DeclarationNameInfo &NameInfo, 5745 SourceLocation NameLoc, 5746 const LookupResult *R = nullptr, 5747 const UsingDecl *UD = nullptr); 5748 5749 NamedDecl *BuildUsingDeclaration( 5750 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, 5751 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, 5752 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, 5753 const ParsedAttributesView &AttrList, bool IsInstantiation, 5754 bool IsUsingIfExists); 5755 NamedDecl *BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS, 5756 SourceLocation UsingLoc, 5757 SourceLocation EnumLoc, 5758 SourceLocation NameLoc, EnumDecl *ED); 5759 NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom, 5760 ArrayRef<NamedDecl *> Expansions); 5761 5762 bool CheckInheritingConstructorUsingDecl(UsingDecl *UD); 5763 5764 /// Given a derived-class using shadow declaration for a constructor and the 5765 /// correspnding base class constructor, find or create the implicit 5766 /// synthesized derived class constructor to use for this initialization. 5767 CXXConstructorDecl * 5768 findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor, 5769 ConstructorUsingShadowDecl *DerivedShadow); 5770 5771 Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS, 5772 SourceLocation UsingLoc, 5773 SourceLocation TypenameLoc, CXXScopeSpec &SS, 5774 UnqualifiedId &Name, SourceLocation EllipsisLoc, 5775 const ParsedAttributesView &AttrList); 5776 Decl *ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS, 5777 SourceLocation UsingLoc, 5778 SourceLocation EnumLoc, const DeclSpec &); 5779 Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS, 5780 MultiTemplateParamsArg TemplateParams, 5781 SourceLocation UsingLoc, UnqualifiedId &Name, 5782 const ParsedAttributesView &AttrList, 5783 TypeResult Type, Decl *DeclFromDeclSpec); 5784 5785 /// BuildCXXConstructExpr - Creates a complete call to a constructor, 5786 /// including handling of its default argument expressions. 5787 /// 5788 /// \param ConstructKind - a CXXConstructExpr::ConstructionKind 5789 ExprResult 5790 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 5791 NamedDecl *FoundDecl, 5792 CXXConstructorDecl *Constructor, MultiExprArg Exprs, 5793 bool HadMultipleCandidates, bool IsListInitialization, 5794 bool IsStdInitListInitialization, 5795 bool RequiresZeroInit, unsigned ConstructKind, 5796 SourceRange ParenRange); 5797 5798 /// Build a CXXConstructExpr whose constructor has already been resolved if 5799 /// it denotes an inherited constructor. 5800 ExprResult 5801 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 5802 CXXConstructorDecl *Constructor, bool Elidable, 5803 MultiExprArg Exprs, 5804 bool HadMultipleCandidates, bool IsListInitialization, 5805 bool IsStdInitListInitialization, 5806 bool RequiresZeroInit, unsigned ConstructKind, 5807 SourceRange ParenRange); 5808 5809 // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if 5810 // the constructor can be elidable? 5811 ExprResult 5812 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, 5813 NamedDecl *FoundDecl, 5814 CXXConstructorDecl *Constructor, bool Elidable, 5815 MultiExprArg Exprs, bool HadMultipleCandidates, 5816 bool IsListInitialization, 5817 bool IsStdInitListInitialization, bool RequiresZeroInit, 5818 unsigned ConstructKind, SourceRange ParenRange); 5819 5820 ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field); 5821 5822 5823 /// Instantiate or parse a C++ default argument expression as necessary. 5824 /// Return true on error. 5825 bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, 5826 ParmVarDecl *Param); 5827 5828 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating 5829 /// the default expr if needed. 5830 ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, 5831 FunctionDecl *FD, 5832 ParmVarDecl *Param); 5833 5834 /// FinalizeVarWithDestructor - Prepare for calling destructor on the 5835 /// constructed variable. 5836 void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType); 5837 5838 /// Helper class that collects exception specifications for 5839 /// implicitly-declared special member functions. 5840 class ImplicitExceptionSpecification { 5841 // Pointer to allow copying 5842 Sema *Self; 5843 // We order exception specifications thus: 5844 // noexcept is the most restrictive, but is only used in C++11. 5845 // throw() comes next. 5846 // Then a throw(collected exceptions) 5847 // Finally no specification, which is expressed as noexcept(false). 5848 // throw(...) is used instead if any called function uses it. 5849 ExceptionSpecificationType ComputedEST; 5850 llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen; 5851 SmallVector<QualType, 4> Exceptions; 5852 5853 void ClearExceptions() { 5854 ExceptionsSeen.clear(); 5855 Exceptions.clear(); 5856 } 5857 5858 public: 5859 explicit ImplicitExceptionSpecification(Sema &Self) 5860 : Self(&Self), ComputedEST(EST_BasicNoexcept) { 5861 if (!Self.getLangOpts().CPlusPlus11) 5862 ComputedEST = EST_DynamicNone; 5863 } 5864 5865 /// Get the computed exception specification type. 5866 ExceptionSpecificationType getExceptionSpecType() const { 5867 assert(!isComputedNoexcept(ComputedEST) && 5868 "noexcept(expr) should not be a possible result"); 5869 return ComputedEST; 5870 } 5871 5872 /// The number of exceptions in the exception specification. 5873 unsigned size() const { return Exceptions.size(); } 5874 5875 /// The set of exceptions in the exception specification. 5876 const QualType *data() const { return Exceptions.data(); } 5877 5878 /// Integrate another called method into the collected data. 5879 void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method); 5880 5881 /// Integrate an invoked expression into the collected data. 5882 void CalledExpr(Expr *E) { CalledStmt(E); } 5883 5884 /// Integrate an invoked statement into the collected data. 5885 void CalledStmt(Stmt *S); 5886 5887 /// Overwrite an EPI's exception specification with this 5888 /// computed exception specification. 5889 FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const { 5890 FunctionProtoType::ExceptionSpecInfo ESI; 5891 ESI.Type = getExceptionSpecType(); 5892 if (ESI.Type == EST_Dynamic) { 5893 ESI.Exceptions = Exceptions; 5894 } else if (ESI.Type == EST_None) { 5895 /// C++11 [except.spec]p14: 5896 /// The exception-specification is noexcept(false) if the set of 5897 /// potential exceptions of the special member function contains "any" 5898 ESI.Type = EST_NoexceptFalse; 5899 ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(), 5900 tok::kw_false).get(); 5901 } 5902 return ESI; 5903 } 5904 }; 5905 5906 /// Evaluate the implicit exception specification for a defaulted 5907 /// special member function. 5908 void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD); 5909 5910 /// Check the given noexcept-specifier, convert its expression, and compute 5911 /// the appropriate ExceptionSpecificationType. 5912 ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr, 5913 ExceptionSpecificationType &EST); 5914 5915 /// Check the given exception-specification and update the 5916 /// exception specification information with the results. 5917 void checkExceptionSpecification(bool IsTopLevel, 5918 ExceptionSpecificationType EST, 5919 ArrayRef<ParsedType> DynamicExceptions, 5920 ArrayRef<SourceRange> DynamicExceptionRanges, 5921 Expr *NoexceptExpr, 5922 SmallVectorImpl<QualType> &Exceptions, 5923 FunctionProtoType::ExceptionSpecInfo &ESI); 5924 5925 /// Determine if we're in a case where we need to (incorrectly) eagerly 5926 /// parse an exception specification to work around a libstdc++ bug. 5927 bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D); 5928 5929 /// Add an exception-specification to the given member function 5930 /// (or member function template). The exception-specification was parsed 5931 /// after the method itself was declared. 5932 void actOnDelayedExceptionSpecification(Decl *Method, 5933 ExceptionSpecificationType EST, 5934 SourceRange SpecificationRange, 5935 ArrayRef<ParsedType> DynamicExceptions, 5936 ArrayRef<SourceRange> DynamicExceptionRanges, 5937 Expr *NoexceptExpr); 5938 5939 class InheritedConstructorInfo; 5940 5941 /// Determine if a special member function should have a deleted 5942 /// definition when it is defaulted. 5943 bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, 5944 InheritedConstructorInfo *ICI = nullptr, 5945 bool Diagnose = false); 5946 5947 /// Produce notes explaining why a defaulted function was defined as deleted. 5948 void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD); 5949 5950 /// Declare the implicit default constructor for the given class. 5951 /// 5952 /// \param ClassDecl The class declaration into which the implicit 5953 /// default constructor will be added. 5954 /// 5955 /// \returns The implicitly-declared default constructor. 5956 CXXConstructorDecl *DeclareImplicitDefaultConstructor( 5957 CXXRecordDecl *ClassDecl); 5958 5959 /// DefineImplicitDefaultConstructor - Checks for feasibility of 5960 /// defining this constructor as the default constructor. 5961 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation, 5962 CXXConstructorDecl *Constructor); 5963 5964 /// Declare the implicit destructor for the given class. 5965 /// 5966 /// \param ClassDecl The class declaration into which the implicit 5967 /// destructor will be added. 5968 /// 5969 /// \returns The implicitly-declared destructor. 5970 CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl); 5971 5972 /// DefineImplicitDestructor - Checks for feasibility of 5973 /// defining this destructor as the default destructor. 5974 void DefineImplicitDestructor(SourceLocation CurrentLocation, 5975 CXXDestructorDecl *Destructor); 5976 5977 /// Build an exception spec for destructors that don't have one. 5978 /// 5979 /// C++11 says that user-defined destructors with no exception spec get one 5980 /// that looks as if the destructor was implicitly declared. 5981 void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor); 5982 5983 /// Define the specified inheriting constructor. 5984 void DefineInheritingConstructor(SourceLocation UseLoc, 5985 CXXConstructorDecl *Constructor); 5986 5987 /// Declare the implicit copy constructor for the given class. 5988 /// 5989 /// \param ClassDecl The class declaration into which the implicit 5990 /// copy constructor will be added. 5991 /// 5992 /// \returns The implicitly-declared copy constructor. 5993 CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl); 5994 5995 /// DefineImplicitCopyConstructor - Checks for feasibility of 5996 /// defining this constructor as the copy constructor. 5997 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation, 5998 CXXConstructorDecl *Constructor); 5999 6000 /// Declare the implicit move constructor for the given class. 6001 /// 6002 /// \param ClassDecl The Class declaration into which the implicit 6003 /// move constructor will be added. 6004 /// 6005 /// \returns The implicitly-declared move constructor, or NULL if it wasn't 6006 /// declared. 6007 CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl); 6008 6009 /// DefineImplicitMoveConstructor - Checks for feasibility of 6010 /// defining this constructor as the move constructor. 6011 void DefineImplicitMoveConstructor(SourceLocation CurrentLocation, 6012 CXXConstructorDecl *Constructor); 6013 6014 /// Declare the implicit copy assignment operator for the given class. 6015 /// 6016 /// \param ClassDecl The class declaration into which the implicit 6017 /// copy assignment operator will be added. 6018 /// 6019 /// \returns The implicitly-declared copy assignment operator. 6020 CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl); 6021 6022 /// Defines an implicitly-declared copy assignment operator. 6023 void DefineImplicitCopyAssignment(SourceLocation CurrentLocation, 6024 CXXMethodDecl *MethodDecl); 6025 6026 /// Declare the implicit move assignment operator for the given class. 6027 /// 6028 /// \param ClassDecl The Class declaration into which the implicit 6029 /// move assignment operator will be added. 6030 /// 6031 /// \returns The implicitly-declared move assignment operator, or NULL if it 6032 /// wasn't declared. 6033 CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl); 6034 6035 /// Defines an implicitly-declared move assignment operator. 6036 void DefineImplicitMoveAssignment(SourceLocation CurrentLocation, 6037 CXXMethodDecl *MethodDecl); 6038 6039 /// Force the declaration of any implicitly-declared members of this 6040 /// class. 6041 void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class); 6042 6043 /// Check a completed declaration of an implicit special member. 6044 void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD); 6045 6046 /// Determine whether the given function is an implicitly-deleted 6047 /// special member function. 6048 bool isImplicitlyDeleted(FunctionDecl *FD); 6049 6050 /// Check whether 'this' shows up in the type of a static member 6051 /// function after the (naturally empty) cv-qualifier-seq would be. 6052 /// 6053 /// \returns true if an error occurred. 6054 bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method); 6055 6056 /// Whether this' shows up in the exception specification of a static 6057 /// member function. 6058 bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method); 6059 6060 /// Check whether 'this' shows up in the attributes of the given 6061 /// static member function. 6062 /// 6063 /// \returns true if an error occurred. 6064 bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method); 6065 6066 /// MaybeBindToTemporary - If the passed in expression has a record type with 6067 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise 6068 /// it simply returns the passed in expression. 6069 ExprResult MaybeBindToTemporary(Expr *E); 6070 6071 /// Wrap the expression in a ConstantExpr if it is a potential immediate 6072 /// invocation. 6073 ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl); 6074 6075 bool CompleteConstructorCall(CXXConstructorDecl *Constructor, 6076 QualType DeclInitType, MultiExprArg ArgsPtr, 6077 SourceLocation Loc, 6078 SmallVectorImpl<Expr *> &ConvertedArgs, 6079 bool AllowExplicit = false, 6080 bool IsListInitialization = false); 6081 6082 ParsedType getInheritingConstructorName(CXXScopeSpec &SS, 6083 SourceLocation NameLoc, 6084 IdentifierInfo &Name); 6085 6086 ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc, 6087 Scope *S, CXXScopeSpec &SS, 6088 bool EnteringContext); 6089 ParsedType getDestructorName(SourceLocation TildeLoc, 6090 IdentifierInfo &II, SourceLocation NameLoc, 6091 Scope *S, CXXScopeSpec &SS, 6092 ParsedType ObjectType, 6093 bool EnteringContext); 6094 6095 ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, 6096 ParsedType ObjectType); 6097 6098 // Checks that reinterpret casts don't have undefined behavior. 6099 void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, 6100 bool IsDereference, SourceRange Range); 6101 6102 // Checks that the vector type should be initialized from a scalar 6103 // by splatting the value rather than populating a single element. 6104 // This is the case for AltiVecVector types as well as with 6105 // AltiVecPixel and AltiVecBool when -faltivec-src-compat=xl is specified. 6106 bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy); 6107 6108 /// ActOnCXXNamedCast - Parse 6109 /// {dynamic,static,reinterpret,const,addrspace}_cast's. 6110 ExprResult ActOnCXXNamedCast(SourceLocation OpLoc, 6111 tok::TokenKind Kind, 6112 SourceLocation LAngleBracketLoc, 6113 Declarator &D, 6114 SourceLocation RAngleBracketLoc, 6115 SourceLocation LParenLoc, 6116 Expr *E, 6117 SourceLocation RParenLoc); 6118 6119 ExprResult BuildCXXNamedCast(SourceLocation OpLoc, 6120 tok::TokenKind Kind, 6121 TypeSourceInfo *Ty, 6122 Expr *E, 6123 SourceRange AngleBrackets, 6124 SourceRange Parens); 6125 6126 ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl, 6127 ExprResult Operand, 6128 SourceLocation RParenLoc); 6129 6130 ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI, 6131 Expr *Operand, SourceLocation RParenLoc); 6132 6133 ExprResult BuildCXXTypeId(QualType TypeInfoType, 6134 SourceLocation TypeidLoc, 6135 TypeSourceInfo *Operand, 6136 SourceLocation RParenLoc); 6137 ExprResult BuildCXXTypeId(QualType TypeInfoType, 6138 SourceLocation TypeidLoc, 6139 Expr *Operand, 6140 SourceLocation RParenLoc); 6141 6142 /// ActOnCXXTypeid - Parse typeid( something ). 6143 ExprResult ActOnCXXTypeid(SourceLocation OpLoc, 6144 SourceLocation LParenLoc, bool isType, 6145 void *TyOrExpr, 6146 SourceLocation RParenLoc); 6147 6148 ExprResult BuildCXXUuidof(QualType TypeInfoType, 6149 SourceLocation TypeidLoc, 6150 TypeSourceInfo *Operand, 6151 SourceLocation RParenLoc); 6152 ExprResult BuildCXXUuidof(QualType TypeInfoType, 6153 SourceLocation TypeidLoc, 6154 Expr *Operand, 6155 SourceLocation RParenLoc); 6156 6157 /// ActOnCXXUuidof - Parse __uuidof( something ). 6158 ExprResult ActOnCXXUuidof(SourceLocation OpLoc, 6159 SourceLocation LParenLoc, bool isType, 6160 void *TyOrExpr, 6161 SourceLocation RParenLoc); 6162 6163 /// Handle a C++1z fold-expression: ( expr op ... op expr ). 6164 ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS, 6165 tok::TokenKind Operator, 6166 SourceLocation EllipsisLoc, Expr *RHS, 6167 SourceLocation RParenLoc); 6168 ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, 6169 SourceLocation LParenLoc, Expr *LHS, 6170 BinaryOperatorKind Operator, 6171 SourceLocation EllipsisLoc, Expr *RHS, 6172 SourceLocation RParenLoc, 6173 Optional<unsigned> NumExpansions); 6174 ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, 6175 BinaryOperatorKind Operator); 6176 6177 //// ActOnCXXThis - Parse 'this' pointer. 6178 ExprResult ActOnCXXThis(SourceLocation loc); 6179 6180 /// Build a CXXThisExpr and mark it referenced in the current context. 6181 Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit); 6182 void MarkThisReferenced(CXXThisExpr *This); 6183 6184 /// Try to retrieve the type of the 'this' pointer. 6185 /// 6186 /// \returns The type of 'this', if possible. Otherwise, returns a NULL type. 6187 QualType getCurrentThisType(); 6188 6189 /// When non-NULL, the C++ 'this' expression is allowed despite the 6190 /// current context not being a non-static member function. In such cases, 6191 /// this provides the type used for 'this'. 6192 QualType CXXThisTypeOverride; 6193 6194 /// RAII object used to temporarily allow the C++ 'this' expression 6195 /// to be used, with the given qualifiers on the current class type. 6196 class CXXThisScopeRAII { 6197 Sema &S; 6198 QualType OldCXXThisTypeOverride; 6199 bool Enabled; 6200 6201 public: 6202 /// Introduce a new scope where 'this' may be allowed (when enabled), 6203 /// using the given declaration (which is either a class template or a 6204 /// class) along with the given qualifiers. 6205 /// along with the qualifiers placed on '*this'. 6206 CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals, 6207 bool Enabled = true); 6208 6209 ~CXXThisScopeRAII(); 6210 }; 6211 6212 /// Make sure the value of 'this' is actually available in the current 6213 /// context, if it is a potentially evaluated context. 6214 /// 6215 /// \param Loc The location at which the capture of 'this' occurs. 6216 /// 6217 /// \param Explicit Whether 'this' is explicitly captured in a lambda 6218 /// capture list. 6219 /// 6220 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index 6221 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture. 6222 /// This is useful when enclosing lambdas must speculatively capture 6223 /// 'this' that may or may not be used in certain specializations of 6224 /// a nested generic lambda (depending on whether the name resolves to 6225 /// a non-static member function or a static function). 6226 /// \return returns 'true' if failed, 'false' if success. 6227 bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false, 6228 bool BuildAndDiagnose = true, 6229 const unsigned *const FunctionScopeIndexToStopAt = nullptr, 6230 bool ByCopy = false); 6231 6232 /// Determine whether the given type is the type of *this that is used 6233 /// outside of the body of a member function for a type that is currently 6234 /// being defined. 6235 bool isThisOutsideMemberFunctionBody(QualType BaseType); 6236 6237 /// ActOnCXXBoolLiteral - Parse {true,false} literals. 6238 ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind); 6239 6240 6241 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals. 6242 ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind); 6243 6244 ExprResult 6245 ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs, 6246 SourceLocation AtLoc, SourceLocation RParen); 6247 6248 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'. 6249 ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc); 6250 6251 //// ActOnCXXThrow - Parse throw expressions. 6252 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr); 6253 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, 6254 bool IsThrownVarInScope); 6255 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E); 6256 6257 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type. 6258 /// Can be interpreted either as function-style casting ("int(x)") 6259 /// or class type construction ("ClassType(x,y,z)") 6260 /// or creation of a value-initialized type ("int()"). 6261 ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, 6262 SourceLocation LParenOrBraceLoc, 6263 MultiExprArg Exprs, 6264 SourceLocation RParenOrBraceLoc, 6265 bool ListInitialization); 6266 6267 ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, 6268 SourceLocation LParenLoc, 6269 MultiExprArg Exprs, 6270 SourceLocation RParenLoc, 6271 bool ListInitialization); 6272 6273 /// ActOnCXXNew - Parsed a C++ 'new' expression. 6274 ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 6275 SourceLocation PlacementLParen, 6276 MultiExprArg PlacementArgs, 6277 SourceLocation PlacementRParen, 6278 SourceRange TypeIdParens, Declarator &D, 6279 Expr *Initializer); 6280 ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, 6281 SourceLocation PlacementLParen, 6282 MultiExprArg PlacementArgs, 6283 SourceLocation PlacementRParen, 6284 SourceRange TypeIdParens, 6285 QualType AllocType, 6286 TypeSourceInfo *AllocTypeInfo, 6287 Optional<Expr *> ArraySize, 6288 SourceRange DirectInitRange, 6289 Expr *Initializer); 6290 6291 /// Determine whether \p FD is an aligned allocation or deallocation 6292 /// function that is unavailable. 6293 bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const; 6294 6295 /// Produce diagnostics if \p FD is an aligned allocation or deallocation 6296 /// function that is unavailable. 6297 void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, 6298 SourceLocation Loc); 6299 6300 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc, 6301 SourceRange R); 6302 6303 /// The scope in which to find allocation functions. 6304 enum AllocationFunctionScope { 6305 /// Only look for allocation functions in the global scope. 6306 AFS_Global, 6307 /// Only look for allocation functions in the scope of the 6308 /// allocated class. 6309 AFS_Class, 6310 /// Look for allocation functions in both the global scope 6311 /// and in the scope of the allocated class. 6312 AFS_Both 6313 }; 6314 6315 /// Finds the overloads of operator new and delete that are appropriate 6316 /// for the allocation. 6317 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, 6318 AllocationFunctionScope NewScope, 6319 AllocationFunctionScope DeleteScope, 6320 QualType AllocType, bool IsArray, 6321 bool &PassAlignment, MultiExprArg PlaceArgs, 6322 FunctionDecl *&OperatorNew, 6323 FunctionDecl *&OperatorDelete, 6324 bool Diagnose = true); 6325 void DeclareGlobalNewDelete(); 6326 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return, 6327 ArrayRef<QualType> Params); 6328 6329 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 6330 DeclarationName Name, FunctionDecl* &Operator, 6331 bool Diagnose = true); 6332 FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc, 6333 bool CanProvideSize, 6334 bool Overaligned, 6335 DeclarationName Name); 6336 FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc, 6337 CXXRecordDecl *RD); 6338 6339 /// ActOnCXXDelete - Parsed a C++ 'delete' expression 6340 ExprResult ActOnCXXDelete(SourceLocation StartLoc, 6341 bool UseGlobal, bool ArrayForm, 6342 Expr *Operand); 6343 void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, 6344 bool IsDelete, bool CallCanBeVirtual, 6345 bool WarnOnNonAbstractTypes, 6346 SourceLocation DtorLoc); 6347 6348 ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, 6349 Expr *Operand, SourceLocation RParen); 6350 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, 6351 SourceLocation RParen); 6352 6353 /// Parsed one of the type trait support pseudo-functions. 6354 ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, 6355 ArrayRef<ParsedType> Args, 6356 SourceLocation RParenLoc); 6357 ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, 6358 ArrayRef<TypeSourceInfo *> Args, 6359 SourceLocation RParenLoc); 6360 6361 /// ActOnArrayTypeTrait - Parsed one of the binary type trait support 6362 /// pseudo-functions. 6363 ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, 6364 SourceLocation KWLoc, 6365 ParsedType LhsTy, 6366 Expr *DimExpr, 6367 SourceLocation RParen); 6368 6369 ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, 6370 SourceLocation KWLoc, 6371 TypeSourceInfo *TSInfo, 6372 Expr *DimExpr, 6373 SourceLocation RParen); 6374 6375 /// ActOnExpressionTrait - Parsed one of the unary type trait support 6376 /// pseudo-functions. 6377 ExprResult ActOnExpressionTrait(ExpressionTrait OET, 6378 SourceLocation KWLoc, 6379 Expr *Queried, 6380 SourceLocation RParen); 6381 6382 ExprResult BuildExpressionTrait(ExpressionTrait OET, 6383 SourceLocation KWLoc, 6384 Expr *Queried, 6385 SourceLocation RParen); 6386 6387 ExprResult ActOnStartCXXMemberReference(Scope *S, 6388 Expr *Base, 6389 SourceLocation OpLoc, 6390 tok::TokenKind OpKind, 6391 ParsedType &ObjectType, 6392 bool &MayBePseudoDestructor); 6393 6394 ExprResult BuildPseudoDestructorExpr(Expr *Base, 6395 SourceLocation OpLoc, 6396 tok::TokenKind OpKind, 6397 const CXXScopeSpec &SS, 6398 TypeSourceInfo *ScopeType, 6399 SourceLocation CCLoc, 6400 SourceLocation TildeLoc, 6401 PseudoDestructorTypeStorage DestroyedType); 6402 6403 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 6404 SourceLocation OpLoc, 6405 tok::TokenKind OpKind, 6406 CXXScopeSpec &SS, 6407 UnqualifiedId &FirstTypeName, 6408 SourceLocation CCLoc, 6409 SourceLocation TildeLoc, 6410 UnqualifiedId &SecondTypeName); 6411 6412 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 6413 SourceLocation OpLoc, 6414 tok::TokenKind OpKind, 6415 SourceLocation TildeLoc, 6416 const DeclSpec& DS); 6417 6418 /// MaybeCreateExprWithCleanups - If the current full-expression 6419 /// requires any cleanups, surround it with a ExprWithCleanups node. 6420 /// Otherwise, just returns the passed-in expression. 6421 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr); 6422 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt); 6423 ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr); 6424 6425 MaterializeTemporaryExpr * 6426 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, 6427 bool BoundToLvalueReference); 6428 6429 ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) { 6430 return ActOnFinishFullExpr( 6431 Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue); 6432 } 6433 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC, 6434 bool DiscardedValue, bool IsConstexpr = false); 6435 StmtResult ActOnFinishFullStmt(Stmt *Stmt); 6436 6437 // Marks SS invalid if it represents an incomplete type. 6438 bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC); 6439 // Complete an enum decl, maybe without a scope spec. 6440 bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L, 6441 CXXScopeSpec *SS = nullptr); 6442 6443 DeclContext *computeDeclContext(QualType T); 6444 DeclContext *computeDeclContext(const CXXScopeSpec &SS, 6445 bool EnteringContext = false); 6446 bool isDependentScopeSpecifier(const CXXScopeSpec &SS); 6447 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS); 6448 6449 /// The parser has parsed a global nested-name-specifier '::'. 6450 /// 6451 /// \param CCLoc The location of the '::'. 6452 /// 6453 /// \param SS The nested-name-specifier, which will be updated in-place 6454 /// to reflect the parsed nested-name-specifier. 6455 /// 6456 /// \returns true if an error occurred, false otherwise. 6457 bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS); 6458 6459 /// The parser has parsed a '__super' nested-name-specifier. 6460 /// 6461 /// \param SuperLoc The location of the '__super' keyword. 6462 /// 6463 /// \param ColonColonLoc The location of the '::'. 6464 /// 6465 /// \param SS The nested-name-specifier, which will be updated in-place 6466 /// to reflect the parsed nested-name-specifier. 6467 /// 6468 /// \returns true if an error occurred, false otherwise. 6469 bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, 6470 SourceLocation ColonColonLoc, CXXScopeSpec &SS); 6471 6472 bool isAcceptableNestedNameSpecifier(const NamedDecl *SD, 6473 bool *CanCorrect = nullptr); 6474 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS); 6475 6476 /// Keeps information about an identifier in a nested-name-spec. 6477 /// 6478 struct NestedNameSpecInfo { 6479 /// The type of the object, if we're parsing nested-name-specifier in 6480 /// a member access expression. 6481 ParsedType ObjectType; 6482 6483 /// The identifier preceding the '::'. 6484 IdentifierInfo *Identifier; 6485 6486 /// The location of the identifier. 6487 SourceLocation IdentifierLoc; 6488 6489 /// The location of the '::'. 6490 SourceLocation CCLoc; 6491 6492 /// Creates info object for the most typical case. 6493 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc, 6494 SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType()) 6495 : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc), 6496 CCLoc(ColonColonLoc) { 6497 } 6498 6499 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc, 6500 SourceLocation ColonColonLoc, QualType ObjectType) 6501 : ObjectType(ParsedType::make(ObjectType)), Identifier(II), 6502 IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) { 6503 } 6504 }; 6505 6506 bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, 6507 NestedNameSpecInfo &IdInfo); 6508 6509 bool BuildCXXNestedNameSpecifier(Scope *S, 6510 NestedNameSpecInfo &IdInfo, 6511 bool EnteringContext, 6512 CXXScopeSpec &SS, 6513 NamedDecl *ScopeLookupResult, 6514 bool ErrorRecoveryLookup, 6515 bool *IsCorrectedToColon = nullptr, 6516 bool OnlyNamespace = false); 6517 6518 /// The parser has parsed a nested-name-specifier 'identifier::'. 6519 /// 6520 /// \param S The scope in which this nested-name-specifier occurs. 6521 /// 6522 /// \param IdInfo Parser information about an identifier in the 6523 /// nested-name-spec. 6524 /// 6525 /// \param EnteringContext Whether we're entering the context nominated by 6526 /// this nested-name-specifier. 6527 /// 6528 /// \param SS The nested-name-specifier, which is both an input 6529 /// parameter (the nested-name-specifier before this type) and an 6530 /// output parameter (containing the full nested-name-specifier, 6531 /// including this new type). 6532 /// 6533 /// \param ErrorRecoveryLookup If true, then this method is called to improve 6534 /// error recovery. In this case do not emit error message. 6535 /// 6536 /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':' 6537 /// are allowed. The bool value pointed by this parameter is set to 'true' 6538 /// if the identifier is treated as if it was followed by ':', not '::'. 6539 /// 6540 /// \param OnlyNamespace If true, only considers namespaces in lookup. 6541 /// 6542 /// \returns true if an error occurred, false otherwise. 6543 bool ActOnCXXNestedNameSpecifier(Scope *S, 6544 NestedNameSpecInfo &IdInfo, 6545 bool EnteringContext, 6546 CXXScopeSpec &SS, 6547 bool ErrorRecoveryLookup = false, 6548 bool *IsCorrectedToColon = nullptr, 6549 bool OnlyNamespace = false); 6550 6551 ExprResult ActOnDecltypeExpression(Expr *E); 6552 6553 bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, 6554 const DeclSpec &DS, 6555 SourceLocation ColonColonLoc); 6556 6557 bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, 6558 NestedNameSpecInfo &IdInfo, 6559 bool EnteringContext); 6560 6561 /// The parser has parsed a nested-name-specifier 6562 /// 'template[opt] template-name < template-args >::'. 6563 /// 6564 /// \param S The scope in which this nested-name-specifier occurs. 6565 /// 6566 /// \param SS The nested-name-specifier, which is both an input 6567 /// parameter (the nested-name-specifier before this type) and an 6568 /// output parameter (containing the full nested-name-specifier, 6569 /// including this new type). 6570 /// 6571 /// \param TemplateKWLoc the location of the 'template' keyword, if any. 6572 /// \param TemplateName the template name. 6573 /// \param TemplateNameLoc The location of the template name. 6574 /// \param LAngleLoc The location of the opening angle bracket ('<'). 6575 /// \param TemplateArgs The template arguments. 6576 /// \param RAngleLoc The location of the closing angle bracket ('>'). 6577 /// \param CCLoc The location of the '::'. 6578 /// 6579 /// \param EnteringContext Whether we're entering the context of the 6580 /// nested-name-specifier. 6581 /// 6582 /// 6583 /// \returns true if an error occurred, false otherwise. 6584 bool ActOnCXXNestedNameSpecifier(Scope *S, 6585 CXXScopeSpec &SS, 6586 SourceLocation TemplateKWLoc, 6587 TemplateTy TemplateName, 6588 SourceLocation TemplateNameLoc, 6589 SourceLocation LAngleLoc, 6590 ASTTemplateArgsPtr TemplateArgs, 6591 SourceLocation RAngleLoc, 6592 SourceLocation CCLoc, 6593 bool EnteringContext); 6594 6595 /// Given a C++ nested-name-specifier, produce an annotation value 6596 /// that the parser can use later to reconstruct the given 6597 /// nested-name-specifier. 6598 /// 6599 /// \param SS A nested-name-specifier. 6600 /// 6601 /// \returns A pointer containing all of the information in the 6602 /// nested-name-specifier \p SS. 6603 void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS); 6604 6605 /// Given an annotation pointer for a nested-name-specifier, restore 6606 /// the nested-name-specifier structure. 6607 /// 6608 /// \param Annotation The annotation pointer, produced by 6609 /// \c SaveNestedNameSpecifierAnnotation(). 6610 /// 6611 /// \param AnnotationRange The source range corresponding to the annotation. 6612 /// 6613 /// \param SS The nested-name-specifier that will be updated with the contents 6614 /// of the annotation pointer. 6615 void RestoreNestedNameSpecifierAnnotation(void *Annotation, 6616 SourceRange AnnotationRange, 6617 CXXScopeSpec &SS); 6618 6619 bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS); 6620 6621 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global 6622 /// scope or nested-name-specifier) is parsed, part of a declarator-id. 6623 /// After this method is called, according to [C++ 3.4.3p3], names should be 6624 /// looked up in the declarator-id's scope, until the declarator is parsed and 6625 /// ActOnCXXExitDeclaratorScope is called. 6626 /// The 'SS' should be a non-empty valid CXXScopeSpec. 6627 bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS); 6628 6629 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously 6630 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same 6631 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well. 6632 /// Used to indicate that names should revert to being looked up in the 6633 /// defining scope. 6634 void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS); 6635 6636 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an 6637 /// initializer for the declaration 'Dcl'. 6638 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a 6639 /// static data member of class X, names should be looked up in the scope of 6640 /// class X. 6641 void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl); 6642 6643 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an 6644 /// initializer for the declaration 'Dcl'. 6645 void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl); 6646 6647 /// Create a new lambda closure type. 6648 CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange, 6649 TypeSourceInfo *Info, 6650 bool KnownDependent, 6651 LambdaCaptureDefault CaptureDefault); 6652 6653 /// Start the definition of a lambda expression. 6654 CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class, 6655 SourceRange IntroducerRange, 6656 TypeSourceInfo *MethodType, 6657 SourceLocation EndLoc, 6658 ArrayRef<ParmVarDecl *> Params, 6659 ConstexprSpecKind ConstexprKind, 6660 Expr *TrailingRequiresClause); 6661 6662 /// Number lambda for linkage purposes if necessary. 6663 void handleLambdaNumbering( 6664 CXXRecordDecl *Class, CXXMethodDecl *Method, 6665 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None); 6666 6667 /// Endow the lambda scope info with the relevant properties. 6668 void buildLambdaScope(sema::LambdaScopeInfo *LSI, 6669 CXXMethodDecl *CallOperator, 6670 SourceRange IntroducerRange, 6671 LambdaCaptureDefault CaptureDefault, 6672 SourceLocation CaptureDefaultLoc, 6673 bool ExplicitParams, 6674 bool ExplicitResultType, 6675 bool Mutable); 6676 6677 /// Perform initialization analysis of the init-capture and perform 6678 /// any implicit conversions such as an lvalue-to-rvalue conversion if 6679 /// not being used to initialize a reference. 6680 ParsedType actOnLambdaInitCaptureInitialization( 6681 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, 6682 IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) { 6683 return ParsedType::make(buildLambdaInitCaptureInitialization( 6684 Loc, ByRef, EllipsisLoc, None, Id, 6685 InitKind != LambdaCaptureInitKind::CopyInit, Init)); 6686 } 6687 QualType buildLambdaInitCaptureInitialization( 6688 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, 6689 Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit, 6690 Expr *&Init); 6691 6692 /// Create a dummy variable within the declcontext of the lambda's 6693 /// call operator, for name lookup purposes for a lambda init capture. 6694 /// 6695 /// CodeGen handles emission of lambda captures, ignoring these dummy 6696 /// variables appropriately. 6697 VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc, 6698 QualType InitCaptureType, 6699 SourceLocation EllipsisLoc, 6700 IdentifierInfo *Id, 6701 unsigned InitStyle, Expr *Init); 6702 6703 /// Add an init-capture to a lambda scope. 6704 void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var); 6705 6706 /// Note that we have finished the explicit captures for the 6707 /// given lambda. 6708 void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI); 6709 6710 /// \brief This is called after parsing the explicit template parameter list 6711 /// on a lambda (if it exists) in C++2a. 6712 void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc, 6713 ArrayRef<NamedDecl *> TParams, 6714 SourceLocation RAngleLoc, 6715 ExprResult RequiresClause); 6716 6717 /// Introduce the lambda parameters into scope. 6718 void addLambdaParameters( 6719 ArrayRef<LambdaIntroducer::LambdaCapture> Captures, 6720 CXXMethodDecl *CallOperator, Scope *CurScope); 6721 6722 /// Deduce a block or lambda's return type based on the return 6723 /// statements present in the body. 6724 void deduceClosureReturnType(sema::CapturingScopeInfo &CSI); 6725 6726 /// ActOnStartOfLambdaDefinition - This is called just before we start 6727 /// parsing the body of a lambda; it analyzes the explicit captures and 6728 /// arguments, and sets up various data-structures for the body of the 6729 /// lambda. 6730 void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, 6731 Declarator &ParamInfo, Scope *CurScope); 6732 6733 /// ActOnLambdaError - If there is an error parsing a lambda, this callback 6734 /// is invoked to pop the information about the lambda. 6735 void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, 6736 bool IsInstantiation = false); 6737 6738 /// ActOnLambdaExpr - This is called when the body of a lambda expression 6739 /// was successfully completed. 6740 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, 6741 Scope *CurScope); 6742 6743 /// Does copying/destroying the captured variable have side effects? 6744 bool CaptureHasSideEffects(const sema::Capture &From); 6745 6746 /// Diagnose if an explicit lambda capture is unused. Returns true if a 6747 /// diagnostic is emitted. 6748 bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange, 6749 const sema::Capture &From); 6750 6751 /// Build a FieldDecl suitable to hold the given capture. 6752 FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture); 6753 6754 /// Initialize the given capture with a suitable expression. 6755 ExprResult BuildCaptureInit(const sema::Capture &Capture, 6756 SourceLocation ImplicitCaptureLoc, 6757 bool IsOpenMPMapping = false); 6758 6759 /// Complete a lambda-expression having processed and attached the 6760 /// lambda body. 6761 ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc, 6762 sema::LambdaScopeInfo *LSI); 6763 6764 /// Get the return type to use for a lambda's conversion function(s) to 6765 /// function pointer type, given the type of the call operator. 6766 QualType 6767 getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType, 6768 CallingConv CC); 6769 6770 /// Define the "body" of the conversion from a lambda object to a 6771 /// function pointer. 6772 /// 6773 /// This routine doesn't actually define a sensible body; rather, it fills 6774 /// in the initialization expression needed to copy the lambda object into 6775 /// the block, and IR generation actually generates the real body of the 6776 /// block pointer conversion. 6777 void DefineImplicitLambdaToFunctionPointerConversion( 6778 SourceLocation CurrentLoc, CXXConversionDecl *Conv); 6779 6780 /// Define the "body" of the conversion from a lambda object to a 6781 /// block pointer. 6782 /// 6783 /// This routine doesn't actually define a sensible body; rather, it fills 6784 /// in the initialization expression needed to copy the lambda object into 6785 /// the block, and IR generation actually generates the real body of the 6786 /// block pointer conversion. 6787 void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc, 6788 CXXConversionDecl *Conv); 6789 6790 ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation, 6791 SourceLocation ConvLocation, 6792 CXXConversionDecl *Conv, 6793 Expr *Src); 6794 6795 /// Check whether the given expression is a valid constraint expression. 6796 /// A diagnostic is emitted if it is not, false is returned, and 6797 /// PossibleNonPrimary will be set to true if the failure might be due to a 6798 /// non-primary expression being used as an atomic constraint. 6799 bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(), 6800 bool *PossibleNonPrimary = nullptr, 6801 bool IsTrailingRequiresClause = false); 6802 6803 private: 6804 /// Caches pairs of template-like decls whose associated constraints were 6805 /// checked for subsumption and whether or not the first's constraints did in 6806 /// fact subsume the second's. 6807 llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache; 6808 /// Caches the normalized associated constraints of declarations (concepts or 6809 /// constrained declarations). If an error occurred while normalizing the 6810 /// associated constraints of the template or concept, nullptr will be cached 6811 /// here. 6812 llvm::DenseMap<NamedDecl *, NormalizedConstraint *> 6813 NormalizationCache; 6814 6815 llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &> 6816 SatisfactionCache; 6817 6818 public: 6819 const NormalizedConstraint * 6820 getNormalizedAssociatedConstraints( 6821 NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints); 6822 6823 /// \brief Check whether the given declaration's associated constraints are 6824 /// at least as constrained than another declaration's according to the 6825 /// partial ordering of constraints. 6826 /// 6827 /// \param Result If no error occurred, receives the result of true if D1 is 6828 /// at least constrained than D2, and false otherwise. 6829 /// 6830 /// \returns true if an error occurred, false otherwise. 6831 bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1, 6832 NamedDecl *D2, ArrayRef<const Expr *> AC2, 6833 bool &Result); 6834 6835 /// If D1 was not at least as constrained as D2, but would've been if a pair 6836 /// of atomic constraints involved had been declared in a concept and not 6837 /// repeated in two separate places in code. 6838 /// \returns true if such a diagnostic was emitted, false otherwise. 6839 bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, 6840 ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2); 6841 6842 /// \brief Check whether the given list of constraint expressions are 6843 /// satisfied (as if in a 'conjunction') given template arguments. 6844 /// \param Template the template-like entity that triggered the constraints 6845 /// check (either a concept or a constrained entity). 6846 /// \param ConstraintExprs a list of constraint expressions, treated as if 6847 /// they were 'AND'ed together. 6848 /// \param TemplateArgs the list of template arguments to substitute into the 6849 /// constraint expression. 6850 /// \param TemplateIDRange The source range of the template id that 6851 /// caused the constraints check. 6852 /// \param Satisfaction if true is returned, will contain details of the 6853 /// satisfaction, with enough information to diagnose an unsatisfied 6854 /// expression. 6855 /// \returns true if an error occurred and satisfaction could not be checked, 6856 /// false otherwise. 6857 bool CheckConstraintSatisfaction( 6858 const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs, 6859 ArrayRef<TemplateArgument> TemplateArgs, 6860 SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction); 6861 6862 /// \brief Check whether the given non-dependent constraint expression is 6863 /// satisfied. Returns false and updates Satisfaction with the satisfaction 6864 /// verdict if successful, emits a diagnostic and returns true if an error 6865 /// occured and satisfaction could not be determined. 6866 /// 6867 /// \returns true if an error occurred, false otherwise. 6868 bool CheckConstraintSatisfaction(const Expr *ConstraintExpr, 6869 ConstraintSatisfaction &Satisfaction); 6870 6871 /// Check whether the given function decl's trailing requires clause is 6872 /// satisfied, if any. Returns false and updates Satisfaction with the 6873 /// satisfaction verdict if successful, emits a diagnostic and returns true if 6874 /// an error occured and satisfaction could not be determined. 6875 /// 6876 /// \returns true if an error occurred, false otherwise. 6877 bool CheckFunctionConstraints(const FunctionDecl *FD, 6878 ConstraintSatisfaction &Satisfaction, 6879 SourceLocation UsageLoc = SourceLocation()); 6880 6881 6882 /// \brief Ensure that the given template arguments satisfy the constraints 6883 /// associated with the given template, emitting a diagnostic if they do not. 6884 /// 6885 /// \param Template The template to which the template arguments are being 6886 /// provided. 6887 /// 6888 /// \param TemplateArgs The converted, canonicalized template arguments. 6889 /// 6890 /// \param TemplateIDRange The source range of the template id that 6891 /// caused the constraints check. 6892 /// 6893 /// \returns true if the constrains are not satisfied or could not be checked 6894 /// for satisfaction, false if the constraints are satisfied. 6895 bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template, 6896 ArrayRef<TemplateArgument> TemplateArgs, 6897 SourceRange TemplateIDRange); 6898 6899 /// \brief Emit diagnostics explaining why a constraint expression was deemed 6900 /// unsatisfied. 6901 /// \param First whether this is the first time an unsatisfied constraint is 6902 /// diagnosed for this error. 6903 void 6904 DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, 6905 bool First = true); 6906 6907 /// \brief Emit diagnostics explaining why a constraint expression was deemed 6908 /// unsatisfied. 6909 void 6910 DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction, 6911 bool First = true); 6912 6913 // ParseObjCStringLiteral - Parse Objective-C string literals. 6914 ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs, 6915 ArrayRef<Expr *> Strings); 6916 6917 ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S); 6918 6919 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the 6920 /// numeric literal expression. Type of the expression will be "NSNumber *" 6921 /// or "id" if NSNumber is unavailable. 6922 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number); 6923 ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc, 6924 bool Value); 6925 ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements); 6926 6927 /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the 6928 /// '@' prefixed parenthesized expression. The type of the expression will 6929 /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type 6930 /// of ValueType, which is allowed to be a built-in numeric type, "char *", 6931 /// "const char *" or C structure with attribute 'objc_boxable'. 6932 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr); 6933 6934 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, 6935 Expr *IndexExpr, 6936 ObjCMethodDecl *getterMethod, 6937 ObjCMethodDecl *setterMethod); 6938 6939 ExprResult BuildObjCDictionaryLiteral(SourceRange SR, 6940 MutableArrayRef<ObjCDictionaryElement> Elements); 6941 6942 ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc, 6943 TypeSourceInfo *EncodedTypeInfo, 6944 SourceLocation RParenLoc); 6945 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl, 6946 CXXConversionDecl *Method, 6947 bool HadMultipleCandidates); 6948 6949 ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc, 6950 SourceLocation EncodeLoc, 6951 SourceLocation LParenLoc, 6952 ParsedType Ty, 6953 SourceLocation RParenLoc); 6954 6955 /// ParseObjCSelectorExpression - Build selector expression for \@selector 6956 ExprResult ParseObjCSelectorExpression(Selector Sel, 6957 SourceLocation AtLoc, 6958 SourceLocation SelLoc, 6959 SourceLocation LParenLoc, 6960 SourceLocation RParenLoc, 6961 bool WarnMultipleSelectors); 6962 6963 /// ParseObjCProtocolExpression - Build protocol expression for \@protocol 6964 ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName, 6965 SourceLocation AtLoc, 6966 SourceLocation ProtoLoc, 6967 SourceLocation LParenLoc, 6968 SourceLocation ProtoIdLoc, 6969 SourceLocation RParenLoc); 6970 6971 //===--------------------------------------------------------------------===// 6972 // C++ Declarations 6973 // 6974 Decl *ActOnStartLinkageSpecification(Scope *S, 6975 SourceLocation ExternLoc, 6976 Expr *LangStr, 6977 SourceLocation LBraceLoc); 6978 Decl *ActOnFinishLinkageSpecification(Scope *S, 6979 Decl *LinkageSpec, 6980 SourceLocation RBraceLoc); 6981 6982 6983 //===--------------------------------------------------------------------===// 6984 // C++ Classes 6985 // 6986 CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS); 6987 bool isCurrentClassName(const IdentifierInfo &II, Scope *S, 6988 const CXXScopeSpec *SS = nullptr); 6989 bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS); 6990 6991 bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc, 6992 SourceLocation ColonLoc, 6993 const ParsedAttributesView &Attrs); 6994 6995 NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, 6996 Declarator &D, 6997 MultiTemplateParamsArg TemplateParameterLists, 6998 Expr *BitfieldWidth, const VirtSpecifiers &VS, 6999 InClassInitStyle InitStyle); 7000 7001 void ActOnStartCXXInClassMemberInitializer(); 7002 void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl, 7003 SourceLocation EqualLoc, 7004 Expr *Init); 7005 7006 MemInitResult ActOnMemInitializer(Decl *ConstructorD, 7007 Scope *S, 7008 CXXScopeSpec &SS, 7009 IdentifierInfo *MemberOrBase, 7010 ParsedType TemplateTypeTy, 7011 const DeclSpec &DS, 7012 SourceLocation IdLoc, 7013 SourceLocation LParenLoc, 7014 ArrayRef<Expr *> Args, 7015 SourceLocation RParenLoc, 7016 SourceLocation EllipsisLoc); 7017 7018 MemInitResult ActOnMemInitializer(Decl *ConstructorD, 7019 Scope *S, 7020 CXXScopeSpec &SS, 7021 IdentifierInfo *MemberOrBase, 7022 ParsedType TemplateTypeTy, 7023 const DeclSpec &DS, 7024 SourceLocation IdLoc, 7025 Expr *InitList, 7026 SourceLocation EllipsisLoc); 7027 7028 MemInitResult BuildMemInitializer(Decl *ConstructorD, 7029 Scope *S, 7030 CXXScopeSpec &SS, 7031 IdentifierInfo *MemberOrBase, 7032 ParsedType TemplateTypeTy, 7033 const DeclSpec &DS, 7034 SourceLocation IdLoc, 7035 Expr *Init, 7036 SourceLocation EllipsisLoc); 7037 7038 MemInitResult BuildMemberInitializer(ValueDecl *Member, 7039 Expr *Init, 7040 SourceLocation IdLoc); 7041 7042 MemInitResult BuildBaseInitializer(QualType BaseType, 7043 TypeSourceInfo *BaseTInfo, 7044 Expr *Init, 7045 CXXRecordDecl *ClassDecl, 7046 SourceLocation EllipsisLoc); 7047 7048 MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, 7049 Expr *Init, 7050 CXXRecordDecl *ClassDecl); 7051 7052 bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, 7053 CXXCtorInitializer *Initializer); 7054 7055 bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, 7056 ArrayRef<CXXCtorInitializer *> Initializers = None); 7057 7058 void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation); 7059 7060 7061 /// MarkBaseAndMemberDestructorsReferenced - Given a record decl, 7062 /// mark all the non-trivial destructors of its members and bases as 7063 /// referenced. 7064 void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc, 7065 CXXRecordDecl *Record); 7066 7067 /// Mark destructors of virtual bases of this class referenced. In the Itanium 7068 /// C++ ABI, this is done when emitting a destructor for any non-abstract 7069 /// class. In the Microsoft C++ ABI, this is done any time a class's 7070 /// destructor is referenced. 7071 void MarkVirtualBaseDestructorsReferenced( 7072 SourceLocation Location, CXXRecordDecl *ClassDecl, 7073 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases = nullptr); 7074 7075 /// Do semantic checks to allow the complete destructor variant to be emitted 7076 /// when the destructor is defined in another translation unit. In the Itanium 7077 /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they 7078 /// can be emitted in separate TUs. To emit the complete variant, run a subset 7079 /// of the checks performed when emitting a regular destructor. 7080 void CheckCompleteDestructorVariant(SourceLocation CurrentLocation, 7081 CXXDestructorDecl *Dtor); 7082 7083 /// The list of classes whose vtables have been used within 7084 /// this translation unit, and the source locations at which the 7085 /// first use occurred. 7086 typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse; 7087 7088 /// The list of vtables that are required but have not yet been 7089 /// materialized. 7090 SmallVector<VTableUse, 16> VTableUses; 7091 7092 /// The set of classes whose vtables have been used within 7093 /// this translation unit, and a bit that will be true if the vtable is 7094 /// required to be emitted (otherwise, it should be emitted only if needed 7095 /// by code generation). 7096 llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed; 7097 7098 /// Load any externally-stored vtable uses. 7099 void LoadExternalVTableUses(); 7100 7101 /// Note that the vtable for the given class was used at the 7102 /// given location. 7103 void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class, 7104 bool DefinitionRequired = false); 7105 7106 /// Mark the exception specifications of all virtual member functions 7107 /// in the given class as needed. 7108 void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc, 7109 const CXXRecordDecl *RD); 7110 7111 /// MarkVirtualMembersReferenced - Will mark all members of the given 7112 /// CXXRecordDecl referenced. 7113 void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD, 7114 bool ConstexprOnly = false); 7115 7116 /// Define all of the vtables that have been used in this 7117 /// translation unit and reference any virtual members used by those 7118 /// vtables. 7119 /// 7120 /// \returns true if any work was done, false otherwise. 7121 bool DefineUsedVTables(); 7122 7123 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl); 7124 7125 void ActOnMemInitializers(Decl *ConstructorDecl, 7126 SourceLocation ColonLoc, 7127 ArrayRef<CXXCtorInitializer*> MemInits, 7128 bool AnyErrors); 7129 7130 /// Check class-level dllimport/dllexport attribute. The caller must 7131 /// ensure that referenceDLLExportedClassMethods is called some point later 7132 /// when all outer classes of Class are complete. 7133 void checkClassLevelDLLAttribute(CXXRecordDecl *Class); 7134 void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class); 7135 7136 void referenceDLLExportedClassMethods(); 7137 7138 void propagateDLLAttrToBaseClassTemplate( 7139 CXXRecordDecl *Class, Attr *ClassAttr, 7140 ClassTemplateSpecializationDecl *BaseTemplateSpec, 7141 SourceLocation BaseLoc); 7142 7143 /// Add gsl::Pointer attribute to std::container::iterator 7144 /// \param ND The declaration that introduces the name 7145 /// std::container::iterator. \param UnderlyingRecord The record named by ND. 7146 void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord); 7147 7148 /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types. 7149 void inferGslOwnerPointerAttribute(CXXRecordDecl *Record); 7150 7151 /// Add [[gsl::Pointer]] attributes for std:: types. 7152 void inferGslPointerAttribute(TypedefNameDecl *TD); 7153 7154 void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record); 7155 7156 /// Check that the C++ class annoated with "trivial_abi" satisfies all the 7157 /// conditions that are needed for the attribute to have an effect. 7158 void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD); 7159 7160 void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, 7161 Decl *TagDecl, SourceLocation LBrac, 7162 SourceLocation RBrac, 7163 const ParsedAttributesView &AttrList); 7164 void ActOnFinishCXXMemberDecls(); 7165 void ActOnFinishCXXNonNestedClass(); 7166 7167 void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param); 7168 unsigned ActOnReenterTemplateScope(Decl *Template, 7169 llvm::function_ref<Scope *()> EnterScope); 7170 void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record); 7171 void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method); 7172 void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param); 7173 void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record); 7174 void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method); 7175 void ActOnFinishDelayedMemberInitializers(Decl *Record); 7176 void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, 7177 CachedTokens &Toks); 7178 void UnmarkAsLateParsedTemplate(FunctionDecl *FD); 7179 bool IsInsideALocalClassWithinATemplateFunction(); 7180 7181 Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc, 7182 Expr *AssertExpr, 7183 Expr *AssertMessageExpr, 7184 SourceLocation RParenLoc); 7185 Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, 7186 Expr *AssertExpr, 7187 StringLiteral *AssertMessageExpr, 7188 SourceLocation RParenLoc, 7189 bool Failed); 7190 7191 FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart, 7192 SourceLocation FriendLoc, 7193 TypeSourceInfo *TSInfo); 7194 Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, 7195 MultiTemplateParamsArg TemplateParams); 7196 NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D, 7197 MultiTemplateParamsArg TemplateParams); 7198 7199 QualType CheckConstructorDeclarator(Declarator &D, QualType R, 7200 StorageClass& SC); 7201 void CheckConstructor(CXXConstructorDecl *Constructor); 7202 QualType CheckDestructorDeclarator(Declarator &D, QualType R, 7203 StorageClass& SC); 7204 bool CheckDestructor(CXXDestructorDecl *Destructor); 7205 void CheckConversionDeclarator(Declarator &D, QualType &R, 7206 StorageClass& SC); 7207 Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion); 7208 void CheckDeductionGuideDeclarator(Declarator &D, QualType &R, 7209 StorageClass &SC); 7210 void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD); 7211 7212 void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD); 7213 7214 bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, 7215 CXXSpecialMember CSM); 7216 void CheckDelayedMemberExceptionSpecs(); 7217 7218 bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD, 7219 DefaultedComparisonKind DCK); 7220 void DeclareImplicitEqualityComparison(CXXRecordDecl *RD, 7221 FunctionDecl *Spaceship); 7222 void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD, 7223 DefaultedComparisonKind DCK); 7224 7225 //===--------------------------------------------------------------------===// 7226 // C++ Derived Classes 7227 // 7228 7229 /// ActOnBaseSpecifier - Parsed a base specifier 7230 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class, 7231 SourceRange SpecifierRange, 7232 bool Virtual, AccessSpecifier Access, 7233 TypeSourceInfo *TInfo, 7234 SourceLocation EllipsisLoc); 7235 7236 BaseResult ActOnBaseSpecifier(Decl *classdecl, 7237 SourceRange SpecifierRange, 7238 ParsedAttributes &Attrs, 7239 bool Virtual, AccessSpecifier Access, 7240 ParsedType basetype, 7241 SourceLocation BaseLoc, 7242 SourceLocation EllipsisLoc); 7243 7244 bool AttachBaseSpecifiers(CXXRecordDecl *Class, 7245 MutableArrayRef<CXXBaseSpecifier *> Bases); 7246 void ActOnBaseSpecifiers(Decl *ClassDecl, 7247 MutableArrayRef<CXXBaseSpecifier *> Bases); 7248 7249 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base); 7250 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base, 7251 CXXBasePaths &Paths); 7252 7253 // FIXME: I don't like this name. 7254 void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath); 7255 7256 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, 7257 SourceLocation Loc, SourceRange Range, 7258 CXXCastPath *BasePath = nullptr, 7259 bool IgnoreAccess = false); 7260 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base, 7261 unsigned InaccessibleBaseID, 7262 unsigned AmbiguousBaseConvID, 7263 SourceLocation Loc, SourceRange Range, 7264 DeclarationName Name, 7265 CXXCastPath *BasePath, 7266 bool IgnoreAccess = false); 7267 7268 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths); 7269 7270 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, 7271 const CXXMethodDecl *Old); 7272 7273 /// CheckOverridingFunctionReturnType - Checks whether the return types are 7274 /// covariant, according to C++ [class.virtual]p5. 7275 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, 7276 const CXXMethodDecl *Old); 7277 7278 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception 7279 /// spec is a subset of base spec. 7280 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, 7281 const CXXMethodDecl *Old); 7282 7283 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange); 7284 7285 /// CheckOverrideControl - Check C++11 override control semantics. 7286 void CheckOverrideControl(NamedDecl *D); 7287 7288 /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was 7289 /// not used in the declaration of an overriding method. 7290 void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent); 7291 7292 /// CheckForFunctionMarkedFinal - Checks whether a virtual member function 7293 /// overrides a virtual member function marked 'final', according to 7294 /// C++11 [class.virtual]p4. 7295 bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New, 7296 const CXXMethodDecl *Old); 7297 7298 7299 //===--------------------------------------------------------------------===// 7300 // C++ Access Control 7301 // 7302 7303 enum AccessResult { 7304 AR_accessible, 7305 AR_inaccessible, 7306 AR_dependent, 7307 AR_delayed 7308 }; 7309 7310 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, 7311 NamedDecl *PrevMemberDecl, 7312 AccessSpecifier LexicalAS); 7313 7314 AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, 7315 DeclAccessPair FoundDecl); 7316 AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, 7317 DeclAccessPair FoundDecl); 7318 AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, 7319 SourceRange PlacementRange, 7320 CXXRecordDecl *NamingClass, 7321 DeclAccessPair FoundDecl, 7322 bool Diagnose = true); 7323 AccessResult CheckConstructorAccess(SourceLocation Loc, 7324 CXXConstructorDecl *D, 7325 DeclAccessPair FoundDecl, 7326 const InitializedEntity &Entity, 7327 bool IsCopyBindingRefToTemp = false); 7328 AccessResult CheckConstructorAccess(SourceLocation Loc, 7329 CXXConstructorDecl *D, 7330 DeclAccessPair FoundDecl, 7331 const InitializedEntity &Entity, 7332 const PartialDiagnostic &PDiag); 7333 AccessResult CheckDestructorAccess(SourceLocation Loc, 7334 CXXDestructorDecl *Dtor, 7335 const PartialDiagnostic &PDiag, 7336 QualType objectType = QualType()); 7337 AccessResult CheckFriendAccess(NamedDecl *D); 7338 AccessResult CheckMemberAccess(SourceLocation UseLoc, 7339 CXXRecordDecl *NamingClass, 7340 DeclAccessPair Found); 7341 AccessResult 7342 CheckStructuredBindingMemberAccess(SourceLocation UseLoc, 7343 CXXRecordDecl *DecomposedClass, 7344 DeclAccessPair Field); 7345 AccessResult CheckMemberOperatorAccess(SourceLocation Loc, 7346 Expr *ObjectExpr, 7347 Expr *ArgExpr, 7348 DeclAccessPair FoundDecl); 7349 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, 7350 DeclAccessPair FoundDecl); 7351 AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, 7352 QualType Base, QualType Derived, 7353 const CXXBasePath &Path, 7354 unsigned DiagID, 7355 bool ForceCheck = false, 7356 bool ForceUnprivileged = false); 7357 void CheckLookupAccess(const LookupResult &R); 7358 bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass, 7359 QualType BaseType); 7360 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, 7361 DeclAccessPair Found, QualType ObjectType, 7362 SourceLocation Loc, 7363 const PartialDiagnostic &Diag); 7364 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, 7365 DeclAccessPair Found, 7366 QualType ObjectType) { 7367 return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType, 7368 SourceLocation(), PDiag()); 7369 } 7370 7371 void HandleDependentAccessCheck(const DependentDiagnostic &DD, 7372 const MultiLevelTemplateArgumentList &TemplateArgs); 7373 void PerformDependentDiagnostics(const DeclContext *Pattern, 7374 const MultiLevelTemplateArgumentList &TemplateArgs); 7375 7376 void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx); 7377 7378 /// When true, access checking violations are treated as SFINAE 7379 /// failures rather than hard errors. 7380 bool AccessCheckingSFINAE; 7381 7382 enum AbstractDiagSelID { 7383 AbstractNone = -1, 7384 AbstractReturnType, 7385 AbstractParamType, 7386 AbstractVariableType, 7387 AbstractFieldType, 7388 AbstractIvarType, 7389 AbstractSynthesizedIvarType, 7390 AbstractArrayType 7391 }; 7392 7393 bool isAbstractType(SourceLocation Loc, QualType T); 7394 bool RequireNonAbstractType(SourceLocation Loc, QualType T, 7395 TypeDiagnoser &Diagnoser); 7396 template <typename... Ts> 7397 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID, 7398 const Ts &...Args) { 7399 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...); 7400 return RequireNonAbstractType(Loc, T, Diagnoser); 7401 } 7402 7403 void DiagnoseAbstractType(const CXXRecordDecl *RD); 7404 7405 //===--------------------------------------------------------------------===// 7406 // C++ Overloaded Operators [C++ 13.5] 7407 // 7408 7409 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl); 7410 7411 bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl); 7412 7413 //===--------------------------------------------------------------------===// 7414 // C++ Templates [C++ 14] 7415 // 7416 void FilterAcceptableTemplateNames(LookupResult &R, 7417 bool AllowFunctionTemplates = true, 7418 bool AllowDependent = true); 7419 bool hasAnyAcceptableTemplateNames(LookupResult &R, 7420 bool AllowFunctionTemplates = true, 7421 bool AllowDependent = true, 7422 bool AllowNonTemplateFunctions = false); 7423 /// Try to interpret the lookup result D as a template-name. 7424 /// 7425 /// \param D A declaration found by name lookup. 7426 /// \param AllowFunctionTemplates Whether function templates should be 7427 /// considered valid results. 7428 /// \param AllowDependent Whether unresolved using declarations (that might 7429 /// name templates) should be considered valid results. 7430 static NamedDecl *getAsTemplateNameDecl(NamedDecl *D, 7431 bool AllowFunctionTemplates = true, 7432 bool AllowDependent = true); 7433 7434 enum TemplateNameIsRequiredTag { TemplateNameIsRequired }; 7435 /// Whether and why a template name is required in this lookup. 7436 class RequiredTemplateKind { 7437 public: 7438 /// Template name is required if TemplateKWLoc is valid. 7439 RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation()) 7440 : TemplateKW(TemplateKWLoc) {} 7441 /// Template name is unconditionally required. 7442 RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {} 7443 7444 SourceLocation getTemplateKeywordLoc() const { 7445 return TemplateKW.getValueOr(SourceLocation()); 7446 } 7447 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } 7448 bool isRequired() const { return TemplateKW != SourceLocation(); } 7449 explicit operator bool() const { return isRequired(); } 7450 7451 private: 7452 llvm::Optional<SourceLocation> TemplateKW; 7453 }; 7454 7455 enum class AssumedTemplateKind { 7456 /// This is not assumed to be a template name. 7457 None, 7458 /// This is assumed to be a template name because lookup found nothing. 7459 FoundNothing, 7460 /// This is assumed to be a template name because lookup found one or more 7461 /// functions (but no function templates). 7462 FoundFunctions, 7463 }; 7464 bool LookupTemplateName( 7465 LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, 7466 bool EnteringContext, bool &MemberOfUnknownSpecialization, 7467 RequiredTemplateKind RequiredTemplate = SourceLocation(), 7468 AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true); 7469 7470 TemplateNameKind isTemplateName(Scope *S, 7471 CXXScopeSpec &SS, 7472 bool hasTemplateKeyword, 7473 const UnqualifiedId &Name, 7474 ParsedType ObjectType, 7475 bool EnteringContext, 7476 TemplateTy &Template, 7477 bool &MemberOfUnknownSpecialization, 7478 bool Disambiguation = false); 7479 7480 /// Try to resolve an undeclared template name as a type template. 7481 /// 7482 /// Sets II to the identifier corresponding to the template name, and updates 7483 /// Name to a corresponding (typo-corrected) type template name and TNK to 7484 /// the corresponding kind, if possible. 7485 void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name, 7486 TemplateNameKind &TNK, 7487 SourceLocation NameLoc, 7488 IdentifierInfo *&II); 7489 7490 bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name, 7491 SourceLocation NameLoc, 7492 bool Diagnose = true); 7493 7494 /// Determine whether a particular identifier might be the name in a C++1z 7495 /// deduction-guide declaration. 7496 bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, 7497 SourceLocation NameLoc, 7498 ParsedTemplateTy *Template = nullptr); 7499 7500 bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, 7501 SourceLocation IILoc, 7502 Scope *S, 7503 const CXXScopeSpec *SS, 7504 TemplateTy &SuggestedTemplate, 7505 TemplateNameKind &SuggestedKind); 7506 7507 bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, 7508 NamedDecl *Instantiation, 7509 bool InstantiatedFromMember, 7510 const NamedDecl *Pattern, 7511 const NamedDecl *PatternDef, 7512 TemplateSpecializationKind TSK, 7513 bool Complain = true); 7514 7515 void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl); 7516 TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl); 7517 7518 NamedDecl *ActOnTypeParameter(Scope *S, bool Typename, 7519 SourceLocation EllipsisLoc, 7520 SourceLocation KeyLoc, 7521 IdentifierInfo *ParamName, 7522 SourceLocation ParamNameLoc, 7523 unsigned Depth, unsigned Position, 7524 SourceLocation EqualLoc, 7525 ParsedType DefaultArg, bool HasTypeConstraint); 7526 7527 bool ActOnTypeConstraint(const CXXScopeSpec &SS, 7528 TemplateIdAnnotation *TypeConstraint, 7529 TemplateTypeParmDecl *ConstrainedParameter, 7530 SourceLocation EllipsisLoc); 7531 bool BuildTypeConstraint(const CXXScopeSpec &SS, 7532 TemplateIdAnnotation *TypeConstraint, 7533 TemplateTypeParmDecl *ConstrainedParameter, 7534 SourceLocation EllipsisLoc, 7535 bool AllowUnexpandedPack); 7536 7537 bool AttachTypeConstraint(NestedNameSpecifierLoc NS, 7538 DeclarationNameInfo NameInfo, 7539 ConceptDecl *NamedConcept, 7540 const TemplateArgumentListInfo *TemplateArgs, 7541 TemplateTypeParmDecl *ConstrainedParameter, 7542 SourceLocation EllipsisLoc); 7543 7544 bool AttachTypeConstraint(AutoTypeLoc TL, 7545 NonTypeTemplateParmDecl *ConstrainedParameter, 7546 SourceLocation EllipsisLoc); 7547 7548 bool RequireStructuralType(QualType T, SourceLocation Loc); 7549 7550 QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, 7551 SourceLocation Loc); 7552 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc); 7553 7554 NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, 7555 unsigned Depth, 7556 unsigned Position, 7557 SourceLocation EqualLoc, 7558 Expr *DefaultArg); 7559 NamedDecl *ActOnTemplateTemplateParameter(Scope *S, 7560 SourceLocation TmpLoc, 7561 TemplateParameterList *Params, 7562 SourceLocation EllipsisLoc, 7563 IdentifierInfo *ParamName, 7564 SourceLocation ParamNameLoc, 7565 unsigned Depth, 7566 unsigned Position, 7567 SourceLocation EqualLoc, 7568 ParsedTemplateArgument DefaultArg); 7569 7570 TemplateParameterList * 7571 ActOnTemplateParameterList(unsigned Depth, 7572 SourceLocation ExportLoc, 7573 SourceLocation TemplateLoc, 7574 SourceLocation LAngleLoc, 7575 ArrayRef<NamedDecl *> Params, 7576 SourceLocation RAngleLoc, 7577 Expr *RequiresClause); 7578 7579 /// The context in which we are checking a template parameter list. 7580 enum TemplateParamListContext { 7581 TPC_ClassTemplate, 7582 TPC_VarTemplate, 7583 TPC_FunctionTemplate, 7584 TPC_ClassTemplateMember, 7585 TPC_FriendClassTemplate, 7586 TPC_FriendFunctionTemplate, 7587 TPC_FriendFunctionTemplateDefinition, 7588 TPC_TypeAliasTemplate 7589 }; 7590 7591 bool CheckTemplateParameterList(TemplateParameterList *NewParams, 7592 TemplateParameterList *OldParams, 7593 TemplateParamListContext TPC, 7594 SkipBodyInfo *SkipBody = nullptr); 7595 TemplateParameterList *MatchTemplateParametersToScopeSpecifier( 7596 SourceLocation DeclStartLoc, SourceLocation DeclLoc, 7597 const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, 7598 ArrayRef<TemplateParameterList *> ParamLists, 7599 bool IsFriend, bool &IsMemberSpecialization, bool &Invalid, 7600 bool SuppressDiagnostic = false); 7601 7602 DeclResult CheckClassTemplate( 7603 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, 7604 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, 7605 const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, 7606 AccessSpecifier AS, SourceLocation ModulePrivateLoc, 7607 SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, 7608 TemplateParameterList **OuterTemplateParamLists, 7609 SkipBodyInfo *SkipBody = nullptr); 7610 7611 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, 7612 QualType NTTPType, 7613 SourceLocation Loc); 7614 7615 /// Get a template argument mapping the given template parameter to itself, 7616 /// e.g. for X in \c template<int X>, this would return an expression template 7617 /// argument referencing X. 7618 TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param, 7619 SourceLocation Location); 7620 7621 void translateTemplateArguments(const ASTTemplateArgsPtr &In, 7622 TemplateArgumentListInfo &Out); 7623 7624 ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType); 7625 7626 void NoteAllFoundTemplates(TemplateName Name); 7627 7628 QualType CheckTemplateIdType(TemplateName Template, 7629 SourceLocation TemplateLoc, 7630 TemplateArgumentListInfo &TemplateArgs); 7631 7632 TypeResult 7633 ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 7634 TemplateTy Template, IdentifierInfo *TemplateII, 7635 SourceLocation TemplateIILoc, SourceLocation LAngleLoc, 7636 ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, 7637 bool IsCtorOrDtorName = false, bool IsClassName = false); 7638 7639 /// Parsed an elaborated-type-specifier that refers to a template-id, 7640 /// such as \c class T::template apply<U>. 7641 TypeResult ActOnTagTemplateIdType(TagUseKind TUK, 7642 TypeSpecifierType TagSpec, 7643 SourceLocation TagLoc, 7644 CXXScopeSpec &SS, 7645 SourceLocation TemplateKWLoc, 7646 TemplateTy TemplateD, 7647 SourceLocation TemplateLoc, 7648 SourceLocation LAngleLoc, 7649 ASTTemplateArgsPtr TemplateArgsIn, 7650 SourceLocation RAngleLoc); 7651 7652 DeclResult ActOnVarTemplateSpecialization( 7653 Scope *S, Declarator &D, TypeSourceInfo *DI, 7654 SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, 7655 StorageClass SC, bool IsPartialSpecialization); 7656 7657 /// Get the specialization of the given variable template corresponding to 7658 /// the specified argument list, or a null-but-valid result if the arguments 7659 /// are dependent. 7660 DeclResult CheckVarTemplateId(VarTemplateDecl *Template, 7661 SourceLocation TemplateLoc, 7662 SourceLocation TemplateNameLoc, 7663 const TemplateArgumentListInfo &TemplateArgs); 7664 7665 /// Form a reference to the specialization of the given variable template 7666 /// corresponding to the specified argument list, or a null-but-valid result 7667 /// if the arguments are dependent. 7668 ExprResult CheckVarTemplateId(const CXXScopeSpec &SS, 7669 const DeclarationNameInfo &NameInfo, 7670 VarTemplateDecl *Template, 7671 SourceLocation TemplateLoc, 7672 const TemplateArgumentListInfo *TemplateArgs); 7673 7674 ExprResult 7675 CheckConceptTemplateId(const CXXScopeSpec &SS, 7676 SourceLocation TemplateKWLoc, 7677 const DeclarationNameInfo &ConceptNameInfo, 7678 NamedDecl *FoundDecl, ConceptDecl *NamedConcept, 7679 const TemplateArgumentListInfo *TemplateArgs); 7680 7681 void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc); 7682 7683 ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, 7684 SourceLocation TemplateKWLoc, 7685 LookupResult &R, 7686 bool RequiresADL, 7687 const TemplateArgumentListInfo *TemplateArgs); 7688 7689 ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, 7690 SourceLocation TemplateKWLoc, 7691 const DeclarationNameInfo &NameInfo, 7692 const TemplateArgumentListInfo *TemplateArgs); 7693 7694 TemplateNameKind ActOnTemplateName( 7695 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, 7696 const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, 7697 TemplateTy &Template, bool AllowInjectedClassName = false); 7698 7699 DeclResult ActOnClassTemplateSpecialization( 7700 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, 7701 SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, 7702 TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, 7703 MultiTemplateParamsArg TemplateParameterLists, 7704 SkipBodyInfo *SkipBody = nullptr); 7705 7706 bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, 7707 TemplateDecl *PrimaryTemplate, 7708 unsigned NumExplicitArgs, 7709 ArrayRef<TemplateArgument> Args); 7710 void CheckTemplatePartialSpecialization( 7711 ClassTemplatePartialSpecializationDecl *Partial); 7712 void CheckTemplatePartialSpecialization( 7713 VarTemplatePartialSpecializationDecl *Partial); 7714 7715 Decl *ActOnTemplateDeclarator(Scope *S, 7716 MultiTemplateParamsArg TemplateParameterLists, 7717 Declarator &D); 7718 7719 bool 7720 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, 7721 TemplateSpecializationKind NewTSK, 7722 NamedDecl *PrevDecl, 7723 TemplateSpecializationKind PrevTSK, 7724 SourceLocation PrevPtOfInstantiation, 7725 bool &SuppressNew); 7726 7727 bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, 7728 const TemplateArgumentListInfo &ExplicitTemplateArgs, 7729 LookupResult &Previous); 7730 7731 bool CheckFunctionTemplateSpecialization( 7732 FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, 7733 LookupResult &Previous, bool QualifiedFriend = false); 7734 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous); 7735 void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous); 7736 7737 DeclResult ActOnExplicitInstantiation( 7738 Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, 7739 unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, 7740 TemplateTy Template, SourceLocation TemplateNameLoc, 7741 SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, 7742 SourceLocation RAngleLoc, const ParsedAttributesView &Attr); 7743 7744 DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, 7745 SourceLocation TemplateLoc, 7746 unsigned TagSpec, SourceLocation KWLoc, 7747 CXXScopeSpec &SS, IdentifierInfo *Name, 7748 SourceLocation NameLoc, 7749 const ParsedAttributesView &Attr); 7750 7751 DeclResult ActOnExplicitInstantiation(Scope *S, 7752 SourceLocation ExternLoc, 7753 SourceLocation TemplateLoc, 7754 Declarator &D); 7755 7756 TemplateArgumentLoc 7757 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, 7758 SourceLocation TemplateLoc, 7759 SourceLocation RAngleLoc, 7760 Decl *Param, 7761 SmallVectorImpl<TemplateArgument> 7762 &Converted, 7763 bool &HasDefaultArg); 7764 7765 /// Specifies the context in which a particular template 7766 /// argument is being checked. 7767 enum CheckTemplateArgumentKind { 7768 /// The template argument was specified in the code or was 7769 /// instantiated with some deduced template arguments. 7770 CTAK_Specified, 7771 7772 /// The template argument was deduced via template argument 7773 /// deduction. 7774 CTAK_Deduced, 7775 7776 /// The template argument was deduced from an array bound 7777 /// via template argument deduction. 7778 CTAK_DeducedFromArrayBound 7779 }; 7780 7781 bool CheckTemplateArgument(NamedDecl *Param, 7782 TemplateArgumentLoc &Arg, 7783 NamedDecl *Template, 7784 SourceLocation TemplateLoc, 7785 SourceLocation RAngleLoc, 7786 unsigned ArgumentPackIndex, 7787 SmallVectorImpl<TemplateArgument> &Converted, 7788 CheckTemplateArgumentKind CTAK = CTAK_Specified); 7789 7790 /// Check that the given template arguments can be be provided to 7791 /// the given template, converting the arguments along the way. 7792 /// 7793 /// \param Template The template to which the template arguments are being 7794 /// provided. 7795 /// 7796 /// \param TemplateLoc The location of the template name in the source. 7797 /// 7798 /// \param TemplateArgs The list of template arguments. If the template is 7799 /// a template template parameter, this function may extend the set of 7800 /// template arguments to also include substituted, defaulted template 7801 /// arguments. 7802 /// 7803 /// \param PartialTemplateArgs True if the list of template arguments is 7804 /// intentionally partial, e.g., because we're checking just the initial 7805 /// set of template arguments. 7806 /// 7807 /// \param Converted Will receive the converted, canonicalized template 7808 /// arguments. 7809 /// 7810 /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to 7811 /// contain the converted forms of the template arguments as written. 7812 /// Otherwise, \p TemplateArgs will not be modified. 7813 /// 7814 /// \param ConstraintsNotSatisfied If provided, and an error occured, will 7815 /// receive true if the cause for the error is the associated constraints of 7816 /// the template not being satisfied by the template arguments. 7817 /// 7818 /// \returns true if an error occurred, false otherwise. 7819 bool CheckTemplateArgumentList(TemplateDecl *Template, 7820 SourceLocation TemplateLoc, 7821 TemplateArgumentListInfo &TemplateArgs, 7822 bool PartialTemplateArgs, 7823 SmallVectorImpl<TemplateArgument> &Converted, 7824 bool UpdateArgsWithConversions = true, 7825 bool *ConstraintsNotSatisfied = nullptr); 7826 7827 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, 7828 TemplateArgumentLoc &Arg, 7829 SmallVectorImpl<TemplateArgument> &Converted); 7830 7831 bool CheckTemplateArgument(TypeSourceInfo *Arg); 7832 ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param, 7833 QualType InstantiatedParamType, Expr *Arg, 7834 TemplateArgument &Converted, 7835 CheckTemplateArgumentKind CTAK = CTAK_Specified); 7836 bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, 7837 TemplateParameterList *Params, 7838 TemplateArgumentLoc &Arg); 7839 7840 ExprResult 7841 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, 7842 QualType ParamType, 7843 SourceLocation Loc); 7844 ExprResult 7845 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, 7846 SourceLocation Loc); 7847 7848 /// Enumeration describing how template parameter lists are compared 7849 /// for equality. 7850 enum TemplateParameterListEqualKind { 7851 /// We are matching the template parameter lists of two templates 7852 /// that might be redeclarations. 7853 /// 7854 /// \code 7855 /// template<typename T> struct X; 7856 /// template<typename T> struct X; 7857 /// \endcode 7858 TPL_TemplateMatch, 7859 7860 /// We are matching the template parameter lists of two template 7861 /// template parameters as part of matching the template parameter lists 7862 /// of two templates that might be redeclarations. 7863 /// 7864 /// \code 7865 /// template<template<int I> class TT> struct X; 7866 /// template<template<int Value> class Other> struct X; 7867 /// \endcode 7868 TPL_TemplateTemplateParmMatch, 7869 7870 /// We are matching the template parameter lists of a template 7871 /// template argument against the template parameter lists of a template 7872 /// template parameter. 7873 /// 7874 /// \code 7875 /// template<template<int Value> class Metafun> struct X; 7876 /// template<int Value> struct integer_c; 7877 /// X<integer_c> xic; 7878 /// \endcode 7879 TPL_TemplateTemplateArgumentMatch 7880 }; 7881 7882 bool TemplateParameterListsAreEqual(TemplateParameterList *New, 7883 TemplateParameterList *Old, 7884 bool Complain, 7885 TemplateParameterListEqualKind Kind, 7886 SourceLocation TemplateArgLoc 7887 = SourceLocation()); 7888 7889 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams); 7890 7891 /// Called when the parser has parsed a C++ typename 7892 /// specifier, e.g., "typename T::type". 7893 /// 7894 /// \param S The scope in which this typename type occurs. 7895 /// \param TypenameLoc the location of the 'typename' keyword 7896 /// \param SS the nested-name-specifier following the typename (e.g., 'T::'). 7897 /// \param II the identifier we're retrieving (e.g., 'type' in the example). 7898 /// \param IdLoc the location of the identifier. 7899 TypeResult 7900 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 7901 const CXXScopeSpec &SS, const IdentifierInfo &II, 7902 SourceLocation IdLoc); 7903 7904 /// Called when the parser has parsed a C++ typename 7905 /// specifier that ends in a template-id, e.g., 7906 /// "typename MetaFun::template apply<T1, T2>". 7907 /// 7908 /// \param S The scope in which this typename type occurs. 7909 /// \param TypenameLoc the location of the 'typename' keyword 7910 /// \param SS the nested-name-specifier following the typename (e.g., 'T::'). 7911 /// \param TemplateLoc the location of the 'template' keyword, if any. 7912 /// \param TemplateName The template name. 7913 /// \param TemplateII The identifier used to name the template. 7914 /// \param TemplateIILoc The location of the template name. 7915 /// \param LAngleLoc The location of the opening angle bracket ('<'). 7916 /// \param TemplateArgs The template arguments. 7917 /// \param RAngleLoc The location of the closing angle bracket ('>'). 7918 TypeResult 7919 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 7920 const CXXScopeSpec &SS, 7921 SourceLocation TemplateLoc, 7922 TemplateTy TemplateName, 7923 IdentifierInfo *TemplateII, 7924 SourceLocation TemplateIILoc, 7925 SourceLocation LAngleLoc, 7926 ASTTemplateArgsPtr TemplateArgs, 7927 SourceLocation RAngleLoc); 7928 7929 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, 7930 SourceLocation KeywordLoc, 7931 NestedNameSpecifierLoc QualifierLoc, 7932 const IdentifierInfo &II, 7933 SourceLocation IILoc, 7934 TypeSourceInfo **TSI, 7935 bool DeducedTSTContext); 7936 7937 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, 7938 SourceLocation KeywordLoc, 7939 NestedNameSpecifierLoc QualifierLoc, 7940 const IdentifierInfo &II, 7941 SourceLocation IILoc, 7942 bool DeducedTSTContext = true); 7943 7944 7945 TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, 7946 SourceLocation Loc, 7947 DeclarationName Name); 7948 bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS); 7949 7950 ExprResult RebuildExprInCurrentInstantiation(Expr *E); 7951 bool RebuildTemplateParamsInCurrentInstantiation( 7952 TemplateParameterList *Params); 7953 7954 std::string 7955 getTemplateArgumentBindingsText(const TemplateParameterList *Params, 7956 const TemplateArgumentList &Args); 7957 7958 std::string 7959 getTemplateArgumentBindingsText(const TemplateParameterList *Params, 7960 const TemplateArgument *Args, 7961 unsigned NumArgs); 7962 7963 //===--------------------------------------------------------------------===// 7964 // C++ Concepts 7965 //===--------------------------------------------------------------------===// 7966 Decl *ActOnConceptDefinition( 7967 Scope *S, MultiTemplateParamsArg TemplateParameterLists, 7968 IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr); 7969 7970 RequiresExprBodyDecl * 7971 ActOnStartRequiresExpr(SourceLocation RequiresKWLoc, 7972 ArrayRef<ParmVarDecl *> LocalParameters, 7973 Scope *BodyScope); 7974 void ActOnFinishRequiresExpr(); 7975 concepts::Requirement *ActOnSimpleRequirement(Expr *E); 7976 concepts::Requirement *ActOnTypeRequirement( 7977 SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc, 7978 IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId); 7979 concepts::Requirement *ActOnCompoundRequirement(Expr *E, 7980 SourceLocation NoexceptLoc); 7981 concepts::Requirement * 7982 ActOnCompoundRequirement( 7983 Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS, 7984 TemplateIdAnnotation *TypeConstraint, unsigned Depth); 7985 concepts::Requirement *ActOnNestedRequirement(Expr *Constraint); 7986 concepts::ExprRequirement * 7987 BuildExprRequirement( 7988 Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc, 7989 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement); 7990 concepts::ExprRequirement * 7991 BuildExprRequirement( 7992 concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag, 7993 bool IsSatisfied, SourceLocation NoexceptLoc, 7994 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement); 7995 concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type); 7996 concepts::TypeRequirement * 7997 BuildTypeRequirement( 7998 concepts::Requirement::SubstitutionDiagnostic *SubstDiag); 7999 concepts::NestedRequirement *BuildNestedRequirement(Expr *E); 8000 concepts::NestedRequirement * 8001 BuildNestedRequirement( 8002 concepts::Requirement::SubstitutionDiagnostic *SubstDiag); 8003 ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc, 8004 RequiresExprBodyDecl *Body, 8005 ArrayRef<ParmVarDecl *> LocalParameters, 8006 ArrayRef<concepts::Requirement *> Requirements, 8007 SourceLocation ClosingBraceLoc); 8008 8009 //===--------------------------------------------------------------------===// 8010 // C++ Variadic Templates (C++0x [temp.variadic]) 8011 //===--------------------------------------------------------------------===// 8012 8013 /// Determine whether an unexpanded parameter pack might be permitted in this 8014 /// location. Useful for error recovery. 8015 bool isUnexpandedParameterPackPermitted(); 8016 8017 /// The context in which an unexpanded parameter pack is 8018 /// being diagnosed. 8019 /// 8020 /// Note that the values of this enumeration line up with the first 8021 /// argument to the \c err_unexpanded_parameter_pack diagnostic. 8022 enum UnexpandedParameterPackContext { 8023 /// An arbitrary expression. 8024 UPPC_Expression = 0, 8025 8026 /// The base type of a class type. 8027 UPPC_BaseType, 8028 8029 /// The type of an arbitrary declaration. 8030 UPPC_DeclarationType, 8031 8032 /// The type of a data member. 8033 UPPC_DataMemberType, 8034 8035 /// The size of a bit-field. 8036 UPPC_BitFieldWidth, 8037 8038 /// The expression in a static assertion. 8039 UPPC_StaticAssertExpression, 8040 8041 /// The fixed underlying type of an enumeration. 8042 UPPC_FixedUnderlyingType, 8043 8044 /// The enumerator value. 8045 UPPC_EnumeratorValue, 8046 8047 /// A using declaration. 8048 UPPC_UsingDeclaration, 8049 8050 /// A friend declaration. 8051 UPPC_FriendDeclaration, 8052 8053 /// A declaration qualifier. 8054 UPPC_DeclarationQualifier, 8055 8056 /// An initializer. 8057 UPPC_Initializer, 8058 8059 /// A default argument. 8060 UPPC_DefaultArgument, 8061 8062 /// The type of a non-type template parameter. 8063 UPPC_NonTypeTemplateParameterType, 8064 8065 /// The type of an exception. 8066 UPPC_ExceptionType, 8067 8068 /// Partial specialization. 8069 UPPC_PartialSpecialization, 8070 8071 /// Microsoft __if_exists. 8072 UPPC_IfExists, 8073 8074 /// Microsoft __if_not_exists. 8075 UPPC_IfNotExists, 8076 8077 /// Lambda expression. 8078 UPPC_Lambda, 8079 8080 /// Block expression. 8081 UPPC_Block, 8082 8083 /// A type constraint. 8084 UPPC_TypeConstraint, 8085 8086 // A requirement in a requires-expression. 8087 UPPC_Requirement, 8088 8089 // A requires-clause. 8090 UPPC_RequiresClause, 8091 }; 8092 8093 /// Diagnose unexpanded parameter packs. 8094 /// 8095 /// \param Loc The location at which we should emit the diagnostic. 8096 /// 8097 /// \param UPPC The context in which we are diagnosing unexpanded 8098 /// parameter packs. 8099 /// 8100 /// \param Unexpanded the set of unexpanded parameter packs. 8101 /// 8102 /// \returns true if an error occurred, false otherwise. 8103 bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc, 8104 UnexpandedParameterPackContext UPPC, 8105 ArrayRef<UnexpandedParameterPack> Unexpanded); 8106 8107 /// If the given type contains an unexpanded parameter pack, 8108 /// diagnose the error. 8109 /// 8110 /// \param Loc The source location where a diagnostc should be emitted. 8111 /// 8112 /// \param T The type that is being checked for unexpanded parameter 8113 /// packs. 8114 /// 8115 /// \returns true if an error occurred, false otherwise. 8116 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, 8117 UnexpandedParameterPackContext UPPC); 8118 8119 /// If the given expression contains an unexpanded parameter 8120 /// pack, diagnose the error. 8121 /// 8122 /// \param E The expression that is being checked for unexpanded 8123 /// parameter packs. 8124 /// 8125 /// \returns true if an error occurred, false otherwise. 8126 bool DiagnoseUnexpandedParameterPack(Expr *E, 8127 UnexpandedParameterPackContext UPPC = UPPC_Expression); 8128 8129 /// If the given requirees-expression contains an unexpanded reference to one 8130 /// of its own parameter packs, diagnose the error. 8131 /// 8132 /// \param RE The requiress-expression that is being checked for unexpanded 8133 /// parameter packs. 8134 /// 8135 /// \returns true if an error occurred, false otherwise. 8136 bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE); 8137 8138 /// If the given nested-name-specifier contains an unexpanded 8139 /// parameter pack, diagnose the error. 8140 /// 8141 /// \param SS The nested-name-specifier that is being checked for 8142 /// unexpanded parameter packs. 8143 /// 8144 /// \returns true if an error occurred, false otherwise. 8145 bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS, 8146 UnexpandedParameterPackContext UPPC); 8147 8148 /// If the given name contains an unexpanded parameter pack, 8149 /// diagnose the error. 8150 /// 8151 /// \param NameInfo The name (with source location information) that 8152 /// is being checked for unexpanded parameter packs. 8153 /// 8154 /// \returns true if an error occurred, false otherwise. 8155 bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo, 8156 UnexpandedParameterPackContext UPPC); 8157 8158 /// If the given template name contains an unexpanded parameter pack, 8159 /// diagnose the error. 8160 /// 8161 /// \param Loc The location of the template name. 8162 /// 8163 /// \param Template The template name that is being checked for unexpanded 8164 /// parameter packs. 8165 /// 8166 /// \returns true if an error occurred, false otherwise. 8167 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, 8168 TemplateName Template, 8169 UnexpandedParameterPackContext UPPC); 8170 8171 /// If the given template argument contains an unexpanded parameter 8172 /// pack, diagnose the error. 8173 /// 8174 /// \param Arg The template argument that is being checked for unexpanded 8175 /// parameter packs. 8176 /// 8177 /// \returns true if an error occurred, false otherwise. 8178 bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg, 8179 UnexpandedParameterPackContext UPPC); 8180 8181 /// Collect the set of unexpanded parameter packs within the given 8182 /// template argument. 8183 /// 8184 /// \param Arg The template argument that will be traversed to find 8185 /// unexpanded parameter packs. 8186 void collectUnexpandedParameterPacks(TemplateArgument Arg, 8187 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8188 8189 /// Collect the set of unexpanded parameter packs within the given 8190 /// template argument. 8191 /// 8192 /// \param Arg The template argument that will be traversed to find 8193 /// unexpanded parameter packs. 8194 void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg, 8195 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8196 8197 /// Collect the set of unexpanded parameter packs within the given 8198 /// type. 8199 /// 8200 /// \param T The type that will be traversed to find 8201 /// unexpanded parameter packs. 8202 void collectUnexpandedParameterPacks(QualType T, 8203 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8204 8205 /// Collect the set of unexpanded parameter packs within the given 8206 /// type. 8207 /// 8208 /// \param TL The type that will be traversed to find 8209 /// unexpanded parameter packs. 8210 void collectUnexpandedParameterPacks(TypeLoc TL, 8211 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8212 8213 /// Collect the set of unexpanded parameter packs within the given 8214 /// nested-name-specifier. 8215 /// 8216 /// \param NNS The nested-name-specifier that will be traversed to find 8217 /// unexpanded parameter packs. 8218 void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS, 8219 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8220 8221 /// Collect the set of unexpanded parameter packs within the given 8222 /// name. 8223 /// 8224 /// \param NameInfo The name that will be traversed to find 8225 /// unexpanded parameter packs. 8226 void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo, 8227 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded); 8228 8229 /// Invoked when parsing a template argument followed by an 8230 /// ellipsis, which creates a pack expansion. 8231 /// 8232 /// \param Arg The template argument preceding the ellipsis, which 8233 /// may already be invalid. 8234 /// 8235 /// \param EllipsisLoc The location of the ellipsis. 8236 ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, 8237 SourceLocation EllipsisLoc); 8238 8239 /// Invoked when parsing a type followed by an ellipsis, which 8240 /// creates a pack expansion. 8241 /// 8242 /// \param Type The type preceding the ellipsis, which will become 8243 /// the pattern of the pack expansion. 8244 /// 8245 /// \param EllipsisLoc The location of the ellipsis. 8246 TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc); 8247 8248 /// Construct a pack expansion type from the pattern of the pack 8249 /// expansion. 8250 TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern, 8251 SourceLocation EllipsisLoc, 8252 Optional<unsigned> NumExpansions); 8253 8254 /// Construct a pack expansion type from the pattern of the pack 8255 /// expansion. 8256 QualType CheckPackExpansion(QualType Pattern, 8257 SourceRange PatternRange, 8258 SourceLocation EllipsisLoc, 8259 Optional<unsigned> NumExpansions); 8260 8261 /// Invoked when parsing an expression followed by an ellipsis, which 8262 /// creates a pack expansion. 8263 /// 8264 /// \param Pattern The expression preceding the ellipsis, which will become 8265 /// the pattern of the pack expansion. 8266 /// 8267 /// \param EllipsisLoc The location of the ellipsis. 8268 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc); 8269 8270 /// Invoked when parsing an expression followed by an ellipsis, which 8271 /// creates a pack expansion. 8272 /// 8273 /// \param Pattern The expression preceding the ellipsis, which will become 8274 /// the pattern of the pack expansion. 8275 /// 8276 /// \param EllipsisLoc The location of the ellipsis. 8277 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, 8278 Optional<unsigned> NumExpansions); 8279 8280 /// Determine whether we could expand a pack expansion with the 8281 /// given set of parameter packs into separate arguments by repeatedly 8282 /// transforming the pattern. 8283 /// 8284 /// \param EllipsisLoc The location of the ellipsis that identifies the 8285 /// pack expansion. 8286 /// 8287 /// \param PatternRange The source range that covers the entire pattern of 8288 /// the pack expansion. 8289 /// 8290 /// \param Unexpanded The set of unexpanded parameter packs within the 8291 /// pattern. 8292 /// 8293 /// \param ShouldExpand Will be set to \c true if the transformer should 8294 /// expand the corresponding pack expansions into separate arguments. When 8295 /// set, \c NumExpansions must also be set. 8296 /// 8297 /// \param RetainExpansion Whether the caller should add an unexpanded 8298 /// pack expansion after all of the expanded arguments. This is used 8299 /// when extending explicitly-specified template argument packs per 8300 /// C++0x [temp.arg.explicit]p9. 8301 /// 8302 /// \param NumExpansions The number of separate arguments that will be in 8303 /// the expanded form of the corresponding pack expansion. This is both an 8304 /// input and an output parameter, which can be set by the caller if the 8305 /// number of expansions is known a priori (e.g., due to a prior substitution) 8306 /// and will be set by the callee when the number of expansions is known. 8307 /// The callee must set this value when \c ShouldExpand is \c true; it may 8308 /// set this value in other cases. 8309 /// 8310 /// \returns true if an error occurred (e.g., because the parameter packs 8311 /// are to be instantiated with arguments of different lengths), false 8312 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions) 8313 /// must be set. 8314 bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, 8315 SourceRange PatternRange, 8316 ArrayRef<UnexpandedParameterPack> Unexpanded, 8317 const MultiLevelTemplateArgumentList &TemplateArgs, 8318 bool &ShouldExpand, 8319 bool &RetainExpansion, 8320 Optional<unsigned> &NumExpansions); 8321 8322 /// Determine the number of arguments in the given pack expansion 8323 /// type. 8324 /// 8325 /// This routine assumes that the number of arguments in the expansion is 8326 /// consistent across all of the unexpanded parameter packs in its pattern. 8327 /// 8328 /// Returns an empty Optional if the type can't be expanded. 8329 Optional<unsigned> getNumArgumentsInExpansion(QualType T, 8330 const MultiLevelTemplateArgumentList &TemplateArgs); 8331 8332 /// Determine whether the given declarator contains any unexpanded 8333 /// parameter packs. 8334 /// 8335 /// This routine is used by the parser to disambiguate function declarators 8336 /// with an ellipsis prior to the ')', e.g., 8337 /// 8338 /// \code 8339 /// void f(T...); 8340 /// \endcode 8341 /// 8342 /// To determine whether we have an (unnamed) function parameter pack or 8343 /// a variadic function. 8344 /// 8345 /// \returns true if the declarator contains any unexpanded parameter packs, 8346 /// false otherwise. 8347 bool containsUnexpandedParameterPacks(Declarator &D); 8348 8349 /// Returns the pattern of the pack expansion for a template argument. 8350 /// 8351 /// \param OrigLoc The template argument to expand. 8352 /// 8353 /// \param Ellipsis Will be set to the location of the ellipsis. 8354 /// 8355 /// \param NumExpansions Will be set to the number of expansions that will 8356 /// be generated from this pack expansion, if known a priori. 8357 TemplateArgumentLoc getTemplateArgumentPackExpansionPattern( 8358 TemplateArgumentLoc OrigLoc, 8359 SourceLocation &Ellipsis, 8360 Optional<unsigned> &NumExpansions) const; 8361 8362 /// Given a template argument that contains an unexpanded parameter pack, but 8363 /// which has already been substituted, attempt to determine the number of 8364 /// elements that will be produced once this argument is fully-expanded. 8365 /// 8366 /// This is intended for use when transforming 'sizeof...(Arg)' in order to 8367 /// avoid actually expanding the pack where possible. 8368 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg); 8369 8370 //===--------------------------------------------------------------------===// 8371 // C++ Template Argument Deduction (C++ [temp.deduct]) 8372 //===--------------------------------------------------------------------===// 8373 8374 /// Adjust the type \p ArgFunctionType to match the calling convention, 8375 /// noreturn, and optionally the exception specification of \p FunctionType. 8376 /// Deduction often wants to ignore these properties when matching function 8377 /// types. 8378 QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, 8379 bool AdjustExceptionSpec = false); 8380 8381 /// Describes the result of template argument deduction. 8382 /// 8383 /// The TemplateDeductionResult enumeration describes the result of 8384 /// template argument deduction, as returned from 8385 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo 8386 /// structure provides additional information about the results of 8387 /// template argument deduction, e.g., the deduced template argument 8388 /// list (if successful) or the specific template parameters or 8389 /// deduced arguments that were involved in the failure. 8390 enum TemplateDeductionResult { 8391 /// Template argument deduction was successful. 8392 TDK_Success = 0, 8393 /// The declaration was invalid; do nothing. 8394 TDK_Invalid, 8395 /// Template argument deduction exceeded the maximum template 8396 /// instantiation depth (which has already been diagnosed). 8397 TDK_InstantiationDepth, 8398 /// Template argument deduction did not deduce a value 8399 /// for every template parameter. 8400 TDK_Incomplete, 8401 /// Template argument deduction did not deduce a value for every 8402 /// expansion of an expanded template parameter pack. 8403 TDK_IncompletePack, 8404 /// Template argument deduction produced inconsistent 8405 /// deduced values for the given template parameter. 8406 TDK_Inconsistent, 8407 /// Template argument deduction failed due to inconsistent 8408 /// cv-qualifiers on a template parameter type that would 8409 /// otherwise be deduced, e.g., we tried to deduce T in "const T" 8410 /// but were given a non-const "X". 8411 TDK_Underqualified, 8412 /// Substitution of the deduced template argument values 8413 /// resulted in an error. 8414 TDK_SubstitutionFailure, 8415 /// After substituting deduced template arguments, a dependent 8416 /// parameter type did not match the corresponding argument. 8417 TDK_DeducedMismatch, 8418 /// After substituting deduced template arguments, an element of 8419 /// a dependent parameter type did not match the corresponding element 8420 /// of the corresponding argument (when deducing from an initializer list). 8421 TDK_DeducedMismatchNested, 8422 /// A non-depnedent component of the parameter did not match the 8423 /// corresponding component of the argument. 8424 TDK_NonDeducedMismatch, 8425 /// When performing template argument deduction for a function 8426 /// template, there were too many call arguments. 8427 TDK_TooManyArguments, 8428 /// When performing template argument deduction for a function 8429 /// template, there were too few call arguments. 8430 TDK_TooFewArguments, 8431 /// The explicitly-specified template arguments were not valid 8432 /// template arguments for the given template. 8433 TDK_InvalidExplicitArguments, 8434 /// Checking non-dependent argument conversions failed. 8435 TDK_NonDependentConversionFailure, 8436 /// The deduced arguments did not satisfy the constraints associated 8437 /// with the template. 8438 TDK_ConstraintsNotSatisfied, 8439 /// Deduction failed; that's all we know. 8440 TDK_MiscellaneousDeductionFailure, 8441 /// CUDA Target attributes do not match. 8442 TDK_CUDATargetMismatch 8443 }; 8444 8445 TemplateDeductionResult 8446 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, 8447 const TemplateArgumentList &TemplateArgs, 8448 sema::TemplateDeductionInfo &Info); 8449 8450 TemplateDeductionResult 8451 DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, 8452 const TemplateArgumentList &TemplateArgs, 8453 sema::TemplateDeductionInfo &Info); 8454 8455 TemplateDeductionResult SubstituteExplicitTemplateArguments( 8456 FunctionTemplateDecl *FunctionTemplate, 8457 TemplateArgumentListInfo &ExplicitTemplateArgs, 8458 SmallVectorImpl<DeducedTemplateArgument> &Deduced, 8459 SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType, 8460 sema::TemplateDeductionInfo &Info); 8461 8462 /// brief A function argument from which we performed template argument 8463 // deduction for a call. 8464 struct OriginalCallArg { 8465 OriginalCallArg(QualType OriginalParamType, bool DecomposedParam, 8466 unsigned ArgIdx, QualType OriginalArgType) 8467 : OriginalParamType(OriginalParamType), 8468 DecomposedParam(DecomposedParam), ArgIdx(ArgIdx), 8469 OriginalArgType(OriginalArgType) {} 8470 8471 QualType OriginalParamType; 8472 bool DecomposedParam; 8473 unsigned ArgIdx; 8474 QualType OriginalArgType; 8475 }; 8476 8477 TemplateDeductionResult FinishTemplateArgumentDeduction( 8478 FunctionTemplateDecl *FunctionTemplate, 8479 SmallVectorImpl<DeducedTemplateArgument> &Deduced, 8480 unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, 8481 sema::TemplateDeductionInfo &Info, 8482 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr, 8483 bool PartialOverloading = false, 8484 llvm::function_ref<bool()> CheckNonDependent = []{ return false; }); 8485 8486 TemplateDeductionResult DeduceTemplateArguments( 8487 FunctionTemplateDecl *FunctionTemplate, 8488 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, 8489 FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info, 8490 bool PartialOverloading, 8491 llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent); 8492 8493 TemplateDeductionResult 8494 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 8495 TemplateArgumentListInfo *ExplicitTemplateArgs, 8496 QualType ArgFunctionType, 8497 FunctionDecl *&Specialization, 8498 sema::TemplateDeductionInfo &Info, 8499 bool IsAddressOfFunction = false); 8500 8501 TemplateDeductionResult 8502 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 8503 QualType ToType, 8504 CXXConversionDecl *&Specialization, 8505 sema::TemplateDeductionInfo &Info); 8506 8507 TemplateDeductionResult 8508 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, 8509 TemplateArgumentListInfo *ExplicitTemplateArgs, 8510 FunctionDecl *&Specialization, 8511 sema::TemplateDeductionInfo &Info, 8512 bool IsAddressOfFunction = false); 8513 8514 /// Substitute Replacement for \p auto in \p TypeWithAuto 8515 QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement); 8516 /// Substitute Replacement for auto in TypeWithAuto 8517 TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, 8518 QualType Replacement); 8519 /// Completely replace the \c auto in \p TypeWithAuto by 8520 /// \p Replacement. This does not retain any \c auto type sugar. 8521 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement); 8522 TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, 8523 QualType Replacement); 8524 8525 /// Result type of DeduceAutoType. 8526 enum DeduceAutoResult { 8527 DAR_Succeeded, 8528 DAR_Failed, 8529 DAR_FailedAlreadyDiagnosed 8530 }; 8531 8532 DeduceAutoResult 8533 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, 8534 Optional<unsigned> DependentDeductionDepth = None, 8535 bool IgnoreConstraints = false); 8536 DeduceAutoResult 8537 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result, 8538 Optional<unsigned> DependentDeductionDepth = None, 8539 bool IgnoreConstraints = false); 8540 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init); 8541 bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, 8542 bool Diagnose = true); 8543 8544 /// Declare implicit deduction guides for a class template if we've 8545 /// not already done so. 8546 void DeclareImplicitDeductionGuides(TemplateDecl *Template, 8547 SourceLocation Loc); 8548 8549 QualType DeduceTemplateSpecializationFromInitializer( 8550 TypeSourceInfo *TInfo, const InitializedEntity &Entity, 8551 const InitializationKind &Kind, MultiExprArg Init); 8552 8553 QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, 8554 QualType Type, TypeSourceInfo *TSI, 8555 SourceRange Range, bool DirectInit, 8556 Expr *Init); 8557 8558 TypeLoc getReturnTypeLoc(FunctionDecl *FD) const; 8559 8560 bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, 8561 SourceLocation ReturnLoc, 8562 Expr *&RetExpr, AutoType *AT); 8563 8564 FunctionTemplateDecl *getMoreSpecializedTemplate( 8565 FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, 8566 TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, 8567 unsigned NumCallArguments2, bool Reversed = false); 8568 UnresolvedSetIterator 8569 getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, 8570 TemplateSpecCandidateSet &FailedCandidates, 8571 SourceLocation Loc, 8572 const PartialDiagnostic &NoneDiag, 8573 const PartialDiagnostic &AmbigDiag, 8574 const PartialDiagnostic &CandidateDiag, 8575 bool Complain = true, QualType TargetType = QualType()); 8576 8577 ClassTemplatePartialSpecializationDecl * 8578 getMoreSpecializedPartialSpecialization( 8579 ClassTemplatePartialSpecializationDecl *PS1, 8580 ClassTemplatePartialSpecializationDecl *PS2, 8581 SourceLocation Loc); 8582 8583 bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, 8584 sema::TemplateDeductionInfo &Info); 8585 8586 VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization( 8587 VarTemplatePartialSpecializationDecl *PS1, 8588 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc); 8589 8590 bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T, 8591 sema::TemplateDeductionInfo &Info); 8592 8593 bool isTemplateTemplateParameterAtLeastAsSpecializedAs( 8594 TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc); 8595 8596 void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, 8597 unsigned Depth, llvm::SmallBitVector &Used); 8598 8599 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, 8600 bool OnlyDeduced, 8601 unsigned Depth, 8602 llvm::SmallBitVector &Used); 8603 void MarkDeducedTemplateParameters( 8604 const FunctionTemplateDecl *FunctionTemplate, 8605 llvm::SmallBitVector &Deduced) { 8606 return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced); 8607 } 8608 static void MarkDeducedTemplateParameters(ASTContext &Ctx, 8609 const FunctionTemplateDecl *FunctionTemplate, 8610 llvm::SmallBitVector &Deduced); 8611 8612 //===--------------------------------------------------------------------===// 8613 // C++ Template Instantiation 8614 // 8615 8616 MultiLevelTemplateArgumentList 8617 getTemplateInstantiationArgs(NamedDecl *D, 8618 const TemplateArgumentList *Innermost = nullptr, 8619 bool RelativeToPrimary = false, 8620 const FunctionDecl *Pattern = nullptr); 8621 8622 /// A context in which code is being synthesized (where a source location 8623 /// alone is not sufficient to identify the context). This covers template 8624 /// instantiation and various forms of implicitly-generated functions. 8625 struct CodeSynthesisContext { 8626 /// The kind of template instantiation we are performing 8627 enum SynthesisKind { 8628 /// We are instantiating a template declaration. The entity is 8629 /// the declaration we're instantiating (e.g., a CXXRecordDecl). 8630 TemplateInstantiation, 8631 8632 /// We are instantiating a default argument for a template 8633 /// parameter. The Entity is the template parameter whose argument is 8634 /// being instantiated, the Template is the template, and the 8635 /// TemplateArgs/NumTemplateArguments provide the template arguments as 8636 /// specified. 8637 DefaultTemplateArgumentInstantiation, 8638 8639 /// We are instantiating a default argument for a function. 8640 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs 8641 /// provides the template arguments as specified. 8642 DefaultFunctionArgumentInstantiation, 8643 8644 /// We are substituting explicit template arguments provided for 8645 /// a function template. The entity is a FunctionTemplateDecl. 8646 ExplicitTemplateArgumentSubstitution, 8647 8648 /// We are substituting template argument determined as part of 8649 /// template argument deduction for either a class template 8650 /// partial specialization or a function template. The 8651 /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or 8652 /// a TemplateDecl. 8653 DeducedTemplateArgumentSubstitution, 8654 8655 /// We are substituting prior template arguments into a new 8656 /// template parameter. The template parameter itself is either a 8657 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl. 8658 PriorTemplateArgumentSubstitution, 8659 8660 /// We are checking the validity of a default template argument that 8661 /// has been used when naming a template-id. 8662 DefaultTemplateArgumentChecking, 8663 8664 /// We are computing the exception specification for a defaulted special 8665 /// member function. 8666 ExceptionSpecEvaluation, 8667 8668 /// We are instantiating the exception specification for a function 8669 /// template which was deferred until it was needed. 8670 ExceptionSpecInstantiation, 8671 8672 /// We are instantiating a requirement of a requires expression. 8673 RequirementInstantiation, 8674 8675 /// We are checking the satisfaction of a nested requirement of a requires 8676 /// expression. 8677 NestedRequirementConstraintsCheck, 8678 8679 /// We are declaring an implicit special member function. 8680 DeclaringSpecialMember, 8681 8682 /// We are declaring an implicit 'operator==' for a defaulted 8683 /// 'operator<=>'. 8684 DeclaringImplicitEqualityComparison, 8685 8686 /// We are defining a synthesized function (such as a defaulted special 8687 /// member). 8688 DefiningSynthesizedFunction, 8689 8690 // We are checking the constraints associated with a constrained entity or 8691 // the constraint expression of a concept. This includes the checks that 8692 // atomic constraints have the type 'bool' and that they can be constant 8693 // evaluated. 8694 ConstraintsCheck, 8695 8696 // We are substituting template arguments into a constraint expression. 8697 ConstraintSubstitution, 8698 8699 // We are normalizing a constraint expression. 8700 ConstraintNormalization, 8701 8702 // We are substituting into the parameter mapping of an atomic constraint 8703 // during normalization. 8704 ParameterMappingSubstitution, 8705 8706 /// We are rewriting a comparison operator in terms of an operator<=>. 8707 RewritingOperatorAsSpaceship, 8708 8709 /// We are initializing a structured binding. 8710 InitializingStructuredBinding, 8711 8712 /// We are marking a class as __dllexport. 8713 MarkingClassDllexported, 8714 8715 /// Added for Template instantiation observation. 8716 /// Memoization means we are _not_ instantiating a template because 8717 /// it is already instantiated (but we entered a context where we 8718 /// would have had to if it was not already instantiated). 8719 Memoization 8720 } Kind; 8721 8722 /// Was the enclosing context a non-instantiation SFINAE context? 8723 bool SavedInNonInstantiationSFINAEContext; 8724 8725 /// The point of instantiation or synthesis within the source code. 8726 SourceLocation PointOfInstantiation; 8727 8728 /// The entity that is being synthesized. 8729 Decl *Entity; 8730 8731 /// The template (or partial specialization) in which we are 8732 /// performing the instantiation, for substitutions of prior template 8733 /// arguments. 8734 NamedDecl *Template; 8735 8736 /// The list of template arguments we are substituting, if they 8737 /// are not part of the entity. 8738 const TemplateArgument *TemplateArgs; 8739 8740 // FIXME: Wrap this union around more members, or perhaps store the 8741 // kind-specific members in the RAII object owning the context. 8742 union { 8743 /// The number of template arguments in TemplateArgs. 8744 unsigned NumTemplateArgs; 8745 8746 /// The special member being declared or defined. 8747 CXXSpecialMember SpecialMember; 8748 }; 8749 8750 ArrayRef<TemplateArgument> template_arguments() const { 8751 assert(Kind != DeclaringSpecialMember); 8752 return {TemplateArgs, NumTemplateArgs}; 8753 } 8754 8755 /// The template deduction info object associated with the 8756 /// substitution or checking of explicit or deduced template arguments. 8757 sema::TemplateDeductionInfo *DeductionInfo; 8758 8759 /// The source range that covers the construct that cause 8760 /// the instantiation, e.g., the template-id that causes a class 8761 /// template instantiation. 8762 SourceRange InstantiationRange; 8763 8764 CodeSynthesisContext() 8765 : Kind(TemplateInstantiation), 8766 SavedInNonInstantiationSFINAEContext(false), Entity(nullptr), 8767 Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0), 8768 DeductionInfo(nullptr) {} 8769 8770 /// Determines whether this template is an actual instantiation 8771 /// that should be counted toward the maximum instantiation depth. 8772 bool isInstantiationRecord() const; 8773 }; 8774 8775 /// List of active code synthesis contexts. 8776 /// 8777 /// This vector is treated as a stack. As synthesis of one entity requires 8778 /// synthesis of another, additional contexts are pushed onto the stack. 8779 SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts; 8780 8781 /// Specializations whose definitions are currently being instantiated. 8782 llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations; 8783 8784 /// Non-dependent types used in templates that have already been instantiated 8785 /// by some template instantiation. 8786 llvm::DenseSet<QualType> InstantiatedNonDependentTypes; 8787 8788 /// Extra modules inspected when performing a lookup during a template 8789 /// instantiation. Computed lazily. 8790 SmallVector<Module*, 16> CodeSynthesisContextLookupModules; 8791 8792 /// Cache of additional modules that should be used for name lookup 8793 /// within the current template instantiation. Computed lazily; use 8794 /// getLookupModules() to get a complete set. 8795 llvm::DenseSet<Module*> LookupModulesCache; 8796 8797 /// Get the set of additional modules that should be checked during 8798 /// name lookup. A module and its imports become visible when instanting a 8799 /// template defined within it. 8800 llvm::DenseSet<Module*> &getLookupModules(); 8801 8802 /// Map from the most recent declaration of a namespace to the most 8803 /// recent visible declaration of that namespace. 8804 llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache; 8805 8806 /// Whether we are in a SFINAE context that is not associated with 8807 /// template instantiation. 8808 /// 8809 /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside 8810 /// of a template instantiation or template argument deduction. 8811 bool InNonInstantiationSFINAEContext; 8812 8813 /// The number of \p CodeSynthesisContexts that are not template 8814 /// instantiations and, therefore, should not be counted as part of the 8815 /// instantiation depth. 8816 /// 8817 /// When the instantiation depth reaches the user-configurable limit 8818 /// \p LangOptions::InstantiationDepth we will abort instantiation. 8819 // FIXME: Should we have a similar limit for other forms of synthesis? 8820 unsigned NonInstantiationEntries; 8821 8822 /// The depth of the context stack at the point when the most recent 8823 /// error or warning was produced. 8824 /// 8825 /// This value is used to suppress printing of redundant context stacks 8826 /// when there are multiple errors or warnings in the same instantiation. 8827 // FIXME: Does this belong in Sema? It's tough to implement it anywhere else. 8828 unsigned LastEmittedCodeSynthesisContextDepth = 0; 8829 8830 /// The template instantiation callbacks to trace or track 8831 /// instantiations (objects can be chained). 8832 /// 8833 /// This callbacks is used to print, trace or track template 8834 /// instantiations as they are being constructed. 8835 std::vector<std::unique_ptr<TemplateInstantiationCallback>> 8836 TemplateInstCallbacks; 8837 8838 /// The current index into pack expansion arguments that will be 8839 /// used for substitution of parameter packs. 8840 /// 8841 /// The pack expansion index will be -1 to indicate that parameter packs 8842 /// should be instantiated as themselves. Otherwise, the index specifies 8843 /// which argument within the parameter pack will be used for substitution. 8844 int ArgumentPackSubstitutionIndex; 8845 8846 /// RAII object used to change the argument pack substitution index 8847 /// within a \c Sema object. 8848 /// 8849 /// See \c ArgumentPackSubstitutionIndex for more information. 8850 class ArgumentPackSubstitutionIndexRAII { 8851 Sema &Self; 8852 int OldSubstitutionIndex; 8853 8854 public: 8855 ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex) 8856 : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) { 8857 Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex; 8858 } 8859 8860 ~ArgumentPackSubstitutionIndexRAII() { 8861 Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex; 8862 } 8863 }; 8864 8865 friend class ArgumentPackSubstitutionRAII; 8866 8867 /// For each declaration that involved template argument deduction, the 8868 /// set of diagnostics that were suppressed during that template argument 8869 /// deduction. 8870 /// 8871 /// FIXME: Serialize this structure to the AST file. 8872 typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> > 8873 SuppressedDiagnosticsMap; 8874 SuppressedDiagnosticsMap SuppressedDiagnostics; 8875 8876 /// A stack object to be created when performing template 8877 /// instantiation. 8878 /// 8879 /// Construction of an object of type \c InstantiatingTemplate 8880 /// pushes the current instantiation onto the stack of active 8881 /// instantiations. If the size of this stack exceeds the maximum 8882 /// number of recursive template instantiations, construction 8883 /// produces an error and evaluates true. 8884 /// 8885 /// Destruction of this object will pop the named instantiation off 8886 /// the stack. 8887 struct InstantiatingTemplate { 8888 /// Note that we are instantiating a class template, 8889 /// function template, variable template, alias template, 8890 /// or a member thereof. 8891 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8892 Decl *Entity, 8893 SourceRange InstantiationRange = SourceRange()); 8894 8895 struct ExceptionSpecification {}; 8896 /// Note that we are instantiating an exception specification 8897 /// of a function template. 8898 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8899 FunctionDecl *Entity, ExceptionSpecification, 8900 SourceRange InstantiationRange = SourceRange()); 8901 8902 /// Note that we are instantiating a default argument in a 8903 /// template-id. 8904 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8905 TemplateParameter Param, TemplateDecl *Template, 8906 ArrayRef<TemplateArgument> TemplateArgs, 8907 SourceRange InstantiationRange = SourceRange()); 8908 8909 /// Note that we are substituting either explicitly-specified or 8910 /// deduced template arguments during function template argument deduction. 8911 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8912 FunctionTemplateDecl *FunctionTemplate, 8913 ArrayRef<TemplateArgument> TemplateArgs, 8914 CodeSynthesisContext::SynthesisKind Kind, 8915 sema::TemplateDeductionInfo &DeductionInfo, 8916 SourceRange InstantiationRange = SourceRange()); 8917 8918 /// Note that we are instantiating as part of template 8919 /// argument deduction for a class template declaration. 8920 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8921 TemplateDecl *Template, 8922 ArrayRef<TemplateArgument> TemplateArgs, 8923 sema::TemplateDeductionInfo &DeductionInfo, 8924 SourceRange InstantiationRange = SourceRange()); 8925 8926 /// Note that we are instantiating as part of template 8927 /// argument deduction for a class template partial 8928 /// specialization. 8929 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8930 ClassTemplatePartialSpecializationDecl *PartialSpec, 8931 ArrayRef<TemplateArgument> TemplateArgs, 8932 sema::TemplateDeductionInfo &DeductionInfo, 8933 SourceRange InstantiationRange = SourceRange()); 8934 8935 /// Note that we are instantiating as part of template 8936 /// argument deduction for a variable template partial 8937 /// specialization. 8938 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8939 VarTemplatePartialSpecializationDecl *PartialSpec, 8940 ArrayRef<TemplateArgument> TemplateArgs, 8941 sema::TemplateDeductionInfo &DeductionInfo, 8942 SourceRange InstantiationRange = SourceRange()); 8943 8944 /// Note that we are instantiating a default argument for a function 8945 /// parameter. 8946 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8947 ParmVarDecl *Param, 8948 ArrayRef<TemplateArgument> TemplateArgs, 8949 SourceRange InstantiationRange = SourceRange()); 8950 8951 /// Note that we are substituting prior template arguments into a 8952 /// non-type parameter. 8953 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8954 NamedDecl *Template, 8955 NonTypeTemplateParmDecl *Param, 8956 ArrayRef<TemplateArgument> TemplateArgs, 8957 SourceRange InstantiationRange); 8958 8959 /// Note that we are substituting prior template arguments into a 8960 /// template template parameter. 8961 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8962 NamedDecl *Template, 8963 TemplateTemplateParmDecl *Param, 8964 ArrayRef<TemplateArgument> TemplateArgs, 8965 SourceRange InstantiationRange); 8966 8967 /// Note that we are checking the default template argument 8968 /// against the template parameter for a given template-id. 8969 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8970 TemplateDecl *Template, 8971 NamedDecl *Param, 8972 ArrayRef<TemplateArgument> TemplateArgs, 8973 SourceRange InstantiationRange); 8974 8975 struct ConstraintsCheck {}; 8976 /// \brief Note that we are checking the constraints associated with some 8977 /// constrained entity (a concept declaration or a template with associated 8978 /// constraints). 8979 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8980 ConstraintsCheck, NamedDecl *Template, 8981 ArrayRef<TemplateArgument> TemplateArgs, 8982 SourceRange InstantiationRange); 8983 8984 struct ConstraintSubstitution {}; 8985 /// \brief Note that we are checking a constraint expression associated 8986 /// with a template declaration or as part of the satisfaction check of a 8987 /// concept. 8988 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8989 ConstraintSubstitution, NamedDecl *Template, 8990 sema::TemplateDeductionInfo &DeductionInfo, 8991 SourceRange InstantiationRange); 8992 8993 struct ConstraintNormalization {}; 8994 /// \brief Note that we are normalizing a constraint expression. 8995 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 8996 ConstraintNormalization, NamedDecl *Template, 8997 SourceRange InstantiationRange); 8998 8999 struct ParameterMappingSubstitution {}; 9000 /// \brief Note that we are subtituting into the parameter mapping of an 9001 /// atomic constraint during constraint normalization. 9002 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 9003 ParameterMappingSubstitution, NamedDecl *Template, 9004 SourceRange InstantiationRange); 9005 9006 /// \brief Note that we are substituting template arguments into a part of 9007 /// a requirement of a requires expression. 9008 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 9009 concepts::Requirement *Req, 9010 sema::TemplateDeductionInfo &DeductionInfo, 9011 SourceRange InstantiationRange = SourceRange()); 9012 9013 /// \brief Note that we are checking the satisfaction of the constraint 9014 /// expression inside of a nested requirement. 9015 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, 9016 concepts::NestedRequirement *Req, ConstraintsCheck, 9017 SourceRange InstantiationRange = SourceRange()); 9018 9019 /// Note that we have finished instantiating this template. 9020 void Clear(); 9021 9022 ~InstantiatingTemplate() { Clear(); } 9023 9024 /// Determines whether we have exceeded the maximum 9025 /// recursive template instantiations. 9026 bool isInvalid() const { return Invalid; } 9027 9028 /// Determine whether we are already instantiating this 9029 /// specialization in some surrounding active instantiation. 9030 bool isAlreadyInstantiating() const { return AlreadyInstantiating; } 9031 9032 private: 9033 Sema &SemaRef; 9034 bool Invalid; 9035 bool AlreadyInstantiating; 9036 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation, 9037 SourceRange InstantiationRange); 9038 9039 InstantiatingTemplate( 9040 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind, 9041 SourceLocation PointOfInstantiation, SourceRange InstantiationRange, 9042 Decl *Entity, NamedDecl *Template = nullptr, 9043 ArrayRef<TemplateArgument> TemplateArgs = None, 9044 sema::TemplateDeductionInfo *DeductionInfo = nullptr); 9045 9046 InstantiatingTemplate(const InstantiatingTemplate&) = delete; 9047 9048 InstantiatingTemplate& 9049 operator=(const InstantiatingTemplate&) = delete; 9050 }; 9051 9052 void pushCodeSynthesisContext(CodeSynthesisContext Ctx); 9053 void popCodeSynthesisContext(); 9054 9055 /// Determine whether we are currently performing template instantiation. 9056 bool inTemplateInstantiation() const { 9057 return CodeSynthesisContexts.size() > NonInstantiationEntries; 9058 } 9059 9060 void PrintContextStack() { 9061 if (!CodeSynthesisContexts.empty() && 9062 CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) { 9063 PrintInstantiationStack(); 9064 LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size(); 9065 } 9066 if (PragmaAttributeCurrentTargetDecl) 9067 PrintPragmaAttributeInstantiationPoint(); 9068 } 9069 void PrintInstantiationStack(); 9070 9071 void PrintPragmaAttributeInstantiationPoint(); 9072 9073 /// Determines whether we are currently in a context where 9074 /// template argument substitution failures are not considered 9075 /// errors. 9076 /// 9077 /// \returns An empty \c Optional if we're not in a SFINAE context. 9078 /// Otherwise, contains a pointer that, if non-NULL, contains the nearest 9079 /// template-deduction context object, which can be used to capture 9080 /// diagnostics that will be suppressed. 9081 Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const; 9082 9083 /// Determines whether we are currently in a context that 9084 /// is not evaluated as per C++ [expr] p5. 9085 bool isUnevaluatedContext() const { 9086 assert(!ExprEvalContexts.empty() && 9087 "Must be in an expression evaluation context"); 9088 return ExprEvalContexts.back().isUnevaluated(); 9089 } 9090 9091 /// RAII class used to determine whether SFINAE has 9092 /// trapped any errors that occur during template argument 9093 /// deduction. 9094 class SFINAETrap { 9095 Sema &SemaRef; 9096 unsigned PrevSFINAEErrors; 9097 bool PrevInNonInstantiationSFINAEContext; 9098 bool PrevAccessCheckingSFINAE; 9099 bool PrevLastDiagnosticIgnored; 9100 9101 public: 9102 explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false) 9103 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors), 9104 PrevInNonInstantiationSFINAEContext( 9105 SemaRef.InNonInstantiationSFINAEContext), 9106 PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE), 9107 PrevLastDiagnosticIgnored( 9108 SemaRef.getDiagnostics().isLastDiagnosticIgnored()) 9109 { 9110 if (!SemaRef.isSFINAEContext()) 9111 SemaRef.InNonInstantiationSFINAEContext = true; 9112 SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE; 9113 } 9114 9115 ~SFINAETrap() { 9116 SemaRef.NumSFINAEErrors = PrevSFINAEErrors; 9117 SemaRef.InNonInstantiationSFINAEContext 9118 = PrevInNonInstantiationSFINAEContext; 9119 SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE; 9120 SemaRef.getDiagnostics().setLastDiagnosticIgnored( 9121 PrevLastDiagnosticIgnored); 9122 } 9123 9124 /// Determine whether any SFINAE errors have been trapped. 9125 bool hasErrorOccurred() const { 9126 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors; 9127 } 9128 }; 9129 9130 /// RAII class used to indicate that we are performing provisional 9131 /// semantic analysis to determine the validity of a construct, so 9132 /// typo-correction and diagnostics in the immediate context (not within 9133 /// implicitly-instantiated templates) should be suppressed. 9134 class TentativeAnalysisScope { 9135 Sema &SemaRef; 9136 // FIXME: Using a SFINAETrap for this is a hack. 9137 SFINAETrap Trap; 9138 bool PrevDisableTypoCorrection; 9139 public: 9140 explicit TentativeAnalysisScope(Sema &SemaRef) 9141 : SemaRef(SemaRef), Trap(SemaRef, true), 9142 PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) { 9143 SemaRef.DisableTypoCorrection = true; 9144 } 9145 ~TentativeAnalysisScope() { 9146 SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection; 9147 } 9148 }; 9149 9150 /// The current instantiation scope used to store local 9151 /// variables. 9152 LocalInstantiationScope *CurrentInstantiationScope; 9153 9154 /// Tracks whether we are in a context where typo correction is 9155 /// disabled. 9156 bool DisableTypoCorrection; 9157 9158 /// The number of typos corrected by CorrectTypo. 9159 unsigned TyposCorrected; 9160 9161 typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet; 9162 typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations; 9163 9164 /// A cache containing identifiers for which typo correction failed and 9165 /// their locations, so that repeated attempts to correct an identifier in a 9166 /// given location are ignored if typo correction already failed for it. 9167 IdentifierSourceLocations TypoCorrectionFailures; 9168 9169 /// Worker object for performing CFG-based warnings. 9170 sema::AnalysisBasedWarnings AnalysisWarnings; 9171 threadSafety::BeforeSet *ThreadSafetyDeclCache; 9172 9173 /// An entity for which implicit template instantiation is required. 9174 /// 9175 /// The source location associated with the declaration is the first place in 9176 /// the source code where the declaration was "used". It is not necessarily 9177 /// the point of instantiation (which will be either before or after the 9178 /// namespace-scope declaration that triggered this implicit instantiation), 9179 /// However, it is the location that diagnostics should generally refer to, 9180 /// because users will need to know what code triggered the instantiation. 9181 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation; 9182 9183 /// The queue of implicit template instantiations that are required 9184 /// but have not yet been performed. 9185 std::deque<PendingImplicitInstantiation> PendingInstantiations; 9186 9187 /// Queue of implicit template instantiations that cannot be performed 9188 /// eagerly. 9189 SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations; 9190 9191 class GlobalEagerInstantiationScope { 9192 public: 9193 GlobalEagerInstantiationScope(Sema &S, bool Enabled) 9194 : S(S), Enabled(Enabled) { 9195 if (!Enabled) return; 9196 9197 SavedPendingInstantiations.swap(S.PendingInstantiations); 9198 SavedVTableUses.swap(S.VTableUses); 9199 } 9200 9201 void perform() { 9202 if (Enabled) { 9203 S.DefineUsedVTables(); 9204 S.PerformPendingInstantiations(); 9205 } 9206 } 9207 9208 ~GlobalEagerInstantiationScope() { 9209 if (!Enabled) return; 9210 9211 // Restore the set of pending vtables. 9212 assert(S.VTableUses.empty() && 9213 "VTableUses should be empty before it is discarded."); 9214 S.VTableUses.swap(SavedVTableUses); 9215 9216 // Restore the set of pending implicit instantiations. 9217 if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) { 9218 assert(S.PendingInstantiations.empty() && 9219 "PendingInstantiations should be empty before it is discarded."); 9220 S.PendingInstantiations.swap(SavedPendingInstantiations); 9221 } else { 9222 // Template instantiations in the PCH may be delayed until the TU. 9223 S.PendingInstantiations.swap(SavedPendingInstantiations); 9224 S.PendingInstantiations.insert(S.PendingInstantiations.end(), 9225 SavedPendingInstantiations.begin(), 9226 SavedPendingInstantiations.end()); 9227 } 9228 } 9229 9230 private: 9231 Sema &S; 9232 SmallVector<VTableUse, 16> SavedVTableUses; 9233 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations; 9234 bool Enabled; 9235 }; 9236 9237 /// The queue of implicit template instantiations that are required 9238 /// and must be performed within the current local scope. 9239 /// 9240 /// This queue is only used for member functions of local classes in 9241 /// templates, which must be instantiated in the same scope as their 9242 /// enclosing function, so that they can reference function-local 9243 /// types, static variables, enumerators, etc. 9244 std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations; 9245 9246 class LocalEagerInstantiationScope { 9247 public: 9248 LocalEagerInstantiationScope(Sema &S) : S(S) { 9249 SavedPendingLocalImplicitInstantiations.swap( 9250 S.PendingLocalImplicitInstantiations); 9251 } 9252 9253 void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); } 9254 9255 ~LocalEagerInstantiationScope() { 9256 assert(S.PendingLocalImplicitInstantiations.empty() && 9257 "there shouldn't be any pending local implicit instantiations"); 9258 SavedPendingLocalImplicitInstantiations.swap( 9259 S.PendingLocalImplicitInstantiations); 9260 } 9261 9262 private: 9263 Sema &S; 9264 std::deque<PendingImplicitInstantiation> 9265 SavedPendingLocalImplicitInstantiations; 9266 }; 9267 9268 /// A helper class for building up ExtParameterInfos. 9269 class ExtParameterInfoBuilder { 9270 SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos; 9271 bool HasInteresting = false; 9272 9273 public: 9274 /// Set the ExtParameterInfo for the parameter at the given index, 9275 /// 9276 void set(unsigned index, FunctionProtoType::ExtParameterInfo info) { 9277 assert(Infos.size() <= index); 9278 Infos.resize(index); 9279 Infos.push_back(info); 9280 9281 if (!HasInteresting) 9282 HasInteresting = (info != FunctionProtoType::ExtParameterInfo()); 9283 } 9284 9285 /// Return a pointer (suitable for setting in an ExtProtoInfo) to the 9286 /// ExtParameterInfo array we've built up. 9287 const FunctionProtoType::ExtParameterInfo * 9288 getPointerOrNull(unsigned numParams) { 9289 if (!HasInteresting) return nullptr; 9290 Infos.resize(numParams); 9291 return Infos.data(); 9292 } 9293 }; 9294 9295 void PerformPendingInstantiations(bool LocalOnly = false); 9296 9297 TypeSourceInfo *SubstType(TypeSourceInfo *T, 9298 const MultiLevelTemplateArgumentList &TemplateArgs, 9299 SourceLocation Loc, DeclarationName Entity, 9300 bool AllowDeducedTST = false); 9301 9302 QualType SubstType(QualType T, 9303 const MultiLevelTemplateArgumentList &TemplateArgs, 9304 SourceLocation Loc, DeclarationName Entity); 9305 9306 TypeSourceInfo *SubstType(TypeLoc TL, 9307 const MultiLevelTemplateArgumentList &TemplateArgs, 9308 SourceLocation Loc, DeclarationName Entity); 9309 9310 TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T, 9311 const MultiLevelTemplateArgumentList &TemplateArgs, 9312 SourceLocation Loc, 9313 DeclarationName Entity, 9314 CXXRecordDecl *ThisContext, 9315 Qualifiers ThisTypeQuals); 9316 void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, 9317 const MultiLevelTemplateArgumentList &Args); 9318 bool SubstExceptionSpec(SourceLocation Loc, 9319 FunctionProtoType::ExceptionSpecInfo &ESI, 9320 SmallVectorImpl<QualType> &ExceptionStorage, 9321 const MultiLevelTemplateArgumentList &Args); 9322 ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D, 9323 const MultiLevelTemplateArgumentList &TemplateArgs, 9324 int indexAdjustment, 9325 Optional<unsigned> NumExpansions, 9326 bool ExpectParameterPack); 9327 bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, 9328 const FunctionProtoType::ExtParameterInfo *ExtParamInfos, 9329 const MultiLevelTemplateArgumentList &TemplateArgs, 9330 SmallVectorImpl<QualType> &ParamTypes, 9331 SmallVectorImpl<ParmVarDecl *> *OutParams, 9332 ExtParameterInfoBuilder &ParamInfos); 9333 ExprResult SubstExpr(Expr *E, 9334 const MultiLevelTemplateArgumentList &TemplateArgs); 9335 9336 /// Substitute the given template arguments into a list of 9337 /// expressions, expanding pack expansions if required. 9338 /// 9339 /// \param Exprs The list of expressions to substitute into. 9340 /// 9341 /// \param IsCall Whether this is some form of call, in which case 9342 /// default arguments will be dropped. 9343 /// 9344 /// \param TemplateArgs The set of template arguments to substitute. 9345 /// 9346 /// \param Outputs Will receive all of the substituted arguments. 9347 /// 9348 /// \returns true if an error occurred, false otherwise. 9349 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall, 9350 const MultiLevelTemplateArgumentList &TemplateArgs, 9351 SmallVectorImpl<Expr *> &Outputs); 9352 9353 StmtResult SubstStmt(Stmt *S, 9354 const MultiLevelTemplateArgumentList &TemplateArgs); 9355 9356 TemplateParameterList * 9357 SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, 9358 const MultiLevelTemplateArgumentList &TemplateArgs); 9359 9360 bool 9361 SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args, 9362 const MultiLevelTemplateArgumentList &TemplateArgs, 9363 TemplateArgumentListInfo &Outputs); 9364 9365 9366 Decl *SubstDecl(Decl *D, DeclContext *Owner, 9367 const MultiLevelTemplateArgumentList &TemplateArgs); 9368 9369 /// Substitute the name and return type of a defaulted 'operator<=>' to form 9370 /// an implicit 'operator=='. 9371 FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD, 9372 FunctionDecl *Spaceship); 9373 9374 ExprResult SubstInitializer(Expr *E, 9375 const MultiLevelTemplateArgumentList &TemplateArgs, 9376 bool CXXDirectInit); 9377 9378 bool 9379 SubstBaseSpecifiers(CXXRecordDecl *Instantiation, 9380 CXXRecordDecl *Pattern, 9381 const MultiLevelTemplateArgumentList &TemplateArgs); 9382 9383 bool 9384 InstantiateClass(SourceLocation PointOfInstantiation, 9385 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, 9386 const MultiLevelTemplateArgumentList &TemplateArgs, 9387 TemplateSpecializationKind TSK, 9388 bool Complain = true); 9389 9390 bool InstantiateEnum(SourceLocation PointOfInstantiation, 9391 EnumDecl *Instantiation, EnumDecl *Pattern, 9392 const MultiLevelTemplateArgumentList &TemplateArgs, 9393 TemplateSpecializationKind TSK); 9394 9395 bool InstantiateInClassInitializer( 9396 SourceLocation PointOfInstantiation, FieldDecl *Instantiation, 9397 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs); 9398 9399 struct LateInstantiatedAttribute { 9400 const Attr *TmplAttr; 9401 LocalInstantiationScope *Scope; 9402 Decl *NewDecl; 9403 9404 LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S, 9405 Decl *D) 9406 : TmplAttr(A), Scope(S), NewDecl(D) 9407 { } 9408 }; 9409 typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec; 9410 9411 void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, 9412 const Decl *Pattern, Decl *Inst, 9413 LateInstantiatedAttrVec *LateAttrs = nullptr, 9414 LocalInstantiationScope *OuterMostScope = nullptr); 9415 9416 void 9417 InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, 9418 const Decl *Pattern, Decl *Inst, 9419 LateInstantiatedAttrVec *LateAttrs = nullptr, 9420 LocalInstantiationScope *OuterMostScope = nullptr); 9421 9422 void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor); 9423 9424 bool usesPartialOrExplicitSpecialization( 9425 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec); 9426 9427 bool 9428 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, 9429 ClassTemplateSpecializationDecl *ClassTemplateSpec, 9430 TemplateSpecializationKind TSK, 9431 bool Complain = true); 9432 9433 void InstantiateClassMembers(SourceLocation PointOfInstantiation, 9434 CXXRecordDecl *Instantiation, 9435 const MultiLevelTemplateArgumentList &TemplateArgs, 9436 TemplateSpecializationKind TSK); 9437 9438 void InstantiateClassTemplateSpecializationMembers( 9439 SourceLocation PointOfInstantiation, 9440 ClassTemplateSpecializationDecl *ClassTemplateSpec, 9441 TemplateSpecializationKind TSK); 9442 9443 NestedNameSpecifierLoc 9444 SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 9445 const MultiLevelTemplateArgumentList &TemplateArgs); 9446 9447 DeclarationNameInfo 9448 SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, 9449 const MultiLevelTemplateArgumentList &TemplateArgs); 9450 TemplateName 9451 SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, 9452 SourceLocation Loc, 9453 const MultiLevelTemplateArgumentList &TemplateArgs); 9454 bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, 9455 TemplateArgumentListInfo &Result, 9456 const MultiLevelTemplateArgumentList &TemplateArgs); 9457 9458 bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD, 9459 ParmVarDecl *Param); 9460 void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, 9461 FunctionDecl *Function); 9462 bool CheckInstantiatedFunctionTemplateConstraints( 9463 SourceLocation PointOfInstantiation, FunctionDecl *Decl, 9464 ArrayRef<TemplateArgument> TemplateArgs, 9465 ConstraintSatisfaction &Satisfaction); 9466 FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, 9467 const TemplateArgumentList *Args, 9468 SourceLocation Loc); 9469 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, 9470 FunctionDecl *Function, 9471 bool Recursive = false, 9472 bool DefinitionRequired = false, 9473 bool AtEndOfTU = false); 9474 VarTemplateSpecializationDecl *BuildVarTemplateInstantiation( 9475 VarTemplateDecl *VarTemplate, VarDecl *FromVar, 9476 const TemplateArgumentList &TemplateArgList, 9477 const TemplateArgumentListInfo &TemplateArgsInfo, 9478 SmallVectorImpl<TemplateArgument> &Converted, 9479 SourceLocation PointOfInstantiation, 9480 LateInstantiatedAttrVec *LateAttrs = nullptr, 9481 LocalInstantiationScope *StartingScope = nullptr); 9482 VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl( 9483 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, 9484 const MultiLevelTemplateArgumentList &TemplateArgs); 9485 void 9486 BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, 9487 const MultiLevelTemplateArgumentList &TemplateArgs, 9488 LateInstantiatedAttrVec *LateAttrs, 9489 DeclContext *Owner, 9490 LocalInstantiationScope *StartingScope, 9491 bool InstantiatingVarTemplate = false, 9492 VarTemplateSpecializationDecl *PrevVTSD = nullptr); 9493 9494 void InstantiateVariableInitializer( 9495 VarDecl *Var, VarDecl *OldVar, 9496 const MultiLevelTemplateArgumentList &TemplateArgs); 9497 void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, 9498 VarDecl *Var, bool Recursive = false, 9499 bool DefinitionRequired = false, 9500 bool AtEndOfTU = false); 9501 9502 void InstantiateMemInitializers(CXXConstructorDecl *New, 9503 const CXXConstructorDecl *Tmpl, 9504 const MultiLevelTemplateArgumentList &TemplateArgs); 9505 9506 NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, 9507 const MultiLevelTemplateArgumentList &TemplateArgs, 9508 bool FindingInstantiatedContext = false); 9509 DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC, 9510 const MultiLevelTemplateArgumentList &TemplateArgs); 9511 9512 // Objective-C declarations. 9513 enum ObjCContainerKind { 9514 OCK_None = -1, 9515 OCK_Interface = 0, 9516 OCK_Protocol, 9517 OCK_Category, 9518 OCK_ClassExtension, 9519 OCK_Implementation, 9520 OCK_CategoryImplementation 9521 }; 9522 ObjCContainerKind getObjCContainerKind() const; 9523 9524 DeclResult actOnObjCTypeParam(Scope *S, 9525 ObjCTypeParamVariance variance, 9526 SourceLocation varianceLoc, 9527 unsigned index, 9528 IdentifierInfo *paramName, 9529 SourceLocation paramLoc, 9530 SourceLocation colonLoc, 9531 ParsedType typeBound); 9532 9533 ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc, 9534 ArrayRef<Decl *> typeParams, 9535 SourceLocation rAngleLoc); 9536 void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList); 9537 9538 Decl *ActOnStartClassInterface( 9539 Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, 9540 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, 9541 IdentifierInfo *SuperName, SourceLocation SuperLoc, 9542 ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange, 9543 Decl *const *ProtoRefs, unsigned NumProtoRefs, 9544 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, 9545 const ParsedAttributesView &AttrList); 9546 9547 void ActOnSuperClassOfClassInterface(Scope *S, 9548 SourceLocation AtInterfaceLoc, 9549 ObjCInterfaceDecl *IDecl, 9550 IdentifierInfo *ClassName, 9551 SourceLocation ClassLoc, 9552 IdentifierInfo *SuperName, 9553 SourceLocation SuperLoc, 9554 ArrayRef<ParsedType> SuperTypeArgs, 9555 SourceRange SuperTypeArgsRange); 9556 9557 void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs, 9558 SmallVectorImpl<SourceLocation> &ProtocolLocs, 9559 IdentifierInfo *SuperName, 9560 SourceLocation SuperLoc); 9561 9562 Decl *ActOnCompatibilityAlias( 9563 SourceLocation AtCompatibilityAliasLoc, 9564 IdentifierInfo *AliasName, SourceLocation AliasLocation, 9565 IdentifierInfo *ClassName, SourceLocation ClassLocation); 9566 9567 bool CheckForwardProtocolDeclarationForCircularDependency( 9568 IdentifierInfo *PName, 9569 SourceLocation &PLoc, SourceLocation PrevLoc, 9570 const ObjCList<ObjCProtocolDecl> &PList); 9571 9572 Decl *ActOnStartProtocolInterface( 9573 SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName, 9574 SourceLocation ProtocolLoc, Decl *const *ProtoRefNames, 9575 unsigned NumProtoRefs, const SourceLocation *ProtoLocs, 9576 SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList); 9577 9578 Decl *ActOnStartCategoryInterface( 9579 SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, 9580 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, 9581 IdentifierInfo *CategoryName, SourceLocation CategoryLoc, 9582 Decl *const *ProtoRefs, unsigned NumProtoRefs, 9583 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, 9584 const ParsedAttributesView &AttrList); 9585 9586 Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc, 9587 IdentifierInfo *ClassName, 9588 SourceLocation ClassLoc, 9589 IdentifierInfo *SuperClassname, 9590 SourceLocation SuperClassLoc, 9591 const ParsedAttributesView &AttrList); 9592 9593 Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, 9594 IdentifierInfo *ClassName, 9595 SourceLocation ClassLoc, 9596 IdentifierInfo *CatName, 9597 SourceLocation CatLoc, 9598 const ParsedAttributesView &AttrList); 9599 9600 DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl, 9601 ArrayRef<Decl *> Decls); 9602 9603 DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc, 9604 IdentifierInfo **IdentList, 9605 SourceLocation *IdentLocs, 9606 ArrayRef<ObjCTypeParamList *> TypeParamLists, 9607 unsigned NumElts); 9608 9609 DeclGroupPtrTy 9610 ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc, 9611 ArrayRef<IdentifierLocPair> IdentList, 9612 const ParsedAttributesView &attrList); 9613 9614 void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer, 9615 ArrayRef<IdentifierLocPair> ProtocolId, 9616 SmallVectorImpl<Decl *> &Protocols); 9617 9618 void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId, 9619 SourceLocation ProtocolLoc, 9620 IdentifierInfo *TypeArgId, 9621 SourceLocation TypeArgLoc, 9622 bool SelectProtocolFirst = false); 9623 9624 /// Given a list of identifiers (and their locations), resolve the 9625 /// names to either Objective-C protocol qualifiers or type 9626 /// arguments, as appropriate. 9627 void actOnObjCTypeArgsOrProtocolQualifiers( 9628 Scope *S, 9629 ParsedType baseType, 9630 SourceLocation lAngleLoc, 9631 ArrayRef<IdentifierInfo *> identifiers, 9632 ArrayRef<SourceLocation> identifierLocs, 9633 SourceLocation rAngleLoc, 9634 SourceLocation &typeArgsLAngleLoc, 9635 SmallVectorImpl<ParsedType> &typeArgs, 9636 SourceLocation &typeArgsRAngleLoc, 9637 SourceLocation &protocolLAngleLoc, 9638 SmallVectorImpl<Decl *> &protocols, 9639 SourceLocation &protocolRAngleLoc, 9640 bool warnOnIncompleteProtocols); 9641 9642 /// Build a an Objective-C protocol-qualified 'id' type where no 9643 /// base type was specified. 9644 TypeResult actOnObjCProtocolQualifierType( 9645 SourceLocation lAngleLoc, 9646 ArrayRef<Decl *> protocols, 9647 ArrayRef<SourceLocation> protocolLocs, 9648 SourceLocation rAngleLoc); 9649 9650 /// Build a specialized and/or protocol-qualified Objective-C type. 9651 TypeResult actOnObjCTypeArgsAndProtocolQualifiers( 9652 Scope *S, 9653 SourceLocation Loc, 9654 ParsedType BaseType, 9655 SourceLocation TypeArgsLAngleLoc, 9656 ArrayRef<ParsedType> TypeArgs, 9657 SourceLocation TypeArgsRAngleLoc, 9658 SourceLocation ProtocolLAngleLoc, 9659 ArrayRef<Decl *> Protocols, 9660 ArrayRef<SourceLocation> ProtocolLocs, 9661 SourceLocation ProtocolRAngleLoc); 9662 9663 /// Build an Objective-C type parameter type. 9664 QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, 9665 SourceLocation ProtocolLAngleLoc, 9666 ArrayRef<ObjCProtocolDecl *> Protocols, 9667 ArrayRef<SourceLocation> ProtocolLocs, 9668 SourceLocation ProtocolRAngleLoc, 9669 bool FailOnError = false); 9670 9671 /// Build an Objective-C object pointer type. 9672 QualType BuildObjCObjectType(QualType BaseType, 9673 SourceLocation Loc, 9674 SourceLocation TypeArgsLAngleLoc, 9675 ArrayRef<TypeSourceInfo *> TypeArgs, 9676 SourceLocation TypeArgsRAngleLoc, 9677 SourceLocation ProtocolLAngleLoc, 9678 ArrayRef<ObjCProtocolDecl *> Protocols, 9679 ArrayRef<SourceLocation> ProtocolLocs, 9680 SourceLocation ProtocolRAngleLoc, 9681 bool FailOnError = false); 9682 9683 /// Ensure attributes are consistent with type. 9684 /// \param [in, out] Attributes The attributes to check; they will 9685 /// be modified to be consistent with \p PropertyTy. 9686 void CheckObjCPropertyAttributes(Decl *PropertyPtrTy, 9687 SourceLocation Loc, 9688 unsigned &Attributes, 9689 bool propertyInPrimaryClass); 9690 9691 /// Process the specified property declaration and create decls for the 9692 /// setters and getters as needed. 9693 /// \param property The property declaration being processed 9694 void ProcessPropertyDecl(ObjCPropertyDecl *property); 9695 9696 9697 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property, 9698 ObjCPropertyDecl *SuperProperty, 9699 const IdentifierInfo *Name, 9700 bool OverridingProtocolProperty); 9701 9702 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, 9703 ObjCInterfaceDecl *ID); 9704 9705 Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd, 9706 ArrayRef<Decl *> allMethods = None, 9707 ArrayRef<DeclGroupPtrTy> allTUVars = None); 9708 9709 Decl *ActOnProperty(Scope *S, SourceLocation AtLoc, 9710 SourceLocation LParenLoc, 9711 FieldDeclarator &FD, ObjCDeclSpec &ODS, 9712 Selector GetterSel, Selector SetterSel, 9713 tok::ObjCKeywordKind MethodImplKind, 9714 DeclContext *lexicalDC = nullptr); 9715 9716 Decl *ActOnPropertyImplDecl(Scope *S, 9717 SourceLocation AtLoc, 9718 SourceLocation PropertyLoc, 9719 bool ImplKind, 9720 IdentifierInfo *PropertyId, 9721 IdentifierInfo *PropertyIvar, 9722 SourceLocation PropertyIvarLoc, 9723 ObjCPropertyQueryKind QueryKind); 9724 9725 enum ObjCSpecialMethodKind { 9726 OSMK_None, 9727 OSMK_Alloc, 9728 OSMK_New, 9729 OSMK_Copy, 9730 OSMK_RetainingInit, 9731 OSMK_NonRetainingInit 9732 }; 9733 9734 struct ObjCArgInfo { 9735 IdentifierInfo *Name; 9736 SourceLocation NameLoc; 9737 // The Type is null if no type was specified, and the DeclSpec is invalid 9738 // in this case. 9739 ParsedType Type; 9740 ObjCDeclSpec DeclSpec; 9741 9742 /// ArgAttrs - Attribute list for this argument. 9743 ParsedAttributesView ArgAttrs; 9744 }; 9745 9746 Decl *ActOnMethodDeclaration( 9747 Scope *S, 9748 SourceLocation BeginLoc, // location of the + or -. 9749 SourceLocation EndLoc, // location of the ; or {. 9750 tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType, 9751 ArrayRef<SourceLocation> SelectorLocs, Selector Sel, 9752 // optional arguments. The number of types/arguments is obtained 9753 // from the Sel.getNumArgs(). 9754 ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo, 9755 unsigned CNumArgs, // c-style args 9756 const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind, 9757 bool isVariadic, bool MethodDefinition); 9758 9759 ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel, 9760 const ObjCObjectPointerType *OPT, 9761 bool IsInstance); 9762 ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty, 9763 bool IsInstance); 9764 9765 bool CheckARCMethodDecl(ObjCMethodDecl *method); 9766 bool inferObjCARCLifetime(ValueDecl *decl); 9767 9768 void deduceOpenCLAddressSpace(ValueDecl *decl); 9769 9770 ExprResult 9771 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, 9772 Expr *BaseExpr, 9773 SourceLocation OpLoc, 9774 DeclarationName MemberName, 9775 SourceLocation MemberLoc, 9776 SourceLocation SuperLoc, QualType SuperType, 9777 bool Super); 9778 9779 ExprResult 9780 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, 9781 IdentifierInfo &propertyName, 9782 SourceLocation receiverNameLoc, 9783 SourceLocation propertyNameLoc); 9784 9785 ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc); 9786 9787 /// Describes the kind of message expression indicated by a message 9788 /// send that starts with an identifier. 9789 enum ObjCMessageKind { 9790 /// The message is sent to 'super'. 9791 ObjCSuperMessage, 9792 /// The message is an instance message. 9793 ObjCInstanceMessage, 9794 /// The message is a class message, and the identifier is a type 9795 /// name. 9796 ObjCClassMessage 9797 }; 9798 9799 ObjCMessageKind getObjCMessageKind(Scope *S, 9800 IdentifierInfo *Name, 9801 SourceLocation NameLoc, 9802 bool IsSuper, 9803 bool HasTrailingDot, 9804 ParsedType &ReceiverType); 9805 9806 ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc, 9807 Selector Sel, 9808 SourceLocation LBracLoc, 9809 ArrayRef<SourceLocation> SelectorLocs, 9810 SourceLocation RBracLoc, 9811 MultiExprArg Args); 9812 9813 ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo, 9814 QualType ReceiverType, 9815 SourceLocation SuperLoc, 9816 Selector Sel, 9817 ObjCMethodDecl *Method, 9818 SourceLocation LBracLoc, 9819 ArrayRef<SourceLocation> SelectorLocs, 9820 SourceLocation RBracLoc, 9821 MultiExprArg Args, 9822 bool isImplicit = false); 9823 9824 ExprResult BuildClassMessageImplicit(QualType ReceiverType, 9825 bool isSuperReceiver, 9826 SourceLocation Loc, 9827 Selector Sel, 9828 ObjCMethodDecl *Method, 9829 MultiExprArg Args); 9830 9831 ExprResult ActOnClassMessage(Scope *S, 9832 ParsedType Receiver, 9833 Selector Sel, 9834 SourceLocation LBracLoc, 9835 ArrayRef<SourceLocation> SelectorLocs, 9836 SourceLocation RBracLoc, 9837 MultiExprArg Args); 9838 9839 ExprResult BuildInstanceMessage(Expr *Receiver, 9840 QualType ReceiverType, 9841 SourceLocation SuperLoc, 9842 Selector Sel, 9843 ObjCMethodDecl *Method, 9844 SourceLocation LBracLoc, 9845 ArrayRef<SourceLocation> SelectorLocs, 9846 SourceLocation RBracLoc, 9847 MultiExprArg Args, 9848 bool isImplicit = false); 9849 9850 ExprResult BuildInstanceMessageImplicit(Expr *Receiver, 9851 QualType ReceiverType, 9852 SourceLocation Loc, 9853 Selector Sel, 9854 ObjCMethodDecl *Method, 9855 MultiExprArg Args); 9856 9857 ExprResult ActOnInstanceMessage(Scope *S, 9858 Expr *Receiver, 9859 Selector Sel, 9860 SourceLocation LBracLoc, 9861 ArrayRef<SourceLocation> SelectorLocs, 9862 SourceLocation RBracLoc, 9863 MultiExprArg Args); 9864 9865 ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc, 9866 ObjCBridgeCastKind Kind, 9867 SourceLocation BridgeKeywordLoc, 9868 TypeSourceInfo *TSInfo, 9869 Expr *SubExpr); 9870 9871 ExprResult ActOnObjCBridgedCast(Scope *S, 9872 SourceLocation LParenLoc, 9873 ObjCBridgeCastKind Kind, 9874 SourceLocation BridgeKeywordLoc, 9875 ParsedType Type, 9876 SourceLocation RParenLoc, 9877 Expr *SubExpr); 9878 9879 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr); 9880 9881 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr); 9882 9883 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr, 9884 CastKind &Kind); 9885 9886 bool checkObjCBridgeRelatedComponents(SourceLocation Loc, 9887 QualType DestType, QualType SrcType, 9888 ObjCInterfaceDecl *&RelatedClass, 9889 ObjCMethodDecl *&ClassMethod, 9890 ObjCMethodDecl *&InstanceMethod, 9891 TypedefNameDecl *&TDNDecl, 9892 bool CfToNs, bool Diagnose = true); 9893 9894 bool CheckObjCBridgeRelatedConversions(SourceLocation Loc, 9895 QualType DestType, QualType SrcType, 9896 Expr *&SrcExpr, bool Diagnose = true); 9897 9898 bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr, 9899 bool Diagnose = true); 9900 9901 bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall); 9902 9903 /// Check whether the given new method is a valid override of the 9904 /// given overridden method, and set any properties that should be inherited. 9905 void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, 9906 const ObjCMethodDecl *Overridden); 9907 9908 /// Describes the compatibility of a result type with its method. 9909 enum ResultTypeCompatibilityKind { 9910 RTC_Compatible, 9911 RTC_Incompatible, 9912 RTC_Unknown 9913 }; 9914 9915 void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method, 9916 ObjCMethodDecl *overridden); 9917 9918 void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod, 9919 ObjCInterfaceDecl *CurrentClass, 9920 ResultTypeCompatibilityKind RTC); 9921 9922 enum PragmaOptionsAlignKind { 9923 POAK_Native, // #pragma options align=native 9924 POAK_Natural, // #pragma options align=natural 9925 POAK_Packed, // #pragma options align=packed 9926 POAK_Power, // #pragma options align=power 9927 POAK_Mac68k, // #pragma options align=mac68k 9928 POAK_Reset // #pragma options align=reset 9929 }; 9930 9931 /// ActOnPragmaClangSection - Called on well formed \#pragma clang section 9932 void ActOnPragmaClangSection(SourceLocation PragmaLoc, 9933 PragmaClangSectionAction Action, 9934 PragmaClangSectionKind SecKind, StringRef SecName); 9935 9936 /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align. 9937 void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, 9938 SourceLocation PragmaLoc); 9939 9940 /// ActOnPragmaPack - Called on well formed \#pragma pack(...). 9941 void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, 9942 StringRef SlotLabel, Expr *Alignment); 9943 9944 enum class PragmaAlignPackDiagnoseKind { 9945 NonDefaultStateAtInclude, 9946 ChangedStateAtExit 9947 }; 9948 9949 void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, 9950 SourceLocation IncludeLoc); 9951 void DiagnoseUnterminatedPragmaAlignPack(); 9952 9953 /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off]. 9954 void ActOnPragmaMSStruct(PragmaMSStructKind Kind); 9955 9956 /// ActOnPragmaMSComment - Called on well formed 9957 /// \#pragma comment(kind, "arg"). 9958 void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind, 9959 StringRef Arg); 9960 9961 /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma 9962 /// pointers_to_members(representation method[, general purpose 9963 /// representation]). 9964 void ActOnPragmaMSPointersToMembers( 9965 LangOptions::PragmaMSPointersToMembersKind Kind, 9966 SourceLocation PragmaLoc); 9967 9968 /// Called on well formed \#pragma vtordisp(). 9969 void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, 9970 SourceLocation PragmaLoc, 9971 MSVtorDispMode Value); 9972 9973 enum PragmaSectionKind { 9974 PSK_DataSeg, 9975 PSK_BSSSeg, 9976 PSK_ConstSeg, 9977 PSK_CodeSeg, 9978 }; 9979 9980 bool UnifySection(StringRef SectionName, int SectionFlags, 9981 NamedDecl *TheDecl); 9982 bool UnifySection(StringRef SectionName, 9983 int SectionFlags, 9984 SourceLocation PragmaSectionLocation); 9985 9986 /// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg. 9987 void ActOnPragmaMSSeg(SourceLocation PragmaLocation, 9988 PragmaMsStackAction Action, 9989 llvm::StringRef StackSlotLabel, 9990 StringLiteral *SegmentName, 9991 llvm::StringRef PragmaName); 9992 9993 /// Called on well formed \#pragma section(). 9994 void ActOnPragmaMSSection(SourceLocation PragmaLocation, 9995 int SectionFlags, StringLiteral *SegmentName); 9996 9997 /// Called on well-formed \#pragma init_seg(). 9998 void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, 9999 StringLiteral *SegmentName); 10000 10001 /// Called on #pragma clang __debug dump II 10002 void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II); 10003 10004 /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch 10005 void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name, 10006 StringRef Value); 10007 10008 /// Are precise floating point semantics currently enabled? 10009 bool isPreciseFPEnabled() { 10010 return !CurFPFeatures.getAllowFPReassociate() && 10011 !CurFPFeatures.getNoSignedZero() && 10012 !CurFPFeatures.getAllowReciprocal() && 10013 !CurFPFeatures.getAllowApproxFunc(); 10014 } 10015 10016 /// ActOnPragmaFloatControl - Call on well-formed \#pragma float_control 10017 void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, 10018 PragmaFloatControlKind Value); 10019 10020 /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'. 10021 void ActOnPragmaUnused(const Token &Identifier, 10022 Scope *curScope, 10023 SourceLocation PragmaLoc); 10024 10025 /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... . 10026 void ActOnPragmaVisibility(const IdentifierInfo* VisType, 10027 SourceLocation PragmaLoc); 10028 10029 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II, 10030 SourceLocation Loc); 10031 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W); 10032 10033 /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident. 10034 void ActOnPragmaWeakID(IdentifierInfo* WeakName, 10035 SourceLocation PragmaLoc, 10036 SourceLocation WeakNameLoc); 10037 10038 /// ActOnPragmaRedefineExtname - Called on well formed 10039 /// \#pragma redefine_extname oldname newname. 10040 void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName, 10041 IdentifierInfo* AliasName, 10042 SourceLocation PragmaLoc, 10043 SourceLocation WeakNameLoc, 10044 SourceLocation AliasNameLoc); 10045 10046 /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident. 10047 void ActOnPragmaWeakAlias(IdentifierInfo* WeakName, 10048 IdentifierInfo* AliasName, 10049 SourceLocation PragmaLoc, 10050 SourceLocation WeakNameLoc, 10051 SourceLocation AliasNameLoc); 10052 10053 /// ActOnPragmaFPContract - Called on well formed 10054 /// \#pragma {STDC,OPENCL} FP_CONTRACT and 10055 /// \#pragma clang fp contract 10056 void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC); 10057 10058 /// Called on well formed 10059 /// \#pragma clang fp reassociate 10060 void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled); 10061 10062 /// ActOnPragmaFenvAccess - Called on well formed 10063 /// \#pragma STDC FENV_ACCESS 10064 void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled); 10065 10066 /// Called on well formed '\#pragma clang fp' that has option 'exceptions'. 10067 void ActOnPragmaFPExceptions(SourceLocation Loc, 10068 LangOptions::FPExceptionModeKind); 10069 10070 /// Called to set constant rounding mode for floating point operations. 10071 void setRoundingMode(SourceLocation Loc, llvm::RoundingMode); 10072 10073 /// Called to set exception behavior for floating point operations. 10074 void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind); 10075 10076 /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to 10077 /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'. 10078 void AddAlignmentAttributesForRecord(RecordDecl *RD); 10079 10080 /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record. 10081 void AddMsStructLayoutForRecord(RecordDecl *RD); 10082 10083 /// PushNamespaceVisibilityAttr - Note that we've entered a 10084 /// namespace with a visibility attribute. 10085 void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr, 10086 SourceLocation Loc); 10087 10088 /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used, 10089 /// add an appropriate visibility attribute. 10090 void AddPushedVisibilityAttribute(Decl *RD); 10091 10092 /// PopPragmaVisibility - Pop the top element of the visibility stack; used 10093 /// for '\#pragma GCC visibility' and visibility attributes on namespaces. 10094 void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc); 10095 10096 /// FreeVisContext - Deallocate and null out VisContext. 10097 void FreeVisContext(); 10098 10099 /// AddCFAuditedAttribute - Check whether we're currently within 10100 /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding 10101 /// the appropriate attribute. 10102 void AddCFAuditedAttribute(Decl *D); 10103 10104 void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, 10105 SourceLocation PragmaLoc, 10106 attr::ParsedSubjectMatchRuleSet Rules); 10107 void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc, 10108 const IdentifierInfo *Namespace); 10109 10110 /// Called on well-formed '\#pragma clang attribute pop'. 10111 void ActOnPragmaAttributePop(SourceLocation PragmaLoc, 10112 const IdentifierInfo *Namespace); 10113 10114 /// Adds the attributes that have been specified using the 10115 /// '\#pragma clang attribute push' directives to the given declaration. 10116 void AddPragmaAttributes(Scope *S, Decl *D); 10117 10118 void DiagnoseUnterminatedPragmaAttribute(); 10119 10120 /// Called on well formed \#pragma clang optimize. 10121 void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc); 10122 10123 /// Get the location for the currently active "\#pragma clang optimize 10124 /// off". If this location is invalid, then the state of the pragma is "on". 10125 SourceLocation getOptimizeOffPragmaLocation() const { 10126 return OptimizeOffPragmaLocation; 10127 } 10128 10129 /// Only called on function definitions; if there is a pragma in scope 10130 /// with the effect of a range-based optnone, consider marking the function 10131 /// with attribute optnone. 10132 void AddRangeBasedOptnone(FunctionDecl *FD); 10133 10134 /// Adds the 'optnone' attribute to the function declaration if there 10135 /// are no conflicts; Loc represents the location causing the 'optnone' 10136 /// attribute to be added (usually because of a pragma). 10137 void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc); 10138 10139 /// AddAlignedAttr - Adds an aligned attribute to a particular declaration. 10140 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, 10141 bool IsPackExpansion); 10142 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T, 10143 bool IsPackExpansion); 10144 10145 /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular 10146 /// declaration. 10147 void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, 10148 Expr *OE); 10149 10150 /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular 10151 /// declaration. 10152 void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, 10153 Expr *ParamExpr); 10154 10155 /// AddAlignValueAttr - Adds an align_value attribute to a particular 10156 /// declaration. 10157 void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E); 10158 10159 /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D. 10160 void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, 10161 StringRef Annot, MutableArrayRef<Expr *> Args); 10162 10163 /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular 10164 /// declaration. 10165 void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI, 10166 Expr *MaxThreads, Expr *MinBlocks); 10167 10168 /// AddModeAttr - Adds a mode attribute to a particular declaration. 10169 void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name, 10170 bool InInstantiation = false); 10171 10172 void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, 10173 ParameterABI ABI); 10174 10175 enum class RetainOwnershipKind {NS, CF, OS}; 10176 void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, 10177 RetainOwnershipKind K, bool IsTemplateInstantiation); 10178 10179 /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size 10180 /// attribute to a particular declaration. 10181 void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI, 10182 Expr *Min, Expr *Max); 10183 10184 /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a 10185 /// particular declaration. 10186 void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI, 10187 Expr *Min, Expr *Max); 10188 10189 bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type); 10190 10191 //===--------------------------------------------------------------------===// 10192 // C++ Coroutines TS 10193 // 10194 bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, 10195 StringRef Keyword); 10196 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E); 10197 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E); 10198 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E); 10199 10200 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E, 10201 bool IsImplicit = false); 10202 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E, 10203 UnresolvedLookupExpr* Lookup); 10204 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E); 10205 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E, 10206 bool IsImplicit = false); 10207 StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs); 10208 bool buildCoroutineParameterMoves(SourceLocation Loc); 10209 VarDecl *buildCoroutinePromise(SourceLocation Loc); 10210 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body); 10211 ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc, 10212 SourceLocation FuncLoc); 10213 /// Check that the expression co_await promise.final_suspend() shall not be 10214 /// potentially-throwing. 10215 bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend); 10216 10217 //===--------------------------------------------------------------------===// 10218 // OpenMP directives and clauses. 10219 // 10220 private: 10221 void *VarDataSharingAttributesStack; 10222 10223 struct DeclareTargetContextInfo { 10224 struct MapInfo { 10225 OMPDeclareTargetDeclAttr::MapTypeTy MT; 10226 SourceLocation Loc; 10227 }; 10228 /// Explicitly listed variables and functions in a 'to' or 'link' clause. 10229 llvm::DenseMap<NamedDecl *, MapInfo> ExplicitlyMapped; 10230 10231 /// The 'device_type' as parsed from the clause. 10232 OMPDeclareTargetDeclAttr::DevTypeTy DT = OMPDeclareTargetDeclAttr::DT_Any; 10233 10234 /// The directive kind, `begin declare target` or `declare target`. 10235 OpenMPDirectiveKind Kind; 10236 10237 /// The directive location. 10238 SourceLocation Loc; 10239 10240 DeclareTargetContextInfo(OpenMPDirectiveKind Kind, SourceLocation Loc) 10241 : Kind(Kind), Loc(Loc) {} 10242 }; 10243 10244 /// Number of nested '#pragma omp declare target' directives. 10245 SmallVector<DeclareTargetContextInfo, 4> DeclareTargetNesting; 10246 10247 /// Initialization of data-sharing attributes stack. 10248 void InitDataSharingAttributesStack(); 10249 void DestroyDataSharingAttributesStack(); 10250 ExprResult 10251 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind, 10252 bool StrictlyPositive = true, 10253 bool SuppressExprDiags = false); 10254 /// Returns OpenMP nesting level for current directive. 10255 unsigned getOpenMPNestingLevel() const; 10256 10257 /// Adjusts the function scopes index for the target-based regions. 10258 void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex, 10259 unsigned Level) const; 10260 10261 /// Returns the number of scopes associated with the construct on the given 10262 /// OpenMP level. 10263 int getNumberOfConstructScopes(unsigned Level) const; 10264 10265 /// Push new OpenMP function region for non-capturing function. 10266 void pushOpenMPFunctionRegion(); 10267 10268 /// Pop OpenMP function region for non-capturing function. 10269 void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI); 10270 10271 /// Analyzes and checks a loop nest for use by a loop transformation. 10272 /// 10273 /// \param Kind The loop transformation directive kind. 10274 /// \param NumLoops How many nested loops the directive is expecting. 10275 /// \param AStmt Associated statement of the transformation directive. 10276 /// \param LoopHelpers [out] The loop analysis result. 10277 /// \param Body [out] The body code nested in \p NumLoops loop. 10278 /// \param OriginalInits [out] Collection of statements and declarations that 10279 /// must have been executed/declared before entering the 10280 /// loop. 10281 /// 10282 /// \return Whether there was any error. 10283 bool checkTransformableLoopNest( 10284 OpenMPDirectiveKind Kind, Stmt *AStmt, int NumLoops, 10285 SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers, 10286 Stmt *&Body, 10287 SmallVectorImpl<SmallVector<llvm::PointerUnion<Stmt *, Decl *>, 0>> 10288 &OriginalInits); 10289 10290 /// Helper to keep information about the current `omp begin/end declare 10291 /// variant` nesting. 10292 struct OMPDeclareVariantScope { 10293 /// The associated OpenMP context selector. 10294 OMPTraitInfo *TI; 10295 10296 /// The associated OpenMP context selector mangling. 10297 std::string NameSuffix; 10298 10299 OMPDeclareVariantScope(OMPTraitInfo &TI); 10300 }; 10301 10302 /// Return the OMPTraitInfo for the surrounding scope, if any. 10303 OMPTraitInfo *getOMPTraitInfoForSurroundingScope() { 10304 return OMPDeclareVariantScopes.empty() ? nullptr 10305 : OMPDeclareVariantScopes.back().TI; 10306 } 10307 10308 /// The current `omp begin/end declare variant` scopes. 10309 SmallVector<OMPDeclareVariantScope, 4> OMPDeclareVariantScopes; 10310 10311 /// The current `omp begin/end assumes` scopes. 10312 SmallVector<AssumptionAttr *, 4> OMPAssumeScoped; 10313 10314 /// All `omp assumes` we encountered so far. 10315 SmallVector<AssumptionAttr *, 4> OMPAssumeGlobal; 10316 10317 public: 10318 /// The declarator \p D defines a function in the scope \p S which is nested 10319 /// in an `omp begin/end declare variant` scope. In this method we create a 10320 /// declaration for \p D and rename \p D according to the OpenMP context 10321 /// selector of the surrounding scope. Return all base functions in \p Bases. 10322 void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope( 10323 Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, 10324 SmallVectorImpl<FunctionDecl *> &Bases); 10325 10326 /// Register \p D as specialization of all base functions in \p Bases in the 10327 /// current `omp begin/end declare variant` scope. 10328 void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope( 10329 Decl *D, SmallVectorImpl<FunctionDecl *> &Bases); 10330 10331 /// Act on \p D, a function definition inside of an `omp [begin/end] assumes`. 10332 void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D); 10333 10334 /// Can we exit an OpenMP declare variant scope at the moment. 10335 bool isInOpenMPDeclareVariantScope() const { 10336 return !OMPDeclareVariantScopes.empty(); 10337 } 10338 10339 /// Given the potential call expression \p Call, determine if there is a 10340 /// specialization via the OpenMP declare variant mechanism available. If 10341 /// there is, return the specialized call expression, otherwise return the 10342 /// original \p Call. 10343 ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope, 10344 SourceLocation LParenLoc, MultiExprArg ArgExprs, 10345 SourceLocation RParenLoc, Expr *ExecConfig); 10346 10347 /// Handle a `omp begin declare variant`. 10348 void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI); 10349 10350 /// Handle a `omp end declare variant`. 10351 void ActOnOpenMPEndDeclareVariant(); 10352 10353 /// Checks if the variant/multiversion functions are compatible. 10354 bool areMultiversionVariantFunctionsCompatible( 10355 const FunctionDecl *OldFD, const FunctionDecl *NewFD, 10356 const PartialDiagnostic &NoProtoDiagID, 10357 const PartialDiagnosticAt &NoteCausedDiagIDAt, 10358 const PartialDiagnosticAt &NoSupportDiagIDAt, 10359 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, 10360 bool ConstexprSupported, bool CLinkageMayDiffer); 10361 10362 /// Function tries to capture lambda's captured variables in the OpenMP region 10363 /// before the original lambda is captured. 10364 void tryCaptureOpenMPLambdas(ValueDecl *V); 10365 10366 /// Return true if the provided declaration \a VD should be captured by 10367 /// reference. 10368 /// \param Level Relative level of nested OpenMP construct for that the check 10369 /// is performed. 10370 /// \param OpenMPCaptureLevel Capture level within an OpenMP construct. 10371 bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level, 10372 unsigned OpenMPCaptureLevel) const; 10373 10374 /// Check if the specified variable is used in one of the private 10375 /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP 10376 /// constructs. 10377 VarDecl *isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo = false, 10378 unsigned StopAt = 0); 10379 ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK, 10380 ExprObjectKind OK, SourceLocation Loc); 10381 10382 /// If the current region is a loop-based region, mark the start of the loop 10383 /// construct. 10384 void startOpenMPLoop(); 10385 10386 /// If the current region is a range loop-based region, mark the start of the 10387 /// loop construct. 10388 void startOpenMPCXXRangeFor(); 10389 10390 /// Check if the specified variable is used in 'private' clause. 10391 /// \param Level Relative level of nested OpenMP construct for that the check 10392 /// is performed. 10393 OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level, 10394 unsigned CapLevel) const; 10395 10396 /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.) 10397 /// for \p FD based on DSA for the provided corresponding captured declaration 10398 /// \p D. 10399 void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level); 10400 10401 /// Check if the specified variable is captured by 'target' directive. 10402 /// \param Level Relative level of nested OpenMP construct for that the check 10403 /// is performed. 10404 bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level, 10405 unsigned CaptureLevel) const; 10406 10407 /// Check if the specified global variable must be captured by outer capture 10408 /// regions. 10409 /// \param Level Relative level of nested OpenMP construct for that 10410 /// the check is performed. 10411 bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level, 10412 unsigned CaptureLevel) const; 10413 10414 ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc, 10415 Expr *Op); 10416 /// Called on start of new data sharing attribute block. 10417 void StartOpenMPDSABlock(OpenMPDirectiveKind K, 10418 const DeclarationNameInfo &DirName, Scope *CurScope, 10419 SourceLocation Loc); 10420 /// Start analysis of clauses. 10421 void StartOpenMPClause(OpenMPClauseKind K); 10422 /// End analysis of clauses. 10423 void EndOpenMPClause(); 10424 /// Called on end of data sharing attribute block. 10425 void EndOpenMPDSABlock(Stmt *CurDirective); 10426 10427 /// Check if the current region is an OpenMP loop region and if it is, 10428 /// mark loop control variable, used in \p Init for loop initialization, as 10429 /// private by default. 10430 /// \param Init First part of the for loop. 10431 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init); 10432 10433 // OpenMP directives and clauses. 10434 /// Called on correct id-expression from the '#pragma omp 10435 /// threadprivate'. 10436 ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec, 10437 const DeclarationNameInfo &Id, 10438 OpenMPDirectiveKind Kind); 10439 /// Called on well-formed '#pragma omp threadprivate'. 10440 DeclGroupPtrTy ActOnOpenMPThreadprivateDirective( 10441 SourceLocation Loc, 10442 ArrayRef<Expr *> VarList); 10443 /// Builds a new OpenMPThreadPrivateDecl and checks its correctness. 10444 OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc, 10445 ArrayRef<Expr *> VarList); 10446 /// Called on well-formed '#pragma omp allocate'. 10447 DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc, 10448 ArrayRef<Expr *> VarList, 10449 ArrayRef<OMPClause *> Clauses, 10450 DeclContext *Owner = nullptr); 10451 10452 /// Called on well-formed '#pragma omp [begin] assume[s]'. 10453 void ActOnOpenMPAssumesDirective(SourceLocation Loc, 10454 OpenMPDirectiveKind DKind, 10455 ArrayRef<StringRef> Assumptions, 10456 bool SkippedClauses); 10457 10458 /// Check if there is an active global `omp begin assumes` directive. 10459 bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); } 10460 10461 /// Check if there is an active global `omp assumes` directive. 10462 bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); } 10463 10464 /// Called on well-formed '#pragma omp end assumes'. 10465 void ActOnOpenMPEndAssumesDirective(); 10466 10467 /// Called on well-formed '#pragma omp requires'. 10468 DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc, 10469 ArrayRef<OMPClause *> ClauseList); 10470 /// Check restrictions on Requires directive 10471 OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc, 10472 ArrayRef<OMPClause *> Clauses); 10473 /// Check if the specified type is allowed to be used in 'omp declare 10474 /// reduction' construct. 10475 QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, 10476 TypeResult ParsedType); 10477 /// Called on start of '#pragma omp declare reduction'. 10478 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart( 10479 Scope *S, DeclContext *DC, DeclarationName Name, 10480 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes, 10481 AccessSpecifier AS, Decl *PrevDeclInScope = nullptr); 10482 /// Initialize declare reduction construct initializer. 10483 void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D); 10484 /// Finish current declare reduction construct initializer. 10485 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner); 10486 /// Initialize declare reduction construct initializer. 10487 /// \return omp_priv variable. 10488 VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D); 10489 /// Finish current declare reduction construct initializer. 10490 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, 10491 VarDecl *OmpPrivParm); 10492 /// Called at the end of '#pragma omp declare reduction'. 10493 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd( 10494 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid); 10495 10496 /// Check variable declaration in 'omp declare mapper' construct. 10497 TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D); 10498 /// Check if the specified type is allowed to be used in 'omp declare 10499 /// mapper' construct. 10500 QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc, 10501 TypeResult ParsedType); 10502 /// Called on start of '#pragma omp declare mapper'. 10503 DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective( 10504 Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType, 10505 SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS, 10506 Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses, 10507 Decl *PrevDeclInScope = nullptr); 10508 /// Build the mapper variable of '#pragma omp declare mapper'. 10509 ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, 10510 QualType MapperType, 10511 SourceLocation StartLoc, 10512 DeclarationName VN); 10513 bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const; 10514 const ValueDecl *getOpenMPDeclareMapperVarName() const; 10515 10516 /// Called on the start of target region i.e. '#pragma omp declare target'. 10517 bool ActOnStartOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI); 10518 10519 /// Called at the end of target region i.e. '#pragma omp end declare target'. 10520 const DeclareTargetContextInfo ActOnOpenMPEndDeclareTargetDirective(); 10521 10522 /// Called once a target context is completed, that can be when a 10523 /// '#pragma omp end declare target' was encountered or when a 10524 /// '#pragma omp declare target' without declaration-definition-seq was 10525 /// encountered. 10526 void ActOnFinishedOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI); 10527 10528 /// Searches for the provided declaration name for OpenMP declare target 10529 /// directive. 10530 NamedDecl *lookupOpenMPDeclareTargetName(Scope *CurScope, 10531 CXXScopeSpec &ScopeSpec, 10532 const DeclarationNameInfo &Id); 10533 10534 /// Called on correct id-expression from the '#pragma omp declare target'. 10535 void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc, 10536 OMPDeclareTargetDeclAttr::MapTypeTy MT, 10537 OMPDeclareTargetDeclAttr::DevTypeTy DT); 10538 10539 /// Check declaration inside target region. 10540 void 10541 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, 10542 SourceLocation IdLoc = SourceLocation()); 10543 /// Finishes analysis of the deferred functions calls that may be declared as 10544 /// host/nohost during device/host compilation. 10545 void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller, 10546 const FunctionDecl *Callee, 10547 SourceLocation Loc); 10548 /// Return true inside OpenMP declare target region. 10549 bool isInOpenMPDeclareTargetContext() const { 10550 return !DeclareTargetNesting.empty(); 10551 } 10552 /// Return true inside OpenMP target region. 10553 bool isInOpenMPTargetExecutionDirective() const; 10554 10555 /// Return the number of captured regions created for an OpenMP directive. 10556 static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind); 10557 10558 /// Initialization of captured region for OpenMP region. 10559 void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope); 10560 10561 /// Called for syntactical loops (ForStmt or CXXForRangeStmt) associated to 10562 /// an OpenMP loop directive. 10563 StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt); 10564 10565 /// End of OpenMP region. 10566 /// 10567 /// \param S Statement associated with the current OpenMP region. 10568 /// \param Clauses List of clauses for the current OpenMP region. 10569 /// 10570 /// \returns Statement for finished OpenMP region. 10571 StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses); 10572 StmtResult ActOnOpenMPExecutableDirective( 10573 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, 10574 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, 10575 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc); 10576 /// Called on well-formed '\#pragma omp parallel' after parsing 10577 /// of the associated statement. 10578 StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses, 10579 Stmt *AStmt, 10580 SourceLocation StartLoc, 10581 SourceLocation EndLoc); 10582 using VarsWithInheritedDSAType = 10583 llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>; 10584 /// Called on well-formed '\#pragma omp simd' after parsing 10585 /// of the associated statement. 10586 StmtResult 10587 ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10588 SourceLocation StartLoc, SourceLocation EndLoc, 10589 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10590 /// Called on well-formed '#pragma omp tile' after parsing of its clauses and 10591 /// the associated statement. 10592 StmtResult ActOnOpenMPTileDirective(ArrayRef<OMPClause *> Clauses, 10593 Stmt *AStmt, SourceLocation StartLoc, 10594 SourceLocation EndLoc); 10595 /// Called on well-formed '#pragma omp unroll' after parsing of its clauses 10596 /// and the associated statement. 10597 StmtResult ActOnOpenMPUnrollDirective(ArrayRef<OMPClause *> Clauses, 10598 Stmt *AStmt, SourceLocation StartLoc, 10599 SourceLocation EndLoc); 10600 /// Called on well-formed '\#pragma omp for' after parsing 10601 /// of the associated statement. 10602 StmtResult 10603 ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10604 SourceLocation StartLoc, SourceLocation EndLoc, 10605 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10606 /// Called on well-formed '\#pragma omp for simd' after parsing 10607 /// of the associated statement. 10608 StmtResult 10609 ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10610 SourceLocation StartLoc, SourceLocation EndLoc, 10611 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10612 /// Called on well-formed '\#pragma omp sections' after parsing 10613 /// of the associated statement. 10614 StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses, 10615 Stmt *AStmt, SourceLocation StartLoc, 10616 SourceLocation EndLoc); 10617 /// Called on well-formed '\#pragma omp section' after parsing of the 10618 /// associated statement. 10619 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc, 10620 SourceLocation EndLoc); 10621 /// Called on well-formed '\#pragma omp single' after parsing of the 10622 /// associated statement. 10623 StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses, 10624 Stmt *AStmt, SourceLocation StartLoc, 10625 SourceLocation EndLoc); 10626 /// Called on well-formed '\#pragma omp master' after parsing of the 10627 /// associated statement. 10628 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc, 10629 SourceLocation EndLoc); 10630 /// Called on well-formed '\#pragma omp critical' after parsing of the 10631 /// associated statement. 10632 StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName, 10633 ArrayRef<OMPClause *> Clauses, 10634 Stmt *AStmt, SourceLocation StartLoc, 10635 SourceLocation EndLoc); 10636 /// Called on well-formed '\#pragma omp parallel for' after parsing 10637 /// of the associated statement. 10638 StmtResult ActOnOpenMPParallelForDirective( 10639 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10640 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10641 /// Called on well-formed '\#pragma omp parallel for simd' after 10642 /// parsing of the associated statement. 10643 StmtResult ActOnOpenMPParallelForSimdDirective( 10644 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10645 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10646 /// Called on well-formed '\#pragma omp parallel master' after 10647 /// parsing of the associated statement. 10648 StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses, 10649 Stmt *AStmt, 10650 SourceLocation StartLoc, 10651 SourceLocation EndLoc); 10652 /// Called on well-formed '\#pragma omp parallel sections' after 10653 /// parsing of the associated statement. 10654 StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses, 10655 Stmt *AStmt, 10656 SourceLocation StartLoc, 10657 SourceLocation EndLoc); 10658 /// Called on well-formed '\#pragma omp task' after parsing of the 10659 /// associated statement. 10660 StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses, 10661 Stmt *AStmt, SourceLocation StartLoc, 10662 SourceLocation EndLoc); 10663 /// Called on well-formed '\#pragma omp taskyield'. 10664 StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc, 10665 SourceLocation EndLoc); 10666 /// Called on well-formed '\#pragma omp barrier'. 10667 StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc, 10668 SourceLocation EndLoc); 10669 /// Called on well-formed '\#pragma omp taskwait'. 10670 StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc, 10671 SourceLocation EndLoc); 10672 /// Called on well-formed '\#pragma omp taskgroup'. 10673 StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses, 10674 Stmt *AStmt, SourceLocation StartLoc, 10675 SourceLocation EndLoc); 10676 /// Called on well-formed '\#pragma omp flush'. 10677 StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, 10678 SourceLocation StartLoc, 10679 SourceLocation EndLoc); 10680 /// Called on well-formed '\#pragma omp depobj'. 10681 StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses, 10682 SourceLocation StartLoc, 10683 SourceLocation EndLoc); 10684 /// Called on well-formed '\#pragma omp scan'. 10685 StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses, 10686 SourceLocation StartLoc, 10687 SourceLocation EndLoc); 10688 /// Called on well-formed '\#pragma omp ordered' after parsing of the 10689 /// associated statement. 10690 StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses, 10691 Stmt *AStmt, SourceLocation StartLoc, 10692 SourceLocation EndLoc); 10693 /// Called on well-formed '\#pragma omp atomic' after parsing of the 10694 /// associated statement. 10695 StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, 10696 Stmt *AStmt, SourceLocation StartLoc, 10697 SourceLocation EndLoc); 10698 /// Called on well-formed '\#pragma omp target' after parsing of the 10699 /// associated statement. 10700 StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses, 10701 Stmt *AStmt, SourceLocation StartLoc, 10702 SourceLocation EndLoc); 10703 /// Called on well-formed '\#pragma omp target data' after parsing of 10704 /// the associated statement. 10705 StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses, 10706 Stmt *AStmt, SourceLocation StartLoc, 10707 SourceLocation EndLoc); 10708 /// Called on well-formed '\#pragma omp target enter data' after 10709 /// parsing of the associated statement. 10710 StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses, 10711 SourceLocation StartLoc, 10712 SourceLocation EndLoc, 10713 Stmt *AStmt); 10714 /// Called on well-formed '\#pragma omp target exit data' after 10715 /// parsing of the associated statement. 10716 StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses, 10717 SourceLocation StartLoc, 10718 SourceLocation EndLoc, 10719 Stmt *AStmt); 10720 /// Called on well-formed '\#pragma omp target parallel' after 10721 /// parsing of the associated statement. 10722 StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses, 10723 Stmt *AStmt, 10724 SourceLocation StartLoc, 10725 SourceLocation EndLoc); 10726 /// Called on well-formed '\#pragma omp target parallel for' after 10727 /// parsing of the associated statement. 10728 StmtResult ActOnOpenMPTargetParallelForDirective( 10729 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10730 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10731 /// Called on well-formed '\#pragma omp teams' after parsing of the 10732 /// associated statement. 10733 StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses, 10734 Stmt *AStmt, SourceLocation StartLoc, 10735 SourceLocation EndLoc); 10736 /// Called on well-formed '\#pragma omp cancellation point'. 10737 StmtResult 10738 ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc, 10739 SourceLocation EndLoc, 10740 OpenMPDirectiveKind CancelRegion); 10741 /// Called on well-formed '\#pragma omp cancel'. 10742 StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses, 10743 SourceLocation StartLoc, 10744 SourceLocation EndLoc, 10745 OpenMPDirectiveKind CancelRegion); 10746 /// Called on well-formed '\#pragma omp taskloop' after parsing of the 10747 /// associated statement. 10748 StmtResult 10749 ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10750 SourceLocation StartLoc, SourceLocation EndLoc, 10751 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10752 /// Called on well-formed '\#pragma omp taskloop simd' after parsing of 10753 /// the associated statement. 10754 StmtResult ActOnOpenMPTaskLoopSimdDirective( 10755 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10756 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10757 /// Called on well-formed '\#pragma omp master taskloop' after parsing of the 10758 /// associated statement. 10759 StmtResult ActOnOpenMPMasterTaskLoopDirective( 10760 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10761 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10762 /// Called on well-formed '\#pragma omp master taskloop simd' after parsing of 10763 /// the associated statement. 10764 StmtResult ActOnOpenMPMasterTaskLoopSimdDirective( 10765 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10766 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10767 /// Called on well-formed '\#pragma omp parallel master taskloop' after 10768 /// parsing of the associated statement. 10769 StmtResult ActOnOpenMPParallelMasterTaskLoopDirective( 10770 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10771 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10772 /// Called on well-formed '\#pragma omp parallel master taskloop simd' after 10773 /// parsing of the associated statement. 10774 StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective( 10775 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10776 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10777 /// Called on well-formed '\#pragma omp distribute' after parsing 10778 /// of the associated statement. 10779 StmtResult 10780 ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10781 SourceLocation StartLoc, SourceLocation EndLoc, 10782 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10783 /// Called on well-formed '\#pragma omp target update'. 10784 StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses, 10785 SourceLocation StartLoc, 10786 SourceLocation EndLoc, 10787 Stmt *AStmt); 10788 /// Called on well-formed '\#pragma omp distribute parallel for' after 10789 /// parsing of the associated statement. 10790 StmtResult ActOnOpenMPDistributeParallelForDirective( 10791 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10792 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10793 /// Called on well-formed '\#pragma omp distribute parallel for simd' 10794 /// after parsing of the associated statement. 10795 StmtResult ActOnOpenMPDistributeParallelForSimdDirective( 10796 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10797 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10798 /// Called on well-formed '\#pragma omp distribute simd' after 10799 /// parsing of the associated statement. 10800 StmtResult ActOnOpenMPDistributeSimdDirective( 10801 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10802 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10803 /// Called on well-formed '\#pragma omp target parallel for simd' after 10804 /// parsing of the associated statement. 10805 StmtResult ActOnOpenMPTargetParallelForSimdDirective( 10806 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10807 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10808 /// Called on well-formed '\#pragma omp target simd' after parsing of 10809 /// the associated statement. 10810 StmtResult 10811 ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt, 10812 SourceLocation StartLoc, SourceLocation EndLoc, 10813 VarsWithInheritedDSAType &VarsWithImplicitDSA); 10814 /// Called on well-formed '\#pragma omp teams distribute' after parsing of 10815 /// the associated statement. 10816 StmtResult ActOnOpenMPTeamsDistributeDirective( 10817 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10818 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10819 /// Called on well-formed '\#pragma omp teams distribute simd' after parsing 10820 /// of the associated statement. 10821 StmtResult ActOnOpenMPTeamsDistributeSimdDirective( 10822 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10823 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10824 /// Called on well-formed '\#pragma omp teams distribute parallel for simd' 10825 /// after parsing of the associated statement. 10826 StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective( 10827 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10828 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10829 /// Called on well-formed '\#pragma omp teams distribute parallel for' 10830 /// after parsing of the associated statement. 10831 StmtResult ActOnOpenMPTeamsDistributeParallelForDirective( 10832 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10833 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10834 /// Called on well-formed '\#pragma omp target teams' after parsing of the 10835 /// associated statement. 10836 StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses, 10837 Stmt *AStmt, 10838 SourceLocation StartLoc, 10839 SourceLocation EndLoc); 10840 /// Called on well-formed '\#pragma omp target teams distribute' after parsing 10841 /// of the associated statement. 10842 StmtResult ActOnOpenMPTargetTeamsDistributeDirective( 10843 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10844 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10845 /// Called on well-formed '\#pragma omp target teams distribute parallel for' 10846 /// after parsing of the associated statement. 10847 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective( 10848 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10849 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10850 /// Called on well-formed '\#pragma omp target teams distribute parallel for 10851 /// simd' after parsing of the associated statement. 10852 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective( 10853 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10854 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10855 /// Called on well-formed '\#pragma omp target teams distribute simd' after 10856 /// parsing of the associated statement. 10857 StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective( 10858 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 10859 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); 10860 /// Called on well-formed '\#pragma omp interop'. 10861 StmtResult ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses, 10862 SourceLocation StartLoc, 10863 SourceLocation EndLoc); 10864 /// Called on well-formed '\#pragma omp dispatch' after parsing of the 10865 // /associated statement. 10866 StmtResult ActOnOpenMPDispatchDirective(ArrayRef<OMPClause *> Clauses, 10867 Stmt *AStmt, SourceLocation StartLoc, 10868 SourceLocation EndLoc); 10869 /// Called on well-formed '\#pragma omp masked' after parsing of the 10870 // /associated statement. 10871 StmtResult ActOnOpenMPMaskedDirective(ArrayRef<OMPClause *> Clauses, 10872 Stmt *AStmt, SourceLocation StartLoc, 10873 SourceLocation EndLoc); 10874 10875 /// Checks correctness of linear modifiers. 10876 bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind, 10877 SourceLocation LinLoc); 10878 /// Checks that the specified declaration matches requirements for the linear 10879 /// decls. 10880 bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc, 10881 OpenMPLinearClauseKind LinKind, QualType Type, 10882 bool IsDeclareSimd = false); 10883 10884 /// Called on well-formed '\#pragma omp declare simd' after parsing of 10885 /// the associated method/function. 10886 DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective( 10887 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, 10888 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, 10889 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, 10890 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR); 10891 10892 /// Checks '\#pragma omp declare variant' variant function and original 10893 /// functions after parsing of the associated method/function. 10894 /// \param DG Function declaration to which declare variant directive is 10895 /// applied to. 10896 /// \param VariantRef Expression that references the variant function, which 10897 /// must be used instead of the original one, specified in \p DG. 10898 /// \param TI The trait info object representing the match clause. 10899 /// \returns None, if the function/variant function are not compatible with 10900 /// the pragma, pair of original function/variant ref expression otherwise. 10901 Optional<std::pair<FunctionDecl *, Expr *>> 10902 checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef, 10903 OMPTraitInfo &TI, SourceRange SR); 10904 10905 /// Called on well-formed '\#pragma omp declare variant' after parsing of 10906 /// the associated method/function. 10907 /// \param FD Function declaration to which declare variant directive is 10908 /// applied to. 10909 /// \param VariantRef Expression that references the variant function, which 10910 /// must be used instead of the original one, specified in \p DG. 10911 /// \param TI The context traits associated with the function variant. 10912 void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef, 10913 OMPTraitInfo &TI, SourceRange SR); 10914 10915 OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, 10916 Expr *Expr, 10917 SourceLocation StartLoc, 10918 SourceLocation LParenLoc, 10919 SourceLocation EndLoc); 10920 /// Called on well-formed 'allocator' clause. 10921 OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator, 10922 SourceLocation StartLoc, 10923 SourceLocation LParenLoc, 10924 SourceLocation EndLoc); 10925 /// Called on well-formed 'if' clause. 10926 OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier, 10927 Expr *Condition, SourceLocation StartLoc, 10928 SourceLocation LParenLoc, 10929 SourceLocation NameModifierLoc, 10930 SourceLocation ColonLoc, 10931 SourceLocation EndLoc); 10932 /// Called on well-formed 'final' clause. 10933 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc, 10934 SourceLocation LParenLoc, 10935 SourceLocation EndLoc); 10936 /// Called on well-formed 'num_threads' clause. 10937 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads, 10938 SourceLocation StartLoc, 10939 SourceLocation LParenLoc, 10940 SourceLocation EndLoc); 10941 /// Called on well-formed 'safelen' clause. 10942 OMPClause *ActOnOpenMPSafelenClause(Expr *Length, 10943 SourceLocation StartLoc, 10944 SourceLocation LParenLoc, 10945 SourceLocation EndLoc); 10946 /// Called on well-formed 'simdlen' clause. 10947 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc, 10948 SourceLocation LParenLoc, 10949 SourceLocation EndLoc); 10950 /// Called on well-form 'sizes' clause. 10951 OMPClause *ActOnOpenMPSizesClause(ArrayRef<Expr *> SizeExprs, 10952 SourceLocation StartLoc, 10953 SourceLocation LParenLoc, 10954 SourceLocation EndLoc); 10955 /// Called on well-form 'full' clauses. 10956 OMPClause *ActOnOpenMPFullClause(SourceLocation StartLoc, 10957 SourceLocation EndLoc); 10958 /// Called on well-form 'partial' clauses. 10959 OMPClause *ActOnOpenMPPartialClause(Expr *FactorExpr, SourceLocation StartLoc, 10960 SourceLocation LParenLoc, 10961 SourceLocation EndLoc); 10962 /// Called on well-formed 'collapse' clause. 10963 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops, 10964 SourceLocation StartLoc, 10965 SourceLocation LParenLoc, 10966 SourceLocation EndLoc); 10967 /// Called on well-formed 'ordered' clause. 10968 OMPClause * 10969 ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc, 10970 SourceLocation LParenLoc = SourceLocation(), 10971 Expr *NumForLoops = nullptr); 10972 /// Called on well-formed 'grainsize' clause. 10973 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc, 10974 SourceLocation LParenLoc, 10975 SourceLocation EndLoc); 10976 /// Called on well-formed 'num_tasks' clause. 10977 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc, 10978 SourceLocation LParenLoc, 10979 SourceLocation EndLoc); 10980 /// Called on well-formed 'hint' clause. 10981 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc, 10982 SourceLocation LParenLoc, 10983 SourceLocation EndLoc); 10984 /// Called on well-formed 'detach' clause. 10985 OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc, 10986 SourceLocation LParenLoc, 10987 SourceLocation EndLoc); 10988 10989 OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind, 10990 unsigned Argument, 10991 SourceLocation ArgumentLoc, 10992 SourceLocation StartLoc, 10993 SourceLocation LParenLoc, 10994 SourceLocation EndLoc); 10995 /// Called on well-formed 'default' clause. 10996 OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind, 10997 SourceLocation KindLoc, 10998 SourceLocation StartLoc, 10999 SourceLocation LParenLoc, 11000 SourceLocation EndLoc); 11001 /// Called on well-formed 'proc_bind' clause. 11002 OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind, 11003 SourceLocation KindLoc, 11004 SourceLocation StartLoc, 11005 SourceLocation LParenLoc, 11006 SourceLocation EndLoc); 11007 /// Called on well-formed 'order' clause. 11008 OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind, 11009 SourceLocation KindLoc, 11010 SourceLocation StartLoc, 11011 SourceLocation LParenLoc, 11012 SourceLocation EndLoc); 11013 /// Called on well-formed 'update' clause. 11014 OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind, 11015 SourceLocation KindLoc, 11016 SourceLocation StartLoc, 11017 SourceLocation LParenLoc, 11018 SourceLocation EndLoc); 11019 11020 OMPClause *ActOnOpenMPSingleExprWithArgClause( 11021 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr, 11022 SourceLocation StartLoc, SourceLocation LParenLoc, 11023 ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc, 11024 SourceLocation EndLoc); 11025 /// Called on well-formed 'schedule' clause. 11026 OMPClause *ActOnOpenMPScheduleClause( 11027 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2, 11028 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, 11029 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc, 11030 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc); 11031 11032 OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc, 11033 SourceLocation EndLoc); 11034 /// Called on well-formed 'nowait' clause. 11035 OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc, 11036 SourceLocation EndLoc); 11037 /// Called on well-formed 'untied' clause. 11038 OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc, 11039 SourceLocation EndLoc); 11040 /// Called on well-formed 'mergeable' clause. 11041 OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc, 11042 SourceLocation EndLoc); 11043 /// Called on well-formed 'read' clause. 11044 OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc, 11045 SourceLocation EndLoc); 11046 /// Called on well-formed 'write' clause. 11047 OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc, 11048 SourceLocation EndLoc); 11049 /// Called on well-formed 'update' clause. 11050 OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc, 11051 SourceLocation EndLoc); 11052 /// Called on well-formed 'capture' clause. 11053 OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc, 11054 SourceLocation EndLoc); 11055 /// Called on well-formed 'seq_cst' clause. 11056 OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc, 11057 SourceLocation EndLoc); 11058 /// Called on well-formed 'acq_rel' clause. 11059 OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc, 11060 SourceLocation EndLoc); 11061 /// Called on well-formed 'acquire' clause. 11062 OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc, 11063 SourceLocation EndLoc); 11064 /// Called on well-formed 'release' clause. 11065 OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc, 11066 SourceLocation EndLoc); 11067 /// Called on well-formed 'relaxed' clause. 11068 OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc, 11069 SourceLocation EndLoc); 11070 11071 /// Called on well-formed 'init' clause. 11072 OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs, 11073 bool IsTarget, bool IsTargetSync, 11074 SourceLocation StartLoc, 11075 SourceLocation LParenLoc, 11076 SourceLocation VarLoc, 11077 SourceLocation EndLoc); 11078 11079 /// Called on well-formed 'use' clause. 11080 OMPClause *ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc, 11081 SourceLocation LParenLoc, 11082 SourceLocation VarLoc, SourceLocation EndLoc); 11083 11084 /// Called on well-formed 'destroy' clause. 11085 OMPClause *ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc, 11086 SourceLocation LParenLoc, 11087 SourceLocation VarLoc, 11088 SourceLocation EndLoc); 11089 /// Called on well-formed 'novariants' clause. 11090 OMPClause *ActOnOpenMPNovariantsClause(Expr *Condition, 11091 SourceLocation StartLoc, 11092 SourceLocation LParenLoc, 11093 SourceLocation EndLoc); 11094 /// Called on well-formed 'nocontext' clause. 11095 OMPClause *ActOnOpenMPNocontextClause(Expr *Condition, 11096 SourceLocation StartLoc, 11097 SourceLocation LParenLoc, 11098 SourceLocation EndLoc); 11099 /// Called on well-formed 'filter' clause. 11100 OMPClause *ActOnOpenMPFilterClause(Expr *ThreadID, SourceLocation StartLoc, 11101 SourceLocation LParenLoc, 11102 SourceLocation EndLoc); 11103 /// Called on well-formed 'threads' clause. 11104 OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc, 11105 SourceLocation EndLoc); 11106 /// Called on well-formed 'simd' clause. 11107 OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc, 11108 SourceLocation EndLoc); 11109 /// Called on well-formed 'nogroup' clause. 11110 OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc, 11111 SourceLocation EndLoc); 11112 /// Called on well-formed 'unified_address' clause. 11113 OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc, 11114 SourceLocation EndLoc); 11115 11116 /// Called on well-formed 'unified_address' clause. 11117 OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc, 11118 SourceLocation EndLoc); 11119 11120 /// Called on well-formed 'reverse_offload' clause. 11121 OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc, 11122 SourceLocation EndLoc); 11123 11124 /// Called on well-formed 'dynamic_allocators' clause. 11125 OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc, 11126 SourceLocation EndLoc); 11127 11128 /// Called on well-formed 'atomic_default_mem_order' clause. 11129 OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause( 11130 OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc, 11131 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc); 11132 11133 OMPClause *ActOnOpenMPVarListClause( 11134 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr, 11135 const OMPVarListLocTy &Locs, SourceLocation ColonLoc, 11136 CXXScopeSpec &ReductionOrMapperIdScopeSpec, 11137 DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier, 11138 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, 11139 ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit, 11140 SourceLocation ExtraModifierLoc, 11141 ArrayRef<OpenMPMotionModifierKind> MotionModifiers, 11142 ArrayRef<SourceLocation> MotionModifiersLoc); 11143 /// Called on well-formed 'inclusive' clause. 11144 OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList, 11145 SourceLocation StartLoc, 11146 SourceLocation LParenLoc, 11147 SourceLocation EndLoc); 11148 /// Called on well-formed 'exclusive' clause. 11149 OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList, 11150 SourceLocation StartLoc, 11151 SourceLocation LParenLoc, 11152 SourceLocation EndLoc); 11153 /// Called on well-formed 'allocate' clause. 11154 OMPClause * 11155 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList, 11156 SourceLocation StartLoc, SourceLocation ColonLoc, 11157 SourceLocation LParenLoc, SourceLocation EndLoc); 11158 /// Called on well-formed 'private' clause. 11159 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList, 11160 SourceLocation StartLoc, 11161 SourceLocation LParenLoc, 11162 SourceLocation EndLoc); 11163 /// Called on well-formed 'firstprivate' clause. 11164 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList, 11165 SourceLocation StartLoc, 11166 SourceLocation LParenLoc, 11167 SourceLocation EndLoc); 11168 /// Called on well-formed 'lastprivate' clause. 11169 OMPClause *ActOnOpenMPLastprivateClause( 11170 ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind, 11171 SourceLocation LPKindLoc, SourceLocation ColonLoc, 11172 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc); 11173 /// Called on well-formed 'shared' clause. 11174 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList, 11175 SourceLocation StartLoc, 11176 SourceLocation LParenLoc, 11177 SourceLocation EndLoc); 11178 /// Called on well-formed 'reduction' clause. 11179 OMPClause *ActOnOpenMPReductionClause( 11180 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier, 11181 SourceLocation StartLoc, SourceLocation LParenLoc, 11182 SourceLocation ModifierLoc, SourceLocation ColonLoc, 11183 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, 11184 const DeclarationNameInfo &ReductionId, 11185 ArrayRef<Expr *> UnresolvedReductions = llvm::None); 11186 /// Called on well-formed 'task_reduction' clause. 11187 OMPClause *ActOnOpenMPTaskReductionClause( 11188 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11189 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, 11190 CXXScopeSpec &ReductionIdScopeSpec, 11191 const DeclarationNameInfo &ReductionId, 11192 ArrayRef<Expr *> UnresolvedReductions = llvm::None); 11193 /// Called on well-formed 'in_reduction' clause. 11194 OMPClause *ActOnOpenMPInReductionClause( 11195 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11196 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, 11197 CXXScopeSpec &ReductionIdScopeSpec, 11198 const DeclarationNameInfo &ReductionId, 11199 ArrayRef<Expr *> UnresolvedReductions = llvm::None); 11200 /// Called on well-formed 'linear' clause. 11201 OMPClause * 11202 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step, 11203 SourceLocation StartLoc, SourceLocation LParenLoc, 11204 OpenMPLinearClauseKind LinKind, SourceLocation LinLoc, 11205 SourceLocation ColonLoc, SourceLocation EndLoc); 11206 /// Called on well-formed 'aligned' clause. 11207 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList, 11208 Expr *Alignment, 11209 SourceLocation StartLoc, 11210 SourceLocation LParenLoc, 11211 SourceLocation ColonLoc, 11212 SourceLocation EndLoc); 11213 /// Called on well-formed 'copyin' clause. 11214 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList, 11215 SourceLocation StartLoc, 11216 SourceLocation LParenLoc, 11217 SourceLocation EndLoc); 11218 /// Called on well-formed 'copyprivate' clause. 11219 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList, 11220 SourceLocation StartLoc, 11221 SourceLocation LParenLoc, 11222 SourceLocation EndLoc); 11223 /// Called on well-formed 'flush' pseudo clause. 11224 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList, 11225 SourceLocation StartLoc, 11226 SourceLocation LParenLoc, 11227 SourceLocation EndLoc); 11228 /// Called on well-formed 'depobj' pseudo clause. 11229 OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc, 11230 SourceLocation LParenLoc, 11231 SourceLocation EndLoc); 11232 /// Called on well-formed 'depend' clause. 11233 OMPClause * 11234 ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind, 11235 SourceLocation DepLoc, SourceLocation ColonLoc, 11236 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11237 SourceLocation LParenLoc, SourceLocation EndLoc); 11238 /// Called on well-formed 'device' clause. 11239 OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier, 11240 Expr *Device, SourceLocation StartLoc, 11241 SourceLocation LParenLoc, 11242 SourceLocation ModifierLoc, 11243 SourceLocation EndLoc); 11244 /// Called on well-formed 'map' clause. 11245 OMPClause * 11246 ActOnOpenMPMapClause(ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, 11247 ArrayRef<SourceLocation> MapTypeModifiersLoc, 11248 CXXScopeSpec &MapperIdScopeSpec, 11249 DeclarationNameInfo &MapperId, 11250 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, 11251 SourceLocation MapLoc, SourceLocation ColonLoc, 11252 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, 11253 ArrayRef<Expr *> UnresolvedMappers = llvm::None); 11254 /// Called on well-formed 'num_teams' clause. 11255 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc, 11256 SourceLocation LParenLoc, 11257 SourceLocation EndLoc); 11258 /// Called on well-formed 'thread_limit' clause. 11259 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit, 11260 SourceLocation StartLoc, 11261 SourceLocation LParenLoc, 11262 SourceLocation EndLoc); 11263 /// Called on well-formed 'priority' clause. 11264 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc, 11265 SourceLocation LParenLoc, 11266 SourceLocation EndLoc); 11267 /// Called on well-formed 'dist_schedule' clause. 11268 OMPClause *ActOnOpenMPDistScheduleClause( 11269 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, 11270 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc, 11271 SourceLocation CommaLoc, SourceLocation EndLoc); 11272 /// Called on well-formed 'defaultmap' clause. 11273 OMPClause *ActOnOpenMPDefaultmapClause( 11274 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind, 11275 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc, 11276 SourceLocation KindLoc, SourceLocation EndLoc); 11277 /// Called on well-formed 'to' clause. 11278 OMPClause * 11279 ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers, 11280 ArrayRef<SourceLocation> MotionModifiersLoc, 11281 CXXScopeSpec &MapperIdScopeSpec, 11282 DeclarationNameInfo &MapperId, SourceLocation ColonLoc, 11283 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, 11284 ArrayRef<Expr *> UnresolvedMappers = llvm::None); 11285 /// Called on well-formed 'from' clause. 11286 OMPClause * 11287 ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers, 11288 ArrayRef<SourceLocation> MotionModifiersLoc, 11289 CXXScopeSpec &MapperIdScopeSpec, 11290 DeclarationNameInfo &MapperId, SourceLocation ColonLoc, 11291 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, 11292 ArrayRef<Expr *> UnresolvedMappers = llvm::None); 11293 /// Called on well-formed 'use_device_ptr' clause. 11294 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList, 11295 const OMPVarListLocTy &Locs); 11296 /// Called on well-formed 'use_device_addr' clause. 11297 OMPClause *ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr *> VarList, 11298 const OMPVarListLocTy &Locs); 11299 /// Called on well-formed 'is_device_ptr' clause. 11300 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList, 11301 const OMPVarListLocTy &Locs); 11302 /// Called on well-formed 'nontemporal' clause. 11303 OMPClause *ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList, 11304 SourceLocation StartLoc, 11305 SourceLocation LParenLoc, 11306 SourceLocation EndLoc); 11307 11308 /// Data for list of allocators. 11309 struct UsesAllocatorsData { 11310 /// Allocator. 11311 Expr *Allocator = nullptr; 11312 /// Allocator traits. 11313 Expr *AllocatorTraits = nullptr; 11314 /// Locations of '(' and ')' symbols. 11315 SourceLocation LParenLoc, RParenLoc; 11316 }; 11317 /// Called on well-formed 'uses_allocators' clause. 11318 OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc, 11319 SourceLocation LParenLoc, 11320 SourceLocation EndLoc, 11321 ArrayRef<UsesAllocatorsData> Data); 11322 /// Called on well-formed 'affinity' clause. 11323 OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc, 11324 SourceLocation LParenLoc, 11325 SourceLocation ColonLoc, 11326 SourceLocation EndLoc, Expr *Modifier, 11327 ArrayRef<Expr *> Locators); 11328 11329 /// The kind of conversion being performed. 11330 enum CheckedConversionKind { 11331 /// An implicit conversion. 11332 CCK_ImplicitConversion, 11333 /// A C-style cast. 11334 CCK_CStyleCast, 11335 /// A functional-style cast. 11336 CCK_FunctionalCast, 11337 /// A cast other than a C-style cast. 11338 CCK_OtherCast, 11339 /// A conversion for an operand of a builtin overloaded operator. 11340 CCK_ForBuiltinOverloadedOp 11341 }; 11342 11343 static bool isCast(CheckedConversionKind CCK) { 11344 return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast || 11345 CCK == CCK_OtherCast; 11346 } 11347 11348 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit 11349 /// cast. If there is already an implicit cast, merge into the existing one. 11350 /// If isLvalue, the result of the cast is an lvalue. 11351 ExprResult 11352 ImpCastExprToType(Expr *E, QualType Type, CastKind CK, 11353 ExprValueKind VK = VK_PRValue, 11354 const CXXCastPath *BasePath = nullptr, 11355 CheckedConversionKind CCK = CCK_ImplicitConversion); 11356 11357 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding 11358 /// to the conversion from scalar type ScalarTy to the Boolean type. 11359 static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy); 11360 11361 /// IgnoredValueConversions - Given that an expression's result is 11362 /// syntactically ignored, perform any conversions that are 11363 /// required. 11364 ExprResult IgnoredValueConversions(Expr *E); 11365 11366 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts 11367 // functions and arrays to their respective pointers (C99 6.3.2.1). 11368 ExprResult UsualUnaryConversions(Expr *E); 11369 11370 /// CallExprUnaryConversions - a special case of an unary conversion 11371 /// performed on a function designator of a call expression. 11372 ExprResult CallExprUnaryConversions(Expr *E); 11373 11374 // DefaultFunctionArrayConversion - converts functions and arrays 11375 // to their respective pointers (C99 6.3.2.1). 11376 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true); 11377 11378 // DefaultFunctionArrayLvalueConversion - converts functions and 11379 // arrays to their respective pointers and performs the 11380 // lvalue-to-rvalue conversion. 11381 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, 11382 bool Diagnose = true); 11383 11384 // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on 11385 // the operand. This function is a no-op if the operand has a function type 11386 // or an array type. 11387 ExprResult DefaultLvalueConversion(Expr *E); 11388 11389 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 11390 // do not have a prototype. Integer promotions are performed on each 11391 // argument, and arguments that have type float are promoted to double. 11392 ExprResult DefaultArgumentPromotion(Expr *E); 11393 11394 /// If \p E is a prvalue denoting an unmaterialized temporary, materialize 11395 /// it as an xvalue. In C++98, the result will still be a prvalue, because 11396 /// we don't have xvalues there. 11397 ExprResult TemporaryMaterializationConversion(Expr *E); 11398 11399 // Used for emitting the right warning by DefaultVariadicArgumentPromotion 11400 enum VariadicCallType { 11401 VariadicFunction, 11402 VariadicBlock, 11403 VariadicMethod, 11404 VariadicConstructor, 11405 VariadicDoesNotApply 11406 }; 11407 11408 VariadicCallType getVariadicCallType(FunctionDecl *FDecl, 11409 const FunctionProtoType *Proto, 11410 Expr *Fn); 11411 11412 // Used for determining in which context a type is allowed to be passed to a 11413 // vararg function. 11414 enum VarArgKind { 11415 VAK_Valid, 11416 VAK_ValidInCXX11, 11417 VAK_Undefined, 11418 VAK_MSVCUndefined, 11419 VAK_Invalid 11420 }; 11421 11422 // Determines which VarArgKind fits an expression. 11423 VarArgKind isValidVarArgType(const QualType &Ty); 11424 11425 /// Check to see if the given expression is a valid argument to a variadic 11426 /// function, issuing a diagnostic if not. 11427 void checkVariadicArgument(const Expr *E, VariadicCallType CT); 11428 11429 /// Check whether the given statement can have musttail applied to it, 11430 /// issuing a diagnostic and returning false if not. In the success case, 11431 /// the statement is rewritten to remove implicit nodes from the return 11432 /// value. 11433 bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA); 11434 11435 private: 11436 /// Check whether the given statement can have musttail applied to it, 11437 /// issuing a diagnostic and returning false if not. 11438 bool checkMustTailAttr(const Stmt *St, const Attr &MTA); 11439 11440 public: 11441 /// Check to see if a given expression could have '.c_str()' called on it. 11442 bool hasCStrMethod(const Expr *E); 11443 11444 /// GatherArgumentsForCall - Collector argument expressions for various 11445 /// form of call prototypes. 11446 bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, 11447 const FunctionProtoType *Proto, 11448 unsigned FirstParam, ArrayRef<Expr *> Args, 11449 SmallVectorImpl<Expr *> &AllArgs, 11450 VariadicCallType CallType = VariadicDoesNotApply, 11451 bool AllowExplicit = false, 11452 bool IsListInitialization = false); 11453 11454 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 11455 // will create a runtime trap if the resulting type is not a POD type. 11456 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 11457 FunctionDecl *FDecl); 11458 11459 /// Context in which we're performing a usual arithmetic conversion. 11460 enum ArithConvKind { 11461 /// An arithmetic operation. 11462 ACK_Arithmetic, 11463 /// A bitwise operation. 11464 ACK_BitwiseOp, 11465 /// A comparison. 11466 ACK_Comparison, 11467 /// A conditional (?:) operator. 11468 ACK_Conditional, 11469 /// A compound assignment expression. 11470 ACK_CompAssign, 11471 }; 11472 11473 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's 11474 // operands and then handles various conversions that are common to binary 11475 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this 11476 // routine returns the first non-arithmetic type found. The client is 11477 // responsible for emitting appropriate error diagnostics. 11478 QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 11479 SourceLocation Loc, ArithConvKind ACK); 11480 11481 /// AssignConvertType - All of the 'assignment' semantic checks return this 11482 /// enum to indicate whether the assignment was allowed. These checks are 11483 /// done for simple assignments, as well as initialization, return from 11484 /// function, argument passing, etc. The query is phrased in terms of a 11485 /// source and destination type. 11486 enum AssignConvertType { 11487 /// Compatible - the types are compatible according to the standard. 11488 Compatible, 11489 11490 /// PointerToInt - The assignment converts a pointer to an int, which we 11491 /// accept as an extension. 11492 PointerToInt, 11493 11494 /// IntToPointer - The assignment converts an int to a pointer, which we 11495 /// accept as an extension. 11496 IntToPointer, 11497 11498 /// FunctionVoidPointer - The assignment is between a function pointer and 11499 /// void*, which the standard doesn't allow, but we accept as an extension. 11500 FunctionVoidPointer, 11501 11502 /// IncompatiblePointer - The assignment is between two pointers types that 11503 /// are not compatible, but we accept them as an extension. 11504 IncompatiblePointer, 11505 11506 /// IncompatibleFunctionPointer - The assignment is between two function 11507 /// pointers types that are not compatible, but we accept them as an 11508 /// extension. 11509 IncompatibleFunctionPointer, 11510 11511 /// IncompatiblePointerSign - The assignment is between two pointers types 11512 /// which point to integers which have a different sign, but are otherwise 11513 /// identical. This is a subset of the above, but broken out because it's by 11514 /// far the most common case of incompatible pointers. 11515 IncompatiblePointerSign, 11516 11517 /// CompatiblePointerDiscardsQualifiers - The assignment discards 11518 /// c/v/r qualifiers, which we accept as an extension. 11519 CompatiblePointerDiscardsQualifiers, 11520 11521 /// IncompatiblePointerDiscardsQualifiers - The assignment 11522 /// discards qualifiers that we don't permit to be discarded, 11523 /// like address spaces. 11524 IncompatiblePointerDiscardsQualifiers, 11525 11526 /// IncompatibleNestedPointerAddressSpaceMismatch - The assignment 11527 /// changes address spaces in nested pointer types which is not allowed. 11528 /// For instance, converting __private int ** to __generic int ** is 11529 /// illegal even though __private could be converted to __generic. 11530 IncompatibleNestedPointerAddressSpaceMismatch, 11531 11532 /// IncompatibleNestedPointerQualifiers - The assignment is between two 11533 /// nested pointer types, and the qualifiers other than the first two 11534 /// levels differ e.g. char ** -> const char **, but we accept them as an 11535 /// extension. 11536 IncompatibleNestedPointerQualifiers, 11537 11538 /// IncompatibleVectors - The assignment is between two vector types that 11539 /// have the same size, which we accept as an extension. 11540 IncompatibleVectors, 11541 11542 /// IntToBlockPointer - The assignment converts an int to a block 11543 /// pointer. We disallow this. 11544 IntToBlockPointer, 11545 11546 /// IncompatibleBlockPointer - The assignment is between two block 11547 /// pointers types that are not compatible. 11548 IncompatibleBlockPointer, 11549 11550 /// IncompatibleObjCQualifiedId - The assignment is between a qualified 11551 /// id type and something else (that is incompatible with it). For example, 11552 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol. 11553 IncompatibleObjCQualifiedId, 11554 11555 /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an 11556 /// object with __weak qualifier. 11557 IncompatibleObjCWeakRef, 11558 11559 /// Incompatible - We reject this conversion outright, it is invalid to 11560 /// represent it in the AST. 11561 Incompatible 11562 }; 11563 11564 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the 11565 /// assignment conversion type specified by ConvTy. This returns true if the 11566 /// conversion was invalid or false if the conversion was accepted. 11567 bool DiagnoseAssignmentResult(AssignConvertType ConvTy, 11568 SourceLocation Loc, 11569 QualType DstType, QualType SrcType, 11570 Expr *SrcExpr, AssignmentAction Action, 11571 bool *Complained = nullptr); 11572 11573 /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag 11574 /// enum. If AllowMask is true, then we also allow the complement of a valid 11575 /// value, to be used as a mask. 11576 bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, 11577 bool AllowMask) const; 11578 11579 /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant 11580 /// integer not in the range of enum values. 11581 void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, 11582 Expr *SrcExpr); 11583 11584 /// CheckAssignmentConstraints - Perform type checking for assignment, 11585 /// argument passing, variable initialization, and function return values. 11586 /// C99 6.5.16. 11587 AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, 11588 QualType LHSType, 11589 QualType RHSType); 11590 11591 /// Check assignment constraints and optionally prepare for a conversion of 11592 /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS 11593 /// is true. 11594 AssignConvertType CheckAssignmentConstraints(QualType LHSType, 11595 ExprResult &RHS, 11596 CastKind &Kind, 11597 bool ConvertRHS = true); 11598 11599 /// Check assignment constraints for an assignment of RHS to LHSType. 11600 /// 11601 /// \param LHSType The destination type for the assignment. 11602 /// \param RHS The source expression for the assignment. 11603 /// \param Diagnose If \c true, diagnostics may be produced when checking 11604 /// for assignability. If a diagnostic is produced, \p RHS will be 11605 /// set to ExprError(). Note that this function may still return 11606 /// without producing a diagnostic, even for an invalid assignment. 11607 /// \param DiagnoseCFAudited If \c true, the target is a function parameter 11608 /// in an audited Core Foundation API and does not need to be checked 11609 /// for ARC retain issues. 11610 /// \param ConvertRHS If \c true, \p RHS will be updated to model the 11611 /// conversions necessary to perform the assignment. If \c false, 11612 /// \p Diagnose must also be \c false. 11613 AssignConvertType CheckSingleAssignmentConstraints( 11614 QualType LHSType, ExprResult &RHS, bool Diagnose = true, 11615 bool DiagnoseCFAudited = false, bool ConvertRHS = true); 11616 11617 // If the lhs type is a transparent union, check whether we 11618 // can initialize the transparent union with the given expression. 11619 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, 11620 ExprResult &RHS); 11621 11622 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType); 11623 11624 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType); 11625 11626 ExprResult PerformImplicitConversion(Expr *From, QualType ToType, 11627 AssignmentAction Action, 11628 bool AllowExplicit = false); 11629 ExprResult PerformImplicitConversion(Expr *From, QualType ToType, 11630 const ImplicitConversionSequence& ICS, 11631 AssignmentAction Action, 11632 CheckedConversionKind CCK 11633 = CCK_ImplicitConversion); 11634 ExprResult PerformImplicitConversion(Expr *From, QualType ToType, 11635 const StandardConversionSequence& SCS, 11636 AssignmentAction Action, 11637 CheckedConversionKind CCK); 11638 11639 ExprResult PerformQualificationConversion( 11640 Expr *E, QualType Ty, ExprValueKind VK = VK_PRValue, 11641 CheckedConversionKind CCK = CCK_ImplicitConversion); 11642 11643 /// the following "Check" methods will return a valid/converted QualType 11644 /// or a null QualType (indicating an error diagnostic was issued). 11645 11646 /// type checking binary operators (subroutines of CreateBuiltinBinOp). 11647 QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, 11648 ExprResult &RHS); 11649 QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS, 11650 ExprResult &RHS); 11651 QualType CheckPointerToMemberOperands( // C++ 5.5 11652 ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, 11653 SourceLocation OpLoc, bool isIndirect); 11654 QualType CheckMultiplyDivideOperands( // C99 6.5.5 11655 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, 11656 bool IsDivide); 11657 QualType CheckRemainderOperands( // C99 6.5.5 11658 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11659 bool IsCompAssign = false); 11660 QualType CheckAdditionOperands( // C99 6.5.6 11661 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11662 BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr); 11663 QualType CheckSubtractionOperands( // C99 6.5.6 11664 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11665 QualType* CompLHSTy = nullptr); 11666 QualType CheckShiftOperands( // C99 6.5.7 11667 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11668 BinaryOperatorKind Opc, bool IsCompAssign = false); 11669 void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE); 11670 QualType CheckCompareOperands( // C99 6.5.8/9 11671 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11672 BinaryOperatorKind Opc); 11673 QualType CheckBitwiseOperands( // C99 6.5.[10...12] 11674 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11675 BinaryOperatorKind Opc); 11676 QualType CheckLogicalOperands( // C99 6.5.[13,14] 11677 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, 11678 BinaryOperatorKind Opc); 11679 // CheckAssignmentOperands is used for both simple and compound assignment. 11680 // For simple assignment, pass both expressions and a null converted type. 11681 // For compound assignment, pass both expressions and the converted type. 11682 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2] 11683 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType); 11684 11685 ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc, 11686 UnaryOperatorKind Opcode, Expr *Op); 11687 ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc, 11688 BinaryOperatorKind Opcode, 11689 Expr *LHS, Expr *RHS); 11690 ExprResult checkPseudoObjectRValue(Expr *E); 11691 Expr *recreateSyntacticForm(PseudoObjectExpr *E); 11692 11693 QualType CheckConditionalOperands( // C99 6.5.15 11694 ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, 11695 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc); 11696 QualType CXXCheckConditionalOperands( // C++ 5.16 11697 ExprResult &cond, ExprResult &lhs, ExprResult &rhs, 11698 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc); 11699 QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, 11700 ExprResult &RHS, 11701 SourceLocation QuestionLoc); 11702 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, 11703 bool ConvertArgs = true); 11704 QualType FindCompositePointerType(SourceLocation Loc, 11705 ExprResult &E1, ExprResult &E2, 11706 bool ConvertArgs = true) { 11707 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get(); 11708 QualType Composite = 11709 FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs); 11710 E1 = E1Tmp; 11711 E2 = E2Tmp; 11712 return Composite; 11713 } 11714 11715 QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 11716 SourceLocation QuestionLoc); 11717 11718 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 11719 SourceLocation QuestionLoc); 11720 11721 void DiagnoseAlwaysNonNullPointer(Expr *E, 11722 Expr::NullPointerConstantKind NullType, 11723 bool IsEqual, SourceRange Range); 11724 11725 /// type checking for vector binary operators. 11726 QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 11727 SourceLocation Loc, bool IsCompAssign, 11728 bool AllowBothBool, bool AllowBoolConversion); 11729 QualType GetSignedVectorType(QualType V); 11730 QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 11731 SourceLocation Loc, 11732 BinaryOperatorKind Opc); 11733 QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 11734 SourceLocation Loc); 11735 11736 /// Type checking for matrix binary operators. 11737 QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS, 11738 SourceLocation Loc, 11739 bool IsCompAssign); 11740 QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS, 11741 SourceLocation Loc, bool IsCompAssign); 11742 11743 bool isValidSveBitcast(QualType srcType, QualType destType); 11744 11745 bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy); 11746 11747 bool areVectorTypesSameSize(QualType srcType, QualType destType); 11748 bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType); 11749 bool isLaxVectorConversion(QualType srcType, QualType destType); 11750 11751 /// type checking declaration initializers (C99 6.7.8) 11752 bool CheckForConstantInitializer(Expr *e, QualType t); 11753 11754 // type checking C++ declaration initializers (C++ [dcl.init]). 11755 11756 /// ReferenceCompareResult - Expresses the result of comparing two 11757 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the 11758 /// purposes of initialization by reference (C++ [dcl.init.ref]p4). 11759 enum ReferenceCompareResult { 11760 /// Ref_Incompatible - The two types are incompatible, so direct 11761 /// reference binding is not possible. 11762 Ref_Incompatible = 0, 11763 /// Ref_Related - The two types are reference-related, which means 11764 /// that their unqualified forms (T1 and T2) are either the same 11765 /// or T1 is a base class of T2. 11766 Ref_Related, 11767 /// Ref_Compatible - The two types are reference-compatible. 11768 Ref_Compatible 11769 }; 11770 11771 // Fake up a scoped enumeration that still contextually converts to bool. 11772 struct ReferenceConversionsScope { 11773 /// The conversions that would be performed on an lvalue of type T2 when 11774 /// binding a reference of type T1 to it, as determined when evaluating 11775 /// whether T1 is reference-compatible with T2. 11776 enum ReferenceConversions { 11777 Qualification = 0x1, 11778 NestedQualification = 0x2, 11779 Function = 0x4, 11780 DerivedToBase = 0x8, 11781 ObjC = 0x10, 11782 ObjCLifetime = 0x20, 11783 11784 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ObjCLifetime) 11785 }; 11786 }; 11787 using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions; 11788 11789 ReferenceCompareResult 11790 CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2, 11791 ReferenceConversions *Conv = nullptr); 11792 11793 ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, 11794 Expr *CastExpr, CastKind &CastKind, 11795 ExprValueKind &VK, CXXCastPath &Path); 11796 11797 /// Force an expression with unknown-type to an expression of the 11798 /// given type. 11799 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType); 11800 11801 /// Type-check an expression that's being passed to an 11802 /// __unknown_anytype parameter. 11803 ExprResult checkUnknownAnyArg(SourceLocation callLoc, 11804 Expr *result, QualType ¶mType); 11805 11806 // CheckMatrixCast - Check type constraints for matrix casts. 11807 // We allow casting between matrixes of the same dimensions i.e. when they 11808 // have the same number of rows and column. Returns true if the cast is 11809 // invalid. 11810 bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy, 11811 CastKind &Kind); 11812 11813 // CheckVectorCast - check type constraints for vectors. 11814 // Since vectors are an extension, there are no C standard reference for this. 11815 // We allow casting between vectors and integer datatypes of the same size. 11816 // returns true if the cast is invalid 11817 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 11818 CastKind &Kind); 11819 11820 /// Prepare `SplattedExpr` for a vector splat operation, adding 11821 /// implicit casts if necessary. 11822 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr); 11823 11824 // CheckExtVectorCast - check type constraints for extended vectors. 11825 // Since vectors are an extension, there are no C standard reference for this. 11826 // We allow casting between vectors and integer datatypes of the same size, 11827 // or vectors and the element type of that vector. 11828 // returns the cast expr 11829 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, 11830 CastKind &Kind); 11831 11832 ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type, 11833 SourceLocation LParenLoc, 11834 Expr *CastExpr, 11835 SourceLocation RParenLoc); 11836 11837 enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error }; 11838 11839 /// Checks for invalid conversions and casts between 11840 /// retainable pointers and other pointer kinds for ARC and Weak. 11841 ARCConversionResult CheckObjCConversion(SourceRange castRange, 11842 QualType castType, Expr *&op, 11843 CheckedConversionKind CCK, 11844 bool Diagnose = true, 11845 bool DiagnoseCFAudited = false, 11846 BinaryOperatorKind Opc = BO_PtrMemD 11847 ); 11848 11849 Expr *stripARCUnbridgedCast(Expr *e); 11850 void diagnoseARCUnbridgedCast(Expr *e); 11851 11852 bool CheckObjCARCUnavailableWeakConversion(QualType castType, 11853 QualType ExprType); 11854 11855 /// checkRetainCycles - Check whether an Objective-C message send 11856 /// might create an obvious retain cycle. 11857 void checkRetainCycles(ObjCMessageExpr *msg); 11858 void checkRetainCycles(Expr *receiver, Expr *argument); 11859 void checkRetainCycles(VarDecl *Var, Expr *Init); 11860 11861 /// checkUnsafeAssigns - Check whether +1 expr is being assigned 11862 /// to weak/__unsafe_unretained type. 11863 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS); 11864 11865 /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned 11866 /// to weak/__unsafe_unretained expression. 11867 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS); 11868 11869 /// CheckMessageArgumentTypes - Check types in an Obj-C message send. 11870 /// \param Method - May be null. 11871 /// \param [out] ReturnType - The return type of the send. 11872 /// \return true iff there were any incompatible types. 11873 bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType, 11874 MultiExprArg Args, Selector Sel, 11875 ArrayRef<SourceLocation> SelectorLocs, 11876 ObjCMethodDecl *Method, bool isClassMessage, 11877 bool isSuperMessage, SourceLocation lbrac, 11878 SourceLocation rbrac, SourceRange RecRange, 11879 QualType &ReturnType, ExprValueKind &VK); 11880 11881 /// Determine the result of a message send expression based on 11882 /// the type of the receiver, the method expected to receive the message, 11883 /// and the form of the message send. 11884 QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType, 11885 ObjCMethodDecl *Method, bool isClassMessage, 11886 bool isSuperMessage); 11887 11888 /// If the given expression involves a message send to a method 11889 /// with a related result type, emit a note describing what happened. 11890 void EmitRelatedResultTypeNote(const Expr *E); 11891 11892 /// Given that we had incompatible pointer types in a return 11893 /// statement, check whether we're in a method with a related result 11894 /// type, and if so, emit a note describing what happened. 11895 void EmitRelatedResultTypeNoteForReturn(QualType destType); 11896 11897 class ConditionResult { 11898 Decl *ConditionVar; 11899 FullExprArg Condition; 11900 bool Invalid; 11901 bool HasKnownValue; 11902 bool KnownValue; 11903 11904 friend class Sema; 11905 ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition, 11906 bool IsConstexpr) 11907 : ConditionVar(ConditionVar), Condition(Condition), Invalid(false), 11908 HasKnownValue(IsConstexpr && Condition.get() && 11909 !Condition.get()->isValueDependent()), 11910 KnownValue(HasKnownValue && 11911 !!Condition.get()->EvaluateKnownConstInt(S.Context)) {} 11912 explicit ConditionResult(bool Invalid) 11913 : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid), 11914 HasKnownValue(false), KnownValue(false) {} 11915 11916 public: 11917 ConditionResult() : ConditionResult(false) {} 11918 bool isInvalid() const { return Invalid; } 11919 std::pair<VarDecl *, Expr *> get() const { 11920 return std::make_pair(cast_or_null<VarDecl>(ConditionVar), 11921 Condition.get()); 11922 } 11923 llvm::Optional<bool> getKnownValue() const { 11924 if (!HasKnownValue) 11925 return None; 11926 return KnownValue; 11927 } 11928 }; 11929 static ConditionResult ConditionError() { return ConditionResult(true); } 11930 11931 enum class ConditionKind { 11932 Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'. 11933 ConstexprIf, ///< A constant boolean condition from 'if constexpr'. 11934 Switch ///< An integral condition for a 'switch' statement. 11935 }; 11936 11937 ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, 11938 Expr *SubExpr, ConditionKind CK); 11939 11940 ConditionResult ActOnConditionVariable(Decl *ConditionVar, 11941 SourceLocation StmtLoc, 11942 ConditionKind CK); 11943 11944 DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D); 11945 11946 ExprResult CheckConditionVariable(VarDecl *ConditionVar, 11947 SourceLocation StmtLoc, 11948 ConditionKind CK); 11949 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond); 11950 11951 /// CheckBooleanCondition - Diagnose problems involving the use of 11952 /// the given expression as a boolean condition (e.g. in an if 11953 /// statement). Also performs the standard function and array 11954 /// decays, possibly changing the input variable. 11955 /// 11956 /// \param Loc - A location associated with the condition, e.g. the 11957 /// 'if' keyword. 11958 /// \return true iff there were any errors 11959 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, 11960 bool IsConstexpr = false); 11961 11962 /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression 11963 /// found in an explicit(bool) specifier. 11964 ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E); 11965 11966 /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier. 11967 /// Returns true if the explicit specifier is now resolved. 11968 bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec); 11969 11970 /// DiagnoseAssignmentAsCondition - Given that an expression is 11971 /// being used as a boolean condition, warn if it's an assignment. 11972 void DiagnoseAssignmentAsCondition(Expr *E); 11973 11974 /// Redundant parentheses over an equality comparison can indicate 11975 /// that the user intended an assignment used as condition. 11976 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE); 11977 11978 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid. 11979 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false); 11980 11981 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have 11982 /// the specified width and sign. If an overflow occurs, detect it and emit 11983 /// the specified diagnostic. 11984 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal, 11985 unsigned NewWidth, bool NewSign, 11986 SourceLocation Loc, unsigned DiagID); 11987 11988 /// Checks that the Objective-C declaration is declared in the global scope. 11989 /// Emits an error and marks the declaration as invalid if it's not declared 11990 /// in the global scope. 11991 bool CheckObjCDeclScope(Decl *D); 11992 11993 /// Abstract base class used for diagnosing integer constant 11994 /// expression violations. 11995 class VerifyICEDiagnoser { 11996 public: 11997 bool Suppress; 11998 11999 VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { } 12000 12001 virtual SemaDiagnosticBuilder 12002 diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T); 12003 virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S, 12004 SourceLocation Loc) = 0; 12005 virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc); 12006 virtual ~VerifyICEDiagnoser() {} 12007 }; 12008 12009 enum AllowFoldKind { 12010 NoFold, 12011 AllowFold, 12012 }; 12013 12014 /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE, 12015 /// and reports the appropriate diagnostics. Returns false on success. 12016 /// Can optionally return the value of the expression. 12017 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 12018 VerifyICEDiagnoser &Diagnoser, 12019 AllowFoldKind CanFold = NoFold); 12020 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 12021 unsigned DiagID, 12022 AllowFoldKind CanFold = NoFold); 12023 ExprResult VerifyIntegerConstantExpression(Expr *E, 12024 llvm::APSInt *Result = nullptr, 12025 AllowFoldKind CanFold = NoFold); 12026 ExprResult VerifyIntegerConstantExpression(Expr *E, 12027 AllowFoldKind CanFold = NoFold) { 12028 return VerifyIntegerConstantExpression(E, nullptr, CanFold); 12029 } 12030 12031 /// VerifyBitField - verifies that a bit field expression is an ICE and has 12032 /// the correct width, and that the field type is valid. 12033 /// Returns false on success. 12034 /// Can optionally return whether the bit-field is of width 0 12035 ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, 12036 QualType FieldTy, bool IsMsStruct, 12037 Expr *BitWidth, bool *ZeroWidth = nullptr); 12038 12039 private: 12040 unsigned ForceCUDAHostDeviceDepth = 0; 12041 12042 public: 12043 /// Increments our count of the number of times we've seen a pragma forcing 12044 /// functions to be __host__ __device__. So long as this count is greater 12045 /// than zero, all functions encountered will be __host__ __device__. 12046 void PushForceCUDAHostDevice(); 12047 12048 /// Decrements our count of the number of times we've seen a pragma forcing 12049 /// functions to be __host__ __device__. Returns false if the count is 0 12050 /// before incrementing, so you can emit an error. 12051 bool PopForceCUDAHostDevice(); 12052 12053 /// Diagnostics that are emitted only if we discover that the given function 12054 /// must be codegen'ed. Because handling these correctly adds overhead to 12055 /// compilation, this is currently only enabled for CUDA compilations. 12056 llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>, 12057 std::vector<PartialDiagnosticAt>> 12058 DeviceDeferredDiags; 12059 12060 /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the 12061 /// key in a hashtable, both the FD and location are hashed. 12062 struct FunctionDeclAndLoc { 12063 CanonicalDeclPtr<FunctionDecl> FD; 12064 SourceLocation Loc; 12065 }; 12066 12067 /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a 12068 /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the 12069 /// same deferred diag twice. 12070 llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags; 12071 12072 /// An inverse call graph, mapping known-emitted functions to one of their 12073 /// known-emitted callers (plus the location of the call). 12074 /// 12075 /// Functions that we can tell a priori must be emitted aren't added to this 12076 /// map. 12077 llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>, 12078 /* Caller = */ FunctionDeclAndLoc> 12079 DeviceKnownEmittedFns; 12080 12081 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 12082 /// context is "used as device code". 12083 /// 12084 /// - If CurContext is a __host__ function, does not emit any diagnostics 12085 /// unless \p EmitOnBothSides is true. 12086 /// - If CurContext is a __device__ or __global__ function, emits the 12087 /// diagnostics immediately. 12088 /// - If CurContext is a __host__ __device__ function and we are compiling for 12089 /// the device, creates a diagnostic which is emitted if and when we realize 12090 /// that the function will be codegen'ed. 12091 /// 12092 /// Example usage: 12093 /// 12094 /// // Variable-length arrays are not allowed in CUDA device code. 12095 /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget()) 12096 /// return ExprError(); 12097 /// // Otherwise, continue parsing as normal. 12098 SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc, 12099 unsigned DiagID); 12100 12101 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 12102 /// context is "used as host code". 12103 /// 12104 /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched. 12105 SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID); 12106 12107 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 12108 /// context is "used as device code". 12109 /// 12110 /// - If CurContext is a `declare target` function or it is known that the 12111 /// function is emitted for the device, emits the diagnostics immediately. 12112 /// - If CurContext is a non-`declare target` function and we are compiling 12113 /// for the device, creates a diagnostic which is emitted if and when we 12114 /// realize that the function will be codegen'ed. 12115 /// 12116 /// Example usage: 12117 /// 12118 /// // Variable-length arrays are not allowed in NVPTX device code. 12119 /// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported)) 12120 /// return ExprError(); 12121 /// // Otherwise, continue parsing as normal. 12122 SemaDiagnosticBuilder 12123 diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD); 12124 12125 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 12126 /// context is "used as host code". 12127 /// 12128 /// - If CurContext is a `declare target` function or it is known that the 12129 /// function is emitted for the host, emits the diagnostics immediately. 12130 /// - If CurContext is a non-host function, just ignore it. 12131 /// 12132 /// Example usage: 12133 /// 12134 /// // Variable-length arrays are not allowed in NVPTX device code. 12135 /// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported)) 12136 /// return ExprError(); 12137 /// // Otherwise, continue parsing as normal. 12138 SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc, 12139 unsigned DiagID, FunctionDecl *FD); 12140 12141 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, 12142 FunctionDecl *FD = nullptr); 12143 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, 12144 const PartialDiagnostic &PD, 12145 FunctionDecl *FD = nullptr) { 12146 return targetDiag(Loc, PD.getDiagID(), FD) << PD; 12147 } 12148 12149 /// Check if the expression is allowed to be used in expressions for the 12150 /// offloading devices. 12151 void checkDeviceDecl(ValueDecl *D, SourceLocation Loc); 12152 12153 enum CUDAFunctionTarget { 12154 CFT_Device, 12155 CFT_Global, 12156 CFT_Host, 12157 CFT_HostDevice, 12158 CFT_InvalidTarget 12159 }; 12160 12161 /// Determines whether the given function is a CUDA device/host/kernel/etc. 12162 /// function. 12163 /// 12164 /// Use this rather than examining the function's attributes yourself -- you 12165 /// will get it wrong. Returns CFT_Host if D is null. 12166 CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, 12167 bool IgnoreImplicitHDAttr = false); 12168 CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs); 12169 12170 enum CUDAVariableTarget { 12171 CVT_Device, /// Emitted on device side with a shadow variable on host side 12172 CVT_Host, /// Emitted on host side only 12173 CVT_Both, /// Emitted on both sides with different addresses 12174 CVT_Unified, /// Emitted as a unified address, e.g. managed variables 12175 }; 12176 /// Determines whether the given variable is emitted on host or device side. 12177 CUDAVariableTarget IdentifyCUDATarget(const VarDecl *D); 12178 12179 /// Gets the CUDA target for the current context. 12180 CUDAFunctionTarget CurrentCUDATarget() { 12181 return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext)); 12182 } 12183 12184 static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D); 12185 12186 // CUDA function call preference. Must be ordered numerically from 12187 // worst to best. 12188 enum CUDAFunctionPreference { 12189 CFP_Never, // Invalid caller/callee combination. 12190 CFP_WrongSide, // Calls from host-device to host or device 12191 // function that do not match current compilation 12192 // mode. 12193 CFP_HostDevice, // Any calls to host/device functions. 12194 CFP_SameSide, // Calls from host-device to host or device 12195 // function matching current compilation mode. 12196 CFP_Native, // host-to-host or device-to-device calls. 12197 }; 12198 12199 /// Identifies relative preference of a given Caller/Callee 12200 /// combination, based on their host/device attributes. 12201 /// \param Caller function which needs address of \p Callee. 12202 /// nullptr in case of global context. 12203 /// \param Callee target function 12204 /// 12205 /// \returns preference value for particular Caller/Callee combination. 12206 CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller, 12207 const FunctionDecl *Callee); 12208 12209 /// Determines whether Caller may invoke Callee, based on their CUDA 12210 /// host/device attributes. Returns false if the call is not allowed. 12211 /// 12212 /// Note: Will return true for CFP_WrongSide calls. These may appear in 12213 /// semantically correct CUDA programs, but only if they're never codegen'ed. 12214 bool IsAllowedCUDACall(const FunctionDecl *Caller, 12215 const FunctionDecl *Callee) { 12216 return IdentifyCUDAPreference(Caller, Callee) != CFP_Never; 12217 } 12218 12219 /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, 12220 /// depending on FD and the current compilation settings. 12221 void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD, 12222 const LookupResult &Previous); 12223 12224 /// May add implicit CUDAConstantAttr attribute to VD, depending on VD 12225 /// and current compilation settings. 12226 void MaybeAddCUDAConstantAttr(VarDecl *VD); 12227 12228 public: 12229 /// Check whether we're allowed to call Callee from the current context. 12230 /// 12231 /// - If the call is never allowed in a semantically-correct program 12232 /// (CFP_Never), emits an error and returns false. 12233 /// 12234 /// - If the call is allowed in semantically-correct programs, but only if 12235 /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to 12236 /// be emitted if and when the caller is codegen'ed, and returns true. 12237 /// 12238 /// Will only create deferred diagnostics for a given SourceLocation once, 12239 /// so you can safely call this multiple times without generating duplicate 12240 /// deferred errors. 12241 /// 12242 /// - Otherwise, returns true without emitting any diagnostics. 12243 bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee); 12244 12245 void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture); 12246 12247 /// Set __device__ or __host__ __device__ attributes on the given lambda 12248 /// operator() method. 12249 /// 12250 /// CUDA lambdas by default is host device function unless it has explicit 12251 /// host or device attribute. 12252 void CUDASetLambdaAttrs(CXXMethodDecl *Method); 12253 12254 /// Finds a function in \p Matches with highest calling priority 12255 /// from \p Caller context and erases all functions with lower 12256 /// calling priority. 12257 void EraseUnwantedCUDAMatches( 12258 const FunctionDecl *Caller, 12259 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches); 12260 12261 /// Given a implicit special member, infer its CUDA target from the 12262 /// calls it needs to make to underlying base/field special members. 12263 /// \param ClassDecl the class for which the member is being created. 12264 /// \param CSM the kind of special member. 12265 /// \param MemberDecl the special member itself. 12266 /// \param ConstRHS true if this is a copy operation with a const object on 12267 /// its RHS. 12268 /// \param Diagnose true if this call should emit diagnostics. 12269 /// \return true if there was an error inferring. 12270 /// The result of this call is implicit CUDA target attribute(s) attached to 12271 /// the member declaration. 12272 bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, 12273 CXXSpecialMember CSM, 12274 CXXMethodDecl *MemberDecl, 12275 bool ConstRHS, 12276 bool Diagnose); 12277 12278 /// \return true if \p CD can be considered empty according to CUDA 12279 /// (E.2.3.1 in CUDA 7.5 Programming guide). 12280 bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD); 12281 bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD); 12282 12283 // \brief Checks that initializers of \p Var satisfy CUDA restrictions. In 12284 // case of error emits appropriate diagnostic and invalidates \p Var. 12285 // 12286 // \details CUDA allows only empty constructors as initializers for global 12287 // variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all 12288 // __shared__ variables whether they are local or not (they all are implicitly 12289 // static in CUDA). One exception is that CUDA allows constant initializers 12290 // for __constant__ and __device__ variables. 12291 void checkAllowedCUDAInitializer(VarDecl *VD); 12292 12293 /// Check whether NewFD is a valid overload for CUDA. Emits 12294 /// diagnostics and invalidates NewFD if not. 12295 void checkCUDATargetOverload(FunctionDecl *NewFD, 12296 const LookupResult &Previous); 12297 /// Copies target attributes from the template TD to the function FD. 12298 void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD); 12299 12300 /// Returns the name of the launch configuration function. This is the name 12301 /// of the function that will be called to configure kernel call, with the 12302 /// parameters specified via <<<>>>. 12303 std::string getCudaConfigureFuncName() const; 12304 12305 /// \name Code completion 12306 //@{ 12307 /// Describes the context in which code completion occurs. 12308 enum ParserCompletionContext { 12309 /// Code completion occurs at top-level or namespace context. 12310 PCC_Namespace, 12311 /// Code completion occurs within a class, struct, or union. 12312 PCC_Class, 12313 /// Code completion occurs within an Objective-C interface, protocol, 12314 /// or category. 12315 PCC_ObjCInterface, 12316 /// Code completion occurs within an Objective-C implementation or 12317 /// category implementation 12318 PCC_ObjCImplementation, 12319 /// Code completion occurs within the list of instance variables 12320 /// in an Objective-C interface, protocol, category, or implementation. 12321 PCC_ObjCInstanceVariableList, 12322 /// Code completion occurs following one or more template 12323 /// headers. 12324 PCC_Template, 12325 /// Code completion occurs following one or more template 12326 /// headers within a class. 12327 PCC_MemberTemplate, 12328 /// Code completion occurs within an expression. 12329 PCC_Expression, 12330 /// Code completion occurs within a statement, which may 12331 /// also be an expression or a declaration. 12332 PCC_Statement, 12333 /// Code completion occurs at the beginning of the 12334 /// initialization statement (or expression) in a for loop. 12335 PCC_ForInit, 12336 /// Code completion occurs within the condition of an if, 12337 /// while, switch, or for statement. 12338 PCC_Condition, 12339 /// Code completion occurs within the body of a function on a 12340 /// recovery path, where we do not have a specific handle on our position 12341 /// in the grammar. 12342 PCC_RecoveryInFunction, 12343 /// Code completion occurs where only a type is permitted. 12344 PCC_Type, 12345 /// Code completion occurs in a parenthesized expression, which 12346 /// might also be a type cast. 12347 PCC_ParenthesizedExpression, 12348 /// Code completion occurs within a sequence of declaration 12349 /// specifiers within a function, method, or block. 12350 PCC_LocalDeclarationSpecifiers 12351 }; 12352 12353 void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path); 12354 void CodeCompleteOrdinaryName(Scope *S, 12355 ParserCompletionContext CompletionContext); 12356 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, 12357 bool AllowNonIdentifiers, 12358 bool AllowNestedNameSpecifiers); 12359 12360 struct CodeCompleteExpressionData; 12361 void CodeCompleteExpression(Scope *S, 12362 const CodeCompleteExpressionData &Data); 12363 void CodeCompleteExpression(Scope *S, QualType PreferredType, 12364 bool IsParenthesized = false); 12365 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase, 12366 SourceLocation OpLoc, bool IsArrow, 12367 bool IsBaseExprStatement, 12368 QualType PreferredType); 12369 void CodeCompletePostfixExpression(Scope *S, ExprResult LHS, 12370 QualType PreferredType); 12371 void CodeCompleteTag(Scope *S, unsigned TagSpec); 12372 void CodeCompleteTypeQualifiers(DeclSpec &DS); 12373 void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D, 12374 const VirtSpecifiers *VS = nullptr); 12375 void CodeCompleteBracketDeclarator(Scope *S); 12376 void CodeCompleteCase(Scope *S); 12377 /// Determines the preferred type of the current function argument, by 12378 /// examining the signatures of all possible overloads. 12379 /// Returns null if unknown or ambiguous, or if code completion is off. 12380 /// 12381 /// If the code completion point has been reached, also reports the function 12382 /// signatures that were considered. 12383 /// 12384 /// FIXME: rename to GuessCallArgumentType to reduce confusion. 12385 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args, 12386 SourceLocation OpenParLoc); 12387 QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type, 12388 SourceLocation Loc, 12389 ArrayRef<Expr *> Args, 12390 SourceLocation OpenParLoc); 12391 QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl, 12392 CXXScopeSpec SS, 12393 ParsedType TemplateTypeTy, 12394 ArrayRef<Expr *> ArgExprs, 12395 IdentifierInfo *II, 12396 SourceLocation OpenParLoc); 12397 void CodeCompleteInitializer(Scope *S, Decl *D); 12398 /// Trigger code completion for a record of \p BaseType. \p InitExprs are 12399 /// expressions in the initializer list seen so far and \p D is the current 12400 /// Designation being parsed. 12401 void CodeCompleteDesignator(const QualType BaseType, 12402 llvm::ArrayRef<Expr *> InitExprs, 12403 const Designation &D); 12404 void CodeCompleteAfterIf(Scope *S, bool IsBracedThen); 12405 12406 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext, 12407 bool IsUsingDeclaration, QualType BaseType, 12408 QualType PreferredType); 12409 void CodeCompleteUsing(Scope *S); 12410 void CodeCompleteUsingDirective(Scope *S); 12411 void CodeCompleteNamespaceDecl(Scope *S); 12412 void CodeCompleteNamespaceAliasDecl(Scope *S); 12413 void CodeCompleteOperatorName(Scope *S); 12414 void CodeCompleteConstructorInitializer( 12415 Decl *Constructor, 12416 ArrayRef<CXXCtorInitializer *> Initializers); 12417 12418 void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, 12419 bool AfterAmpersand); 12420 void CodeCompleteAfterFunctionEquals(Declarator &D); 12421 12422 void CodeCompleteObjCAtDirective(Scope *S); 12423 void CodeCompleteObjCAtVisibility(Scope *S); 12424 void CodeCompleteObjCAtStatement(Scope *S); 12425 void CodeCompleteObjCAtExpression(Scope *S); 12426 void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS); 12427 void CodeCompleteObjCPropertyGetter(Scope *S); 12428 void CodeCompleteObjCPropertySetter(Scope *S); 12429 void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, 12430 bool IsParameter); 12431 void CodeCompleteObjCMessageReceiver(Scope *S); 12432 void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, 12433 ArrayRef<IdentifierInfo *> SelIdents, 12434 bool AtArgumentExpression); 12435 void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, 12436 ArrayRef<IdentifierInfo *> SelIdents, 12437 bool AtArgumentExpression, 12438 bool IsSuper = false); 12439 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver, 12440 ArrayRef<IdentifierInfo *> SelIdents, 12441 bool AtArgumentExpression, 12442 ObjCInterfaceDecl *Super = nullptr); 12443 void CodeCompleteObjCForCollection(Scope *S, 12444 DeclGroupPtrTy IterationVar); 12445 void CodeCompleteObjCSelector(Scope *S, 12446 ArrayRef<IdentifierInfo *> SelIdents); 12447 void CodeCompleteObjCProtocolReferences( 12448 ArrayRef<IdentifierLocPair> Protocols); 12449 void CodeCompleteObjCProtocolDecl(Scope *S); 12450 void CodeCompleteObjCInterfaceDecl(Scope *S); 12451 void CodeCompleteObjCSuperclass(Scope *S, 12452 IdentifierInfo *ClassName, 12453 SourceLocation ClassNameLoc); 12454 void CodeCompleteObjCImplementationDecl(Scope *S); 12455 void CodeCompleteObjCInterfaceCategory(Scope *S, 12456 IdentifierInfo *ClassName, 12457 SourceLocation ClassNameLoc); 12458 void CodeCompleteObjCImplementationCategory(Scope *S, 12459 IdentifierInfo *ClassName, 12460 SourceLocation ClassNameLoc); 12461 void CodeCompleteObjCPropertyDefinition(Scope *S); 12462 void CodeCompleteObjCPropertySynthesizeIvar(Scope *S, 12463 IdentifierInfo *PropertyName); 12464 void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod, 12465 ParsedType ReturnType); 12466 void CodeCompleteObjCMethodDeclSelector(Scope *S, 12467 bool IsInstanceMethod, 12468 bool AtParameterName, 12469 ParsedType ReturnType, 12470 ArrayRef<IdentifierInfo *> SelIdents); 12471 void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName, 12472 SourceLocation ClassNameLoc, 12473 bool IsBaseExprStatement); 12474 void CodeCompletePreprocessorDirective(bool InConditional); 12475 void CodeCompleteInPreprocessorConditionalExclusion(Scope *S); 12476 void CodeCompletePreprocessorMacroName(bool IsDefinition); 12477 void CodeCompletePreprocessorExpression(); 12478 void CodeCompletePreprocessorMacroArgument(Scope *S, 12479 IdentifierInfo *Macro, 12480 MacroInfo *MacroInfo, 12481 unsigned Argument); 12482 void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled); 12483 void CodeCompleteNaturalLanguage(); 12484 void CodeCompleteAvailabilityPlatformName(); 12485 void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator, 12486 CodeCompletionTUInfo &CCTUInfo, 12487 SmallVectorImpl<CodeCompletionResult> &Results); 12488 //@} 12489 12490 //===--------------------------------------------------------------------===// 12491 // Extra semantic analysis beyond the C type system 12492 12493 public: 12494 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, 12495 unsigned ByteNo) const; 12496 12497 private: 12498 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, 12499 const ArraySubscriptExpr *ASE=nullptr, 12500 bool AllowOnePastEnd=true, bool IndexNegated=false); 12501 void CheckArrayAccess(const Expr *E); 12502 // Used to grab the relevant information from a FormatAttr and a 12503 // FunctionDeclaration. 12504 struct FormatStringInfo { 12505 unsigned FormatIdx; 12506 unsigned FirstDataArg; 12507 bool HasVAListArg; 12508 }; 12509 12510 static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, 12511 FormatStringInfo *FSI); 12512 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, 12513 const FunctionProtoType *Proto); 12514 bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc, 12515 ArrayRef<const Expr *> Args); 12516 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall, 12517 const FunctionProtoType *Proto); 12518 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto); 12519 void CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType, 12520 ArrayRef<const Expr *> Args, 12521 const FunctionProtoType *Proto, SourceLocation Loc); 12522 12523 void CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl, 12524 StringRef ParamName, QualType ArgTy, QualType ParamTy); 12525 12526 void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, 12527 const Expr *ThisArg, ArrayRef<const Expr *> Args, 12528 bool IsMemberFunction, SourceLocation Loc, SourceRange Range, 12529 VariadicCallType CallType); 12530 12531 bool CheckObjCString(Expr *Arg); 12532 ExprResult CheckOSLogFormatStringArg(Expr *Arg); 12533 12534 ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl, 12535 unsigned BuiltinID, CallExpr *TheCall); 12536 12537 bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12538 CallExpr *TheCall); 12539 12540 void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall); 12541 12542 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall, 12543 unsigned MaxWidth); 12544 bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12545 CallExpr *TheCall); 12546 bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12547 bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12548 bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12549 CallExpr *TheCall); 12550 bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg, 12551 bool WantCDE); 12552 bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12553 CallExpr *TheCall); 12554 12555 bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12556 CallExpr *TheCall); 12557 bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12558 bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12559 bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall); 12560 bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12561 CallExpr *TheCall); 12562 bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID, 12563 CallExpr *TheCall); 12564 bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall); 12565 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12566 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall); 12567 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall); 12568 bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall); 12569 bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall, 12570 ArrayRef<int> ArgNums); 12571 bool CheckX86BuiltinTileDuplicate(CallExpr *TheCall, ArrayRef<int> ArgNums); 12572 bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall, 12573 ArrayRef<int> ArgNums); 12574 bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12575 CallExpr *TheCall); 12576 bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12577 CallExpr *TheCall); 12578 bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); 12579 bool CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum); 12580 bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, 12581 CallExpr *TheCall); 12582 12583 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall); 12584 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call); 12585 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall); 12586 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs); 12587 bool SemaBuiltinComplex(CallExpr *TheCall); 12588 bool SemaBuiltinVSX(CallExpr *TheCall); 12589 bool SemaBuiltinOSLogFormat(CallExpr *TheCall); 12590 bool SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum); 12591 12592 public: 12593 // Used by C++ template instantiation. 12594 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall); 12595 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, 12596 SourceLocation BuiltinLoc, 12597 SourceLocation RParenLoc); 12598 12599 private: 12600 bool SemaBuiltinPrefetch(CallExpr *TheCall); 12601 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall); 12602 bool SemaBuiltinArithmeticFence(CallExpr *TheCall); 12603 bool SemaBuiltinAssume(CallExpr *TheCall); 12604 bool SemaBuiltinAssumeAligned(CallExpr *TheCall); 12605 bool SemaBuiltinLongjmp(CallExpr *TheCall); 12606 bool SemaBuiltinSetjmp(CallExpr *TheCall); 12607 ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult); 12608 ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult); 12609 ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult, 12610 AtomicExpr::AtomicOp Op); 12611 ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult, 12612 bool IsDelete); 12613 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum, 12614 llvm::APSInt &Result); 12615 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, 12616 int High, bool RangeIsError = true); 12617 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum, 12618 unsigned Multiple); 12619 bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum); 12620 bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum, 12621 unsigned ArgBits); 12622 bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum, 12623 unsigned ArgBits); 12624 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall, 12625 int ArgNum, unsigned ExpectedFieldNum, 12626 bool AllowName); 12627 bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall); 12628 bool SemaBuiltinPPCMMACall(CallExpr *TheCall, const char *TypeDesc); 12629 12630 bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc); 12631 12632 // Matrix builtin handling. 12633 ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall, 12634 ExprResult CallResult); 12635 ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall, 12636 ExprResult CallResult); 12637 ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall, 12638 ExprResult CallResult); 12639 12640 public: 12641 enum FormatStringType { 12642 FST_Scanf, 12643 FST_Printf, 12644 FST_NSString, 12645 FST_Strftime, 12646 FST_Strfmon, 12647 FST_Kprintf, 12648 FST_FreeBSDKPrintf, 12649 FST_OSTrace, 12650 FST_OSLog, 12651 FST_Unknown 12652 }; 12653 static FormatStringType GetFormatStringType(const FormatAttr *Format); 12654 12655 bool FormatStringHasSArg(const StringLiteral *FExpr); 12656 12657 static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx); 12658 12659 private: 12660 bool CheckFormatArguments(const FormatAttr *Format, 12661 ArrayRef<const Expr *> Args, 12662 bool IsCXXMember, 12663 VariadicCallType CallType, 12664 SourceLocation Loc, SourceRange Range, 12665 llvm::SmallBitVector &CheckedVarArgs); 12666 bool CheckFormatArguments(ArrayRef<const Expr *> Args, 12667 bool HasVAListArg, unsigned format_idx, 12668 unsigned firstDataArg, FormatStringType Type, 12669 VariadicCallType CallType, 12670 SourceLocation Loc, SourceRange range, 12671 llvm::SmallBitVector &CheckedVarArgs); 12672 12673 void CheckAbsoluteValueFunction(const CallExpr *Call, 12674 const FunctionDecl *FDecl); 12675 12676 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl); 12677 12678 void CheckMemaccessArguments(const CallExpr *Call, 12679 unsigned BId, 12680 IdentifierInfo *FnName); 12681 12682 void CheckStrlcpycatArguments(const CallExpr *Call, 12683 IdentifierInfo *FnName); 12684 12685 void CheckStrncatArguments(const CallExpr *Call, 12686 IdentifierInfo *FnName); 12687 12688 void CheckFreeArguments(const CallExpr *E); 12689 12690 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType, 12691 SourceLocation ReturnLoc, 12692 bool isObjCMethod = false, 12693 const AttrVec *Attrs = nullptr, 12694 const FunctionDecl *FD = nullptr); 12695 12696 public: 12697 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS); 12698 12699 private: 12700 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation()); 12701 void CheckBoolLikeConversion(Expr *E, SourceLocation CC); 12702 void CheckForIntOverflow(Expr *E); 12703 void CheckUnsequencedOperations(const Expr *E); 12704 12705 /// Perform semantic checks on a completed expression. This will either 12706 /// be a full-expression or a default argument expression. 12707 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(), 12708 bool IsConstexpr = false); 12709 12710 void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field, 12711 Expr *Init); 12712 12713 /// Check if there is a field shadowing. 12714 void CheckShadowInheritedFields(const SourceLocation &Loc, 12715 DeclarationName FieldName, 12716 const CXXRecordDecl *RD, 12717 bool DeclIsField = true); 12718 12719 /// Check if the given expression contains 'break' or 'continue' 12720 /// statement that produces control flow different from GCC. 12721 void CheckBreakContinueBinding(Expr *E); 12722 12723 /// Check whether receiver is mutable ObjC container which 12724 /// attempts to add itself into the container 12725 void CheckObjCCircularContainer(ObjCMessageExpr *Message); 12726 12727 void CheckTCBEnforcement(const CallExpr *TheCall, const FunctionDecl *Callee); 12728 12729 void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE); 12730 void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc, 12731 bool DeleteWasArrayForm); 12732 public: 12733 /// Register a magic integral constant to be used as a type tag. 12734 void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, 12735 uint64_t MagicValue, QualType Type, 12736 bool LayoutCompatible, bool MustBeNull); 12737 12738 struct TypeTagData { 12739 TypeTagData() {} 12740 12741 TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) : 12742 Type(Type), LayoutCompatible(LayoutCompatible), 12743 MustBeNull(MustBeNull) 12744 {} 12745 12746 QualType Type; 12747 12748 /// If true, \c Type should be compared with other expression's types for 12749 /// layout-compatibility. 12750 unsigned LayoutCompatible : 1; 12751 unsigned MustBeNull : 1; 12752 }; 12753 12754 /// A pair of ArgumentKind identifier and magic value. This uniquely 12755 /// identifies the magic value. 12756 typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue; 12757 12758 private: 12759 /// A map from magic value to type information. 12760 std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>> 12761 TypeTagForDatatypeMagicValues; 12762 12763 /// Peform checks on a call of a function with argument_with_type_tag 12764 /// or pointer_with_type_tag attributes. 12765 void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr, 12766 const ArrayRef<const Expr *> ExprArgs, 12767 SourceLocation CallSiteLoc); 12768 12769 /// Check if we are taking the address of a packed field 12770 /// as this may be a problem if the pointer value is dereferenced. 12771 void CheckAddressOfPackedMember(Expr *rhs); 12772 12773 /// The parser's current scope. 12774 /// 12775 /// The parser maintains this state here. 12776 Scope *CurScope; 12777 12778 mutable IdentifierInfo *Ident_super; 12779 mutable IdentifierInfo *Ident___float128; 12780 12781 /// Nullability type specifiers. 12782 IdentifierInfo *Ident__Nonnull = nullptr; 12783 IdentifierInfo *Ident__Nullable = nullptr; 12784 IdentifierInfo *Ident__Nullable_result = nullptr; 12785 IdentifierInfo *Ident__Null_unspecified = nullptr; 12786 12787 IdentifierInfo *Ident_NSError = nullptr; 12788 12789 /// The handler for the FileChanged preprocessor events. 12790 /// 12791 /// Used for diagnostics that implement custom semantic analysis for #include 12792 /// directives, like -Wpragma-pack. 12793 sema::SemaPPCallbacks *SemaPPCallbackHandler; 12794 12795 protected: 12796 friend class Parser; 12797 friend class InitializationSequence; 12798 friend class ASTReader; 12799 friend class ASTDeclReader; 12800 friend class ASTWriter; 12801 12802 public: 12803 /// Retrieve the keyword associated 12804 IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability); 12805 12806 /// The struct behind the CFErrorRef pointer. 12807 RecordDecl *CFError = nullptr; 12808 bool isCFError(RecordDecl *D); 12809 12810 /// Retrieve the identifier "NSError". 12811 IdentifierInfo *getNSErrorIdent(); 12812 12813 /// Retrieve the parser's current scope. 12814 /// 12815 /// This routine must only be used when it is certain that semantic analysis 12816 /// and the parser are in precisely the same context, which is not the case 12817 /// when, e.g., we are performing any kind of template instantiation. 12818 /// Therefore, the only safe places to use this scope are in the parser 12819 /// itself and in routines directly invoked from the parser and *never* from 12820 /// template substitution or instantiation. 12821 Scope *getCurScope() const { return CurScope; } 12822 12823 void incrementMSManglingNumber() const { 12824 return CurScope->incrementMSManglingNumber(); 12825 } 12826 12827 IdentifierInfo *getSuperIdentifier() const; 12828 IdentifierInfo *getFloat128Identifier() const; 12829 12830 Decl *getObjCDeclContext() const; 12831 12832 DeclContext *getCurLexicalContext() const { 12833 return OriginalLexicalContext ? OriginalLexicalContext : CurContext; 12834 } 12835 12836 const DeclContext *getCurObjCLexicalContext() const { 12837 const DeclContext *DC = getCurLexicalContext(); 12838 // A category implicitly has the attribute of the interface. 12839 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC)) 12840 DC = CatD->getClassInterface(); 12841 return DC; 12842 } 12843 12844 /// Determine the number of levels of enclosing template parameters. This is 12845 /// only usable while parsing. Note that this does not include dependent 12846 /// contexts in which no template parameters have yet been declared, such as 12847 /// in a terse function template or generic lambda before the first 'auto' is 12848 /// encountered. 12849 unsigned getTemplateDepth(Scope *S) const; 12850 12851 /// To be used for checking whether the arguments being passed to 12852 /// function exceeds the number of parameters expected for it. 12853 static bool TooManyArguments(size_t NumParams, size_t NumArgs, 12854 bool PartialOverloading = false) { 12855 // We check whether we're just after a comma in code-completion. 12856 if (NumArgs > 0 && PartialOverloading) 12857 return NumArgs + 1 > NumParams; // If so, we view as an extra argument. 12858 return NumArgs > NumParams; 12859 } 12860 12861 // Emitting members of dllexported classes is delayed until the class 12862 // (including field initializers) is fully parsed. 12863 SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses; 12864 SmallVector<CXXMethodDecl*, 4> DelayedDllExportMemberFunctions; 12865 12866 private: 12867 int ParsingClassDepth = 0; 12868 12869 class SavePendingParsedClassStateRAII { 12870 public: 12871 SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); } 12872 12873 ~SavePendingParsedClassStateRAII() { 12874 assert(S.DelayedOverridingExceptionSpecChecks.empty() && 12875 "there shouldn't be any pending delayed exception spec checks"); 12876 assert(S.DelayedEquivalentExceptionSpecChecks.empty() && 12877 "there shouldn't be any pending delayed exception spec checks"); 12878 swapSavedState(); 12879 } 12880 12881 private: 12882 Sema &S; 12883 decltype(DelayedOverridingExceptionSpecChecks) 12884 SavedOverridingExceptionSpecChecks; 12885 decltype(DelayedEquivalentExceptionSpecChecks) 12886 SavedEquivalentExceptionSpecChecks; 12887 12888 void swapSavedState() { 12889 SavedOverridingExceptionSpecChecks.swap( 12890 S.DelayedOverridingExceptionSpecChecks); 12891 SavedEquivalentExceptionSpecChecks.swap( 12892 S.DelayedEquivalentExceptionSpecChecks); 12893 } 12894 }; 12895 12896 /// Helper class that collects misaligned member designations and 12897 /// their location info for delayed diagnostics. 12898 struct MisalignedMember { 12899 Expr *E; 12900 RecordDecl *RD; 12901 ValueDecl *MD; 12902 CharUnits Alignment; 12903 12904 MisalignedMember() : E(), RD(), MD(), Alignment() {} 12905 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD, 12906 CharUnits Alignment) 12907 : E(E), RD(RD), MD(MD), Alignment(Alignment) {} 12908 explicit MisalignedMember(Expr *E) 12909 : MisalignedMember(E, nullptr, nullptr, CharUnits()) {} 12910 12911 bool operator==(const MisalignedMember &m) { return this->E == m.E; } 12912 }; 12913 /// Small set of gathered accesses to potentially misaligned members 12914 /// due to the packed attribute. 12915 SmallVector<MisalignedMember, 4> MisalignedMembers; 12916 12917 /// Adds an expression to the set of gathered misaligned members. 12918 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD, 12919 CharUnits Alignment); 12920 12921 public: 12922 /// Diagnoses the current set of gathered accesses. This typically 12923 /// happens at full expression level. The set is cleared after emitting the 12924 /// diagnostics. 12925 void DiagnoseMisalignedMembers(); 12926 12927 /// This function checks if the expression is in the sef of potentially 12928 /// misaligned members and it is converted to some pointer type T with lower 12929 /// or equal alignment requirements. If so it removes it. This is used when 12930 /// we do not want to diagnose such misaligned access (e.g. in conversions to 12931 /// void*). 12932 void DiscardMisalignedMemberAddress(const Type *T, Expr *E); 12933 12934 /// This function calls Action when it determines that E designates a 12935 /// misaligned member due to the packed attribute. This is used to emit 12936 /// local diagnostics like in reference binding. 12937 void RefersToMemberWithReducedAlignment( 12938 Expr *E, 12939 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)> 12940 Action); 12941 12942 /// Describes the reason a calling convention specification was ignored, used 12943 /// for diagnostics. 12944 enum class CallingConventionIgnoredReason { 12945 ForThisTarget = 0, 12946 VariadicFunction, 12947 ConstructorDestructor, 12948 BuiltinFunction 12949 }; 12950 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current 12951 /// context is "used as device code". 12952 /// 12953 /// - If CurLexicalContext is a kernel function or it is known that the 12954 /// function will be emitted for the device, emits the diagnostics 12955 /// immediately. 12956 /// - If CurLexicalContext is a function and we are compiling 12957 /// for the device, but we don't know that this function will be codegen'ed 12958 /// for devive yet, creates a diagnostic which is emitted if and when we 12959 /// realize that the function will be codegen'ed. 12960 /// 12961 /// Example usage: 12962 /// 12963 /// Diagnose __float128 type usage only from SYCL device code if the current 12964 /// target doesn't support it 12965 /// if (!S.Context.getTargetInfo().hasFloat128Type() && 12966 /// S.getLangOpts().SYCLIsDevice) 12967 /// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128"; 12968 SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc, 12969 unsigned DiagID); 12970 12971 /// Check whether we're allowed to call Callee from the current context. 12972 /// 12973 /// - If the call is never allowed in a semantically-correct program 12974 /// emits an error and returns false. 12975 /// 12976 /// - If the call is allowed in semantically-correct programs, but only if 12977 /// it's never codegen'ed, creates a deferred diagnostic to be emitted if 12978 /// and when the caller is codegen'ed, and returns true. 12979 /// 12980 /// - Otherwise, returns true without emitting any diagnostics. 12981 /// 12982 /// Adds Callee to DeviceCallGraph if we don't know if its caller will be 12983 /// codegen'ed yet. 12984 bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee); 12985 }; 12986 12987 /// RAII object that enters a new expression evaluation context. 12988 class EnterExpressionEvaluationContext { 12989 Sema &Actions; 12990 bool Entered = true; 12991 12992 public: 12993 EnterExpressionEvaluationContext( 12994 Sema &Actions, Sema::ExpressionEvaluationContext NewContext, 12995 Decl *LambdaContextDecl = nullptr, 12996 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext = 12997 Sema::ExpressionEvaluationContextRecord::EK_Other, 12998 bool ShouldEnter = true) 12999 : Actions(Actions), Entered(ShouldEnter) { 13000 if (Entered) 13001 Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl, 13002 ExprContext); 13003 } 13004 EnterExpressionEvaluationContext( 13005 Sema &Actions, Sema::ExpressionEvaluationContext NewContext, 13006 Sema::ReuseLambdaContextDecl_t, 13007 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext = 13008 Sema::ExpressionEvaluationContextRecord::EK_Other) 13009 : Actions(Actions) { 13010 Actions.PushExpressionEvaluationContext( 13011 NewContext, Sema::ReuseLambdaContextDecl, ExprContext); 13012 } 13013 13014 enum InitListTag { InitList }; 13015 EnterExpressionEvaluationContext(Sema &Actions, InitListTag, 13016 bool ShouldEnter = true) 13017 : Actions(Actions), Entered(false) { 13018 // In C++11 onwards, narrowing checks are performed on the contents of 13019 // braced-init-lists, even when they occur within unevaluated operands. 13020 // Therefore we still need to instantiate constexpr functions used in such 13021 // a context. 13022 if (ShouldEnter && Actions.isUnevaluatedContext() && 13023 Actions.getLangOpts().CPlusPlus11) { 13024 Actions.PushExpressionEvaluationContext( 13025 Sema::ExpressionEvaluationContext::UnevaluatedList); 13026 Entered = true; 13027 } 13028 } 13029 13030 ~EnterExpressionEvaluationContext() { 13031 if (Entered) 13032 Actions.PopExpressionEvaluationContext(); 13033 } 13034 }; 13035 13036 DeductionFailureInfo 13037 MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, 13038 sema::TemplateDeductionInfo &Info); 13039 13040 /// Contains a late templated function. 13041 /// Will be parsed at the end of the translation unit, used by Sema & Parser. 13042 struct LateParsedTemplate { 13043 CachedTokens Toks; 13044 /// The template function declaration to be late parsed. 13045 Decl *D; 13046 }; 13047 13048 template <> 13049 void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation, 13050 PragmaMsStackAction Action, 13051 llvm::StringRef StackSlotLabel, 13052 AlignPackInfo Value); 13053 13054 } // end namespace clang 13055 13056 namespace llvm { 13057 // Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its 13058 // SourceLocation. 13059 template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> { 13060 using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc; 13061 using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>; 13062 13063 static FunctionDeclAndLoc getEmptyKey() { 13064 return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()}; 13065 } 13066 13067 static FunctionDeclAndLoc getTombstoneKey() { 13068 return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()}; 13069 } 13070 13071 static unsigned getHashValue(const FunctionDeclAndLoc &FDL) { 13072 return hash_combine(FDBaseInfo::getHashValue(FDL.FD), 13073 FDL.Loc.getHashValue()); 13074 } 13075 13076 static bool isEqual(const FunctionDeclAndLoc &LHS, 13077 const FunctionDeclAndLoc &RHS) { 13078 return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc; 13079 } 13080 }; 13081 } // namespace llvm 13082 13083 #endif 13084