brintos / llvm-project-archived public Read only

1//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//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-exception6//7//===----------------------------------------------------------------------===//8//9// This file implements the actions class which performs semantic analysis and10// builds an AST out of a parse stream.11//12//===----------------------------------------------------------------------===//13 14#include "UsedDeclVisitor.h"15#include "clang/AST/ASTContext.h"16#include "clang/AST/ASTDiagnostic.h"17#include "clang/AST/Decl.h"18#include "clang/AST/DeclCXX.h"19#include "clang/AST/DeclFriend.h"20#include "clang/AST/DeclObjC.h"21#include "clang/AST/Expr.h"22#include "clang/AST/ExprCXX.h"23#include "clang/AST/PrettyDeclStackTrace.h"24#include "clang/AST/StmtCXX.h"25#include "clang/AST/TypeOrdering.h"26#include "clang/Basic/DarwinSDKInfo.h"27#include "clang/Basic/DiagnosticOptions.h"28#include "clang/Basic/PartialDiagnostic.h"29#include "clang/Basic/SourceManager.h"30#include "clang/Basic/TargetInfo.h"31#include "clang/Lex/HeaderSearch.h"32#include "clang/Lex/HeaderSearchOptions.h"33#include "clang/Lex/Preprocessor.h"34#include "clang/Sema/CXXFieldCollector.h"35#include "clang/Sema/EnterExpressionEvaluationContext.h"36#include "clang/Sema/ExternalSemaSource.h"37#include "clang/Sema/Initialization.h"38#include "clang/Sema/MultiplexExternalSemaSource.h"39#include "clang/Sema/ObjCMethodList.h"40#include "clang/Sema/RISCVIntrinsicManager.h"41#include "clang/Sema/Scope.h"42#include "clang/Sema/ScopeInfo.h"43#include "clang/Sema/SemaAMDGPU.h"44#include "clang/Sema/SemaARM.h"45#include "clang/Sema/SemaAVR.h"46#include "clang/Sema/SemaBPF.h"47#include "clang/Sema/SemaCUDA.h"48#include "clang/Sema/SemaCodeCompletion.h"49#include "clang/Sema/SemaConsumer.h"50#include "clang/Sema/SemaDirectX.h"51#include "clang/Sema/SemaHLSL.h"52#include "clang/Sema/SemaHexagon.h"53#include "clang/Sema/SemaLoongArch.h"54#include "clang/Sema/SemaM68k.h"55#include "clang/Sema/SemaMIPS.h"56#include "clang/Sema/SemaMSP430.h"57#include "clang/Sema/SemaNVPTX.h"58#include "clang/Sema/SemaObjC.h"59#include "clang/Sema/SemaOpenACC.h"60#include "clang/Sema/SemaOpenCL.h"61#include "clang/Sema/SemaOpenMP.h"62#include "clang/Sema/SemaPPC.h"63#include "clang/Sema/SemaPseudoObject.h"64#include "clang/Sema/SemaRISCV.h"65#include "clang/Sema/SemaSPIRV.h"66#include "clang/Sema/SemaSYCL.h"67#include "clang/Sema/SemaSwift.h"68#include "clang/Sema/SemaSystemZ.h"69#include "clang/Sema/SemaWasm.h"70#include "clang/Sema/SemaX86.h"71#include "clang/Sema/TemplateDeduction.h"72#include "clang/Sema/TemplateInstCallback.h"73#include "clang/Sema/TypoCorrection.h"74#include "llvm/ADT/DenseMap.h"75#include "llvm/ADT/STLExtras.h"76#include "llvm/ADT/SmallPtrSet.h"77#include "llvm/Support/TimeProfiler.h"78#include <optional>79 80using namespace clang;81using namespace sema;82 83SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {84  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);85}86 87SourceRange88Sema::getRangeForNextToken(SourceLocation Loc, bool IncludeMacros,89                           bool IncludeComments,90                           std::optional<tok::TokenKind> ExpectedToken) {91  if (!Loc.isValid())92    return SourceRange();93  std::optional<Token> NextToken =94      Lexer::findNextToken(Loc, SourceMgr, LangOpts, IncludeComments);95  if (!NextToken)96    return SourceRange();97  if (ExpectedToken && NextToken->getKind() != *ExpectedToken)98    return SourceRange();99  SourceLocation TokenStart = NextToken->getLocation();100  SourceLocation TokenEnd = NextToken->getLastLoc();101  if (!TokenStart.isValid() || !TokenEnd.isValid())102    return SourceRange();103  if (!IncludeMacros && (TokenStart.isMacroID() || TokenEnd.isMacroID()))104    return SourceRange();105 106  return SourceRange(TokenStart, TokenEnd);107}108 109ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }110 111DarwinSDKInfo *112Sema::getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,113                                              StringRef Platform) {114  auto *SDKInfo = getDarwinSDKInfoForAvailabilityChecking();115  if (!SDKInfo && !WarnedDarwinSDKInfoMissing) {116    Diag(Loc, diag::warn_missing_sdksettings_for_availability_checking)117        << Platform;118    WarnedDarwinSDKInfoMissing = true;119  }120  return SDKInfo;121}122 123DarwinSDKInfo *Sema::getDarwinSDKInfoForAvailabilityChecking() {124  if (CachedDarwinSDKInfo)125    return CachedDarwinSDKInfo->get();126  auto SDKInfo = parseDarwinSDKInfo(127      PP.getFileManager().getVirtualFileSystem(),128      PP.getHeaderSearchInfo().getHeaderSearchOpts().Sysroot);129  if (SDKInfo && *SDKInfo) {130    CachedDarwinSDKInfo = std::make_unique<DarwinSDKInfo>(std::move(**SDKInfo));131    return CachedDarwinSDKInfo->get();132  }133  if (!SDKInfo)134    llvm::consumeError(SDKInfo.takeError());135  CachedDarwinSDKInfo = std::unique_ptr<DarwinSDKInfo>();136  return nullptr;137}138 139IdentifierInfo *Sema::InventAbbreviatedTemplateParameterTypeName(140    const IdentifierInfo *ParamName, unsigned int Index) {141  std::string InventedName;142  llvm::raw_string_ostream OS(InventedName);143 144  if (!ParamName)145    OS << "auto:" << Index + 1;146  else147    OS << ParamName->getName() << ":auto";148 149  return &Context.Idents.get(OS.str());150}151 152PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,153                                       const Preprocessor &PP) {154  PrintingPolicy Policy = Context.getPrintingPolicy();155  // In diagnostics, we print _Bool as bool if the latter is defined as the156  // former.157  Policy.Bool = Context.getLangOpts().Bool;158  if (!Policy.Bool) {159    if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {160      Policy.Bool = BoolMacro->isObjectLike() &&161                    BoolMacro->getNumTokens() == 1 &&162                    BoolMacro->getReplacementToken(0).is(tok::kw__Bool);163    }164  }165 166  // Shorten the data output if needed167  Policy.EntireContentsOfLargeArray = false;168 169  return Policy;170}171 172void Sema::ActOnTranslationUnitScope(Scope *S) {173  TUScope = S;174  PushDeclContext(S, Context.getTranslationUnitDecl());175}176 177namespace clang {178namespace sema {179 180class SemaPPCallbacks : public PPCallbacks {181  Sema *S = nullptr;182  llvm::SmallVector<SourceLocation, 8> IncludeStack;183  llvm::SmallVector<llvm::TimeTraceProfilerEntry *, 8> ProfilerStack;184 185public:186  void set(Sema &S) { this->S = &S; }187 188  void reset() { S = nullptr; }189 190  void FileChanged(SourceLocation Loc, FileChangeReason Reason,191                   SrcMgr::CharacteristicKind FileType,192                   FileID PrevFID) override {193    if (!S)194      return;195    switch (Reason) {196    case EnterFile: {197      SourceManager &SM = S->getSourceManager();198      SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));199      if (IncludeLoc.isValid()) {200        if (llvm::timeTraceProfilerEnabled()) {201          OptionalFileEntryRef FE = SM.getFileEntryRefForID(SM.getFileID(Loc));202          ProfilerStack.push_back(llvm::timeTraceAsyncProfilerBegin(203              "Source", FE ? FE->getName() : StringRef("<unknown>")));204        }205 206        IncludeStack.push_back(IncludeLoc);207        S->DiagnoseNonDefaultPragmaAlignPack(208            Sema::PragmaAlignPackDiagnoseKind::NonDefaultStateAtInclude,209            IncludeLoc);210      }211      break;212    }213    case ExitFile:214      if (!IncludeStack.empty()) {215        if (llvm::timeTraceProfilerEnabled())216          llvm::timeTraceProfilerEnd(ProfilerStack.pop_back_val());217 218        S->DiagnoseNonDefaultPragmaAlignPack(219            Sema::PragmaAlignPackDiagnoseKind::ChangedStateAtExit,220            IncludeStack.pop_back_val());221      }222      break;223    default:224      break;225    }226  }227  void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,228                        diag::Severity Mapping, StringRef Str) override {229    // If one of the analysis-based diagnostics was enabled while processing230    // a function, we want to note it in the analysis-based warnings so they231    // can be run at the end of the function body even if the analysis warnings232    // are disabled at that point.233    SmallVector<diag::kind, 256> GroupDiags;234    diag::Flavor Flavor =235        Str[1] == 'W' ? diag::Flavor::WarningOrError : diag::Flavor::Remark;236    StringRef Group = Str.substr(2);237 238    if (S->PP.getDiagnostics().getDiagnosticIDs()->getDiagnosticsInGroup(239            Flavor, Group, GroupDiags))240      return;241 242    for (diag::kind K : GroupDiags) {243      // Note: the cases in this switch should be kept in sync with the244      // diagnostics in AnalysisBasedWarnings::getPolicyInEffectAt().245      AnalysisBasedWarnings::Policy &Override =246          S->AnalysisWarnings.getPolicyOverrides();247      switch (K) {248      default: break;249      case diag::warn_unreachable:250      case diag::warn_unreachable_break:251      case diag::warn_unreachable_return:252      case diag::warn_unreachable_loop_increment:253        Override.enableCheckUnreachable = true;254        break;255      case diag::warn_double_lock:256        Override.enableThreadSafetyAnalysis = true;257        break;258      case diag::warn_use_in_invalid_state:259        Override.enableConsumedAnalysis = true;260        break;261      }262    }263  }264};265 266} // end namespace sema267} // end namespace clang268 269const unsigned Sema::MaxAlignmentExponent;270const uint64_t Sema::MaximumAlignment;271 272Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,273           TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)274    : SemaBase(*this), CollectStats(false), TUKind(TUKind),275      CurFPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),276      Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),277      SourceMgr(PP.getSourceManager()), APINotes(SourceMgr, LangOpts),278      AnalysisWarnings(*this), ThreadSafetyDeclCache(nullptr),279      LateTemplateParser(nullptr), OpaqueParser(nullptr), CurContext(nullptr),280      ExternalSource(nullptr), StackHandler(Diags), CurScope(nullptr),281      Ident_super(nullptr), AMDGPUPtr(std::make_unique<SemaAMDGPU>(*this)),282      ARMPtr(std::make_unique<SemaARM>(*this)),283      AVRPtr(std::make_unique<SemaAVR>(*this)),284      BPFPtr(std::make_unique<SemaBPF>(*this)),285      CodeCompletionPtr(286          std::make_unique<SemaCodeCompletion>(*this, CodeCompleter)),287      CUDAPtr(std::make_unique<SemaCUDA>(*this)),288      DirectXPtr(std::make_unique<SemaDirectX>(*this)),289      HLSLPtr(std::make_unique<SemaHLSL>(*this)),290      HexagonPtr(std::make_unique<SemaHexagon>(*this)),291      LoongArchPtr(std::make_unique<SemaLoongArch>(*this)),292      M68kPtr(std::make_unique<SemaM68k>(*this)),293      MIPSPtr(std::make_unique<SemaMIPS>(*this)),294      MSP430Ptr(std::make_unique<SemaMSP430>(*this)),295      NVPTXPtr(std::make_unique<SemaNVPTX>(*this)),296      ObjCPtr(std::make_unique<SemaObjC>(*this)),297      OpenACCPtr(std::make_unique<SemaOpenACC>(*this)),298      OpenCLPtr(std::make_unique<SemaOpenCL>(*this)),299      OpenMPPtr(std::make_unique<SemaOpenMP>(*this)),300      PPCPtr(std::make_unique<SemaPPC>(*this)),301      PseudoObjectPtr(std::make_unique<SemaPseudoObject>(*this)),302      RISCVPtr(std::make_unique<SemaRISCV>(*this)),303      SPIRVPtr(std::make_unique<SemaSPIRV>(*this)),304      SYCLPtr(std::make_unique<SemaSYCL>(*this)),305      SwiftPtr(std::make_unique<SemaSwift>(*this)),306      SystemZPtr(std::make_unique<SemaSystemZ>(*this)),307      WasmPtr(std::make_unique<SemaWasm>(*this)),308      X86Ptr(std::make_unique<SemaX86>(*this)),309      MSPointerToMemberRepresentationMethod(310          LangOpts.getMSPointerToMemberRepresentationMethod()),311      MSStructPragmaOn(false), VtorDispStack(LangOpts.getVtorDispMode()),312      AlignPackStack(AlignPackInfo(getLangOpts().XLPragmaPack)),313      DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),314      CodeSegStack(nullptr), StrictGuardStackCheckStack(false),315      FpPragmaStack(FPOptionsOverride()), CurInitSeg(nullptr),316      VisContext(nullptr), PragmaAttributeCurrentTargetDecl(nullptr),317      StdCoroutineTraitsCache(nullptr), IdResolver(pp),318      OriginalLexicalContext(nullptr), StdInitializerList(nullptr),319      StdTypeIdentity(nullptr),320      FullyCheckedComparisonCategories(321          static_cast<unsigned>(ComparisonCategoryType::Last) + 1),322      StdSourceLocationImplDecl(nullptr), CXXTypeInfoDecl(nullptr),323      GlobalNewDeleteDeclared(false), DisableTypoCorrection(false),324      TyposCorrected(0), IsBuildingRecoveryCallExpr(false),325      CurrentInstantiationScope(nullptr), NonInstantiationEntries(0),326      ArgPackSubstIndex(std::nullopt), SatisfactionCache(Context) {327  assert(pp.TUKind == TUKind);328  TUScope = nullptr;329 330  LoadedExternalKnownNamespaces = false;331  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)332    ObjC().NSNumberLiteralMethods[I] = nullptr;333 334  if (getLangOpts().ObjC)335    ObjC().NSAPIObj.reset(new NSAPI(Context));336 337  if (getLangOpts().CPlusPlus)338    FieldCollector.reset(new CXXFieldCollector());339 340  // Tell diagnostics how to render things from the AST library.341  Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);342 343  // This evaluation context exists to ensure that there's always at least one344  // valid evaluation context available. It is never removed from the345  // evaluation stack.346  ExprEvalContexts.emplace_back(347      ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},348      nullptr, ExpressionEvaluationContextRecord::EK_Other);349 350  // Initialization of data sharing attributes stack for OpenMP351  OpenMP().InitDataSharingAttributesStack();352 353  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =354      std::make_unique<sema::SemaPPCallbacks>();355  SemaPPCallbackHandler = Callbacks.get();356  PP.addPPCallbacks(std::move(Callbacks));357  SemaPPCallbackHandler->set(*this);358 359  CurFPFeatures.setFPEvalMethod(PP.getCurrentFPEvalMethod());360}361 362// Anchor Sema's type info to this TU.363void Sema::anchor() {}364 365void Sema::addImplicitTypedef(StringRef Name, QualType T) {366  DeclarationName DN = &Context.Idents.get(Name);367  if (IdResolver.begin(DN) == IdResolver.end())368    PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);369}370 371void Sema::Initialize() {372  // Create BuiltinVaListDecl *before* ExternalSemaSource::InitializeSema(this)373  // because during initialization ASTReader can emit globals that require374  // name mangling. And the name mangling uses BuiltinVaListDecl.375  if (Context.getTargetInfo().hasBuiltinMSVaList())376    (void)Context.getBuiltinMSVaListDecl();377  (void)Context.getBuiltinVaListDecl();378 379  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))380    SC->InitializeSema(*this);381 382  // Tell the external Sema source about this Sema object.383  if (ExternalSemaSource *ExternalSema384      = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))385    ExternalSema->InitializeSema(*this);386 387  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we388  // will not be able to merge any duplicate __va_list_tag decls correctly.389  VAListTagName = PP.getIdentifierInfo("__va_list_tag");390 391  if (!TUScope)392    return;393 394  // Initialize predefined 128-bit integer types, if needed.395  if (Context.getTargetInfo().hasInt128Type() ||396      (Context.getAuxTargetInfo() &&397       Context.getAuxTargetInfo()->hasInt128Type())) {398    // If either of the 128-bit integer types are unavailable to name lookup,399    // define them now.400    DeclarationName Int128 = &Context.Idents.get("__int128_t");401    if (IdResolver.begin(Int128) == IdResolver.end())402      PushOnScopeChains(Context.getInt128Decl(), TUScope);403 404    DeclarationName UInt128 = &Context.Idents.get("__uint128_t");405    if (IdResolver.begin(UInt128) == IdResolver.end())406      PushOnScopeChains(Context.getUInt128Decl(), TUScope);407  }408 409 410  // Initialize predefined Objective-C types:411  if (getLangOpts().ObjC) {412    // If 'SEL' does not yet refer to any declarations, make it refer to the413    // predefined 'SEL'.414    DeclarationName SEL = &Context.Idents.get("SEL");415    if (IdResolver.begin(SEL) == IdResolver.end())416      PushOnScopeChains(Context.getObjCSelDecl(), TUScope);417 418    // If 'id' does not yet refer to any declarations, make it refer to the419    // predefined 'id'.420    DeclarationName Id = &Context.Idents.get("id");421    if (IdResolver.begin(Id) == IdResolver.end())422      PushOnScopeChains(Context.getObjCIdDecl(), TUScope);423 424    // Create the built-in typedef for 'Class'.425    DeclarationName Class = &Context.Idents.get("Class");426    if (IdResolver.begin(Class) == IdResolver.end())427      PushOnScopeChains(Context.getObjCClassDecl(), TUScope);428 429    // Create the built-in forward declaratino for 'Protocol'.430    DeclarationName Protocol = &Context.Idents.get("Protocol");431    if (IdResolver.begin(Protocol) == IdResolver.end())432      PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);433  }434 435  // Create the internal type for the *StringMakeConstantString builtins.436  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");437  if (IdResolver.begin(ConstantString) == IdResolver.end())438    PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);439 440  // Initialize Microsoft "predefined C++ types".441  if (getLangOpts().MSVCCompat) {442    if (getLangOpts().CPlusPlus &&443        IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())444      PushOnScopeChains(Context.getMSTypeInfoTagDecl(), TUScope);445 446    addImplicitTypedef("size_t", Context.getSizeType());447  }448 449  // Initialize predefined OpenCL types and supported extensions and (optional)450  // core features.451  if (getLangOpts().OpenCL) {452    getOpenCLOptions().addSupport(453        Context.getTargetInfo().getSupportedOpenCLOpts(), getLangOpts());454    addImplicitTypedef("sampler_t", Context.OCLSamplerTy);455    addImplicitTypedef("event_t", Context.OCLEventTy);456    auto OCLCompatibleVersion = getLangOpts().getOpenCLCompatibleVersion();457    if (OCLCompatibleVersion >= 200) {458      if (getLangOpts().OpenCLCPlusPlus || getLangOpts().Blocks) {459        addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);460        addImplicitTypedef("queue_t", Context.OCLQueueTy);461      }462      if (getLangOpts().OpenCLPipes)463        addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);464      addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));465      addImplicitTypedef("atomic_uint",466                         Context.getAtomicType(Context.UnsignedIntTy));467      addImplicitTypedef("atomic_float",468                         Context.getAtomicType(Context.FloatTy));469      // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as470      // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.471      addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));472 473 474      // OpenCL v2.0 s6.13.11.6:475      // - The atomic_long and atomic_ulong types are supported if the476      //   cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics477      //   extensions are supported.478      // - The atomic_double type is only supported if double precision479      //   is supported and the cl_khr_int64_base_atomics and480      //   cl_khr_int64_extended_atomics extensions are supported.481      // - If the device address space is 64-bits, the data types482      //   atomic_intptr_t, atomic_uintptr_t, atomic_size_t and483      //   atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and484      //   cl_khr_int64_extended_atomics extensions are supported.485 486      auto AddPointerSizeDependentTypes = [&]() {487        auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());488        auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());489        auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());490        auto AtomicPtrDiffT =491            Context.getAtomicType(Context.getPointerDiffType());492        addImplicitTypedef("atomic_size_t", AtomicSizeT);493        addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);494        addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);495        addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);496      };497 498      if (Context.getTypeSize(Context.getSizeType()) == 32) {499        AddPointerSizeDependentTypes();500      }501 502      if (getOpenCLOptions().isSupported("cl_khr_fp16", getLangOpts())) {503        auto AtomicHalfT = Context.getAtomicType(Context.HalfTy);504        addImplicitTypedef("atomic_half", AtomicHalfT);505      }506 507      std::vector<QualType> Atomic64BitTypes;508      if (getOpenCLOptions().isSupported("cl_khr_int64_base_atomics",509                                         getLangOpts()) &&510          getOpenCLOptions().isSupported("cl_khr_int64_extended_atomics",511                                         getLangOpts())) {512        if (getOpenCLOptions().isSupported("cl_khr_fp64", getLangOpts())) {513          auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);514          addImplicitTypedef("atomic_double", AtomicDoubleT);515          Atomic64BitTypes.push_back(AtomicDoubleT);516        }517        auto AtomicLongT = Context.getAtomicType(Context.LongTy);518        auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);519        addImplicitTypedef("atomic_long", AtomicLongT);520        addImplicitTypedef("atomic_ulong", AtomicULongT);521 522 523        if (Context.getTypeSize(Context.getSizeType()) == 64) {524          AddPointerSizeDependentTypes();525        }526      }527    }528 529#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \530  if (getOpenCLOptions().isSupported(#Ext, getLangOpts())) {                   \531    addImplicitTypedef(#ExtType, Context.Id##Ty);                              \532  }533#include "clang/Basic/OpenCLExtensionTypes.def"534  }535 536  if (Context.getTargetInfo().hasAArch64ACLETypes() ||537      (Context.getAuxTargetInfo() &&538       Context.getAuxTargetInfo()->hasAArch64ACLETypes())) {539#define SVE_TYPE(Name, Id, SingletonId)                                        \540  addImplicitTypedef(#Name, Context.SingletonId);541#define NEON_VECTOR_TYPE(Name, BaseType, ElBits, NumEls, VectorKind)           \542  addImplicitTypedef(                                                          \543      #Name, Context.getVectorType(Context.BaseType, NumEls, VectorKind));544#include "clang/Basic/AArch64ACLETypes.def"545  }546 547  if (Context.getTargetInfo().getTriple().isPPC64()) {548#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \549      addImplicitTypedef(#Name, Context.Id##Ty);550#include "clang/Basic/PPCTypes.def"551#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \552    addImplicitTypedef(#Name, Context.Id##Ty);553#include "clang/Basic/PPCTypes.def"554  }555 556  if (Context.getTargetInfo().hasRISCVVTypes()) {557#define RVV_TYPE(Name, Id, SingletonId)                                        \558  addImplicitTypedef(Name, Context.SingletonId);559#include "clang/Basic/RISCVVTypes.def"560  }561 562  if (Context.getTargetInfo().getTriple().isWasm() &&563      Context.getTargetInfo().hasFeature("reference-types")) {564#define WASM_TYPE(Name, Id, SingletonId)                                       \565  addImplicitTypedef(Name, Context.SingletonId);566#include "clang/Basic/WebAssemblyReferenceTypes.def"567  }568 569  if (Context.getTargetInfo().getTriple().isAMDGPU() ||570      (Context.getAuxTargetInfo() &&571       Context.getAuxTargetInfo()->getTriple().isAMDGPU())) {572#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align)                       \573  addImplicitTypedef(Name, Context.SingletonId);574#include "clang/Basic/AMDGPUTypes.def"575  }576 577  if (Context.getTargetInfo().hasBuiltinMSVaList()) {578    DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");579    if (IdResolver.begin(MSVaList) == IdResolver.end())580      PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);581  }582 583  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");584  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())585    PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);586}587 588Sema::~Sema() {589  assert(InstantiatingSpecializations.empty() &&590         "failed to clean up an InstantiatingTemplate?");591 592  if (VisContext) FreeVisContext();593 594  // Kill all the active scopes.595  for (sema::FunctionScopeInfo *FSI : FunctionScopes)596    delete FSI;597 598  // Tell the SemaConsumer to forget about us; we're going out of scope.599  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))600    SC->ForgetSema();601 602  // Detach from the external Sema source.603  if (ExternalSemaSource *ExternalSema604        = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))605    ExternalSema->ForgetSema();606 607  // Delete cached satisfactions.608  std::vector<ConstraintSatisfaction *> Satisfactions;609  Satisfactions.reserve(SatisfactionCache.size());610  for (auto &Node : SatisfactionCache)611    Satisfactions.push_back(&Node);612  for (auto *Node : Satisfactions)613    delete Node;614 615  threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);616 617  // Destroys data sharing attributes stack for OpenMP618  OpenMP().DestroyDataSharingAttributesStack();619 620  // Detach from the PP callback handler which outlives Sema since it's owned621  // by the preprocessor.622  SemaPPCallbackHandler->reset();623}624 625void Sema::runWithSufficientStackSpace(SourceLocation Loc,626                                       llvm::function_ref<void()> Fn) {627  StackHandler.runWithSufficientStackSpace(Loc, Fn);628}629 630bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,631                                      UnavailableAttr::ImplicitReason reason) {632  // If we're not in a function, it's an error.633  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);634  if (!fn) return false;635 636  // If we're in template instantiation, it's an error.637  if (inTemplateInstantiation())638    return false;639 640  // If that function's not in a system header, it's an error.641  if (!Context.getSourceManager().isInSystemHeader(loc))642    return false;643 644  // If the function is already unavailable, it's not an error.645  if (fn->hasAttr<UnavailableAttr>()) return true;646 647  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));648  return true;649}650 651ASTMutationListener *Sema::getASTMutationListener() const {652  return getASTConsumer().GetASTMutationListener();653}654 655void Sema::addExternalSource(IntrusiveRefCntPtr<ExternalSemaSource> E) {656  assert(E && "Cannot use with NULL ptr");657 658  if (!ExternalSource) {659    ExternalSource = std::move(E);660    return;661  }662 663  if (auto *Ex = dyn_cast<MultiplexExternalSemaSource>(ExternalSource.get()))664    Ex->AddSource(std::move(E));665  else666    ExternalSource = llvm::makeIntrusiveRefCnt<MultiplexExternalSemaSource>(667        ExternalSource, std::move(E));668}669 670void Sema::PrintStats() const {671  llvm::errs() << "\n*** Semantic Analysis Stats:\n";672  if (SFINAETrap *Trap = getSFINAEContext())673    llvm::errs() << int(Trap->hasErrorOccurred())674                 << " SFINAE diagnostics trapped.\n";675 676  BumpAlloc.PrintStats();677  AnalysisWarnings.PrintStats();678}679 680void Sema::diagnoseNullableToNonnullConversion(QualType DstType,681                                               QualType SrcType,682                                               SourceLocation Loc) {683  std::optional<NullabilityKind> ExprNullability = SrcType->getNullability();684  if (!ExprNullability || (*ExprNullability != NullabilityKind::Nullable &&685                           *ExprNullability != NullabilityKind::NullableResult))686    return;687 688  std::optional<NullabilityKind> TypeNullability = DstType->getNullability();689  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)690    return;691 692  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;693}694 695// Generate diagnostics when adding or removing effects in a type conversion.696void Sema::diagnoseFunctionEffectConversion(QualType DstType, QualType SrcType,697                                            SourceLocation Loc) {698  const auto SrcFX = FunctionEffectsRef::get(SrcType);699  const auto DstFX = FunctionEffectsRef::get(DstType);700  if (SrcFX != DstFX) {701    for (const auto &Diff : FunctionEffectDiffVector(SrcFX, DstFX)) {702      if (Diff.shouldDiagnoseConversion(SrcType, SrcFX, DstType, DstFX))703        Diag(Loc, diag::warn_invalid_add_func_effects) << Diff.effectName();704    }705  }706}707 708void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E) {709  // nullptr only exists from C++11 on, so don't warn on its absence earlier.710  if (!getLangOpts().CPlusPlus11)711    return;712 713  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)714    return;715 716  const Expr *EStripped = E->IgnoreParenImpCasts();717  if (EStripped->getType()->isNullPtrType())718    return;719  if (isa<GNUNullExpr>(EStripped))720    return;721 722  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,723                      E->getBeginLoc()))724    return;725 726  // Don't diagnose the conversion from a 0 literal to a null pointer argument727  // in a synthesized call to operator<=>.728  if (!CodeSynthesisContexts.empty() &&729      CodeSynthesisContexts.back().Kind ==730          CodeSynthesisContext::RewritingOperatorAsSpaceship)731    return;732 733  // Ignore null pointers in defaulted comparison operators.734  FunctionDecl *FD = getCurFunctionDecl();735  if (FD && FD->isDefaulted()) {736    return;737  }738 739  // If it is a macro from system header, and if the macro name is not "NULL",740  // do not warn.741  // Note that uses of "NULL" will be ignored above on systems that define it742  // as __null.743  SourceLocation MaybeMacroLoc = E->getBeginLoc();744  if (Diags.getSuppressSystemWarnings() &&745      SourceMgr.isInSystemMacro(MaybeMacroLoc) &&746      !findMacroSpelling(MaybeMacroLoc, "NULL"))747    return;748 749  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)750      << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");751}752 753/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.754/// If there is already an implicit cast, merge into the existing one.755/// The result is of the given category.756ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,757                                   CastKind Kind, ExprValueKind VK,758                                   const CXXCastPath *BasePath,759                                   CheckedConversionKind CCK) {760#ifndef NDEBUG761  if (VK == VK_PRValue && !E->isPRValue()) {762    switch (Kind) {763    default:764      llvm_unreachable(765          ("can't implicitly cast glvalue to prvalue with this cast "766           "kind: " +767           std::string(CastExpr::getCastKindName(Kind)))768              .c_str());769    case CK_Dependent:770    case CK_LValueToRValue:771    case CK_ArrayToPointerDecay:772    case CK_FunctionToPointerDecay:773    case CK_ToVoid:774    case CK_NonAtomicToAtomic:775    case CK_HLSLArrayRValue:776    case CK_HLSLAggregateSplatCast:777      break;778    }779  }780  assert((VK == VK_PRValue || Kind == CK_Dependent || !E->isPRValue()) &&781         "can't cast prvalue to glvalue");782#endif783 784  diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());785  diagnoseZeroToNullptrConversion(Kind, E);786  if (Context.hasAnyFunctionEffects() && !isCast(CCK) &&787      Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)788    diagnoseFunctionEffectConversion(Ty, E->getType(), E->getBeginLoc());789 790  QualType ExprTy = Context.getCanonicalType(E->getType());791  QualType TypeTy = Context.getCanonicalType(Ty);792 793  // This cast is used in place of a regular LValue to RValue cast for794  // HLSL Array Parameter Types. It needs to be emitted even if795  // ExprTy == TypeTy, except if E is an HLSLOutArgExpr796  // Emitting a cast in that case will prevent HLSLOutArgExpr from797  // being handled properly in EmitCallArg798  if (Kind == CK_HLSLArrayRValue && !isa<HLSLOutArgExpr>(E))799    return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK,800                                    CurFPFeatureOverrides());801 802  if (ExprTy == TypeTy)803    return E;804 805  if (Kind == CK_ArrayToPointerDecay) {806    // C++1z [conv.array]: The temporary materialization conversion is applied.807    // We also use this to fuel C++ DR1213, which applies to C++11 onwards.808    if (getLangOpts().CPlusPlus && E->isPRValue()) {809      // The temporary is an lvalue in C++98 and an xvalue otherwise.810      ExprResult Materialized = CreateMaterializeTemporaryExpr(811          E->getType(), E, !getLangOpts().CPlusPlus11);812      if (Materialized.isInvalid())813        return ExprError();814      E = Materialized.get();815    }816    // C17 6.7.1p6 footnote 124: The implementation can treat any register817    // declaration simply as an auto declaration. However, whether or not818    // addressable storage is actually used, the address of any part of an819    // object declared with storage-class specifier register cannot be820    // computed, either explicitly(by use of the unary & operator as discussed821    // in 6.5.3.2) or implicitly(by converting an array name to a pointer as822    // discussed in 6.3.2.1).Thus, the only operator that can be applied to an823    // array declared with storage-class specifier register is sizeof.824    if (VK == VK_PRValue && !getLangOpts().CPlusPlus && !E->isPRValue()) {825      if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {826        if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {827          if (VD->getStorageClass() == SC_Register) {828            Diag(E->getExprLoc(), diag::err_typecheck_address_of)829                << /*register variable*/ 3 << E->getSourceRange();830            return ExprError();831          }832        }833      }834    }835  }836 837  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {838    if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {839      ImpCast->setType(Ty);840      ImpCast->setValueKind(VK);841      return E;842    }843  }844 845  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK,846                                  CurFPFeatureOverrides());847}848 849CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {850  switch (ScalarTy->getScalarTypeKind()) {851  case Type::STK_Bool: return CK_NoOp;852  case Type::STK_CPointer: return CK_PointerToBoolean;853  case Type::STK_BlockPointer: return CK_PointerToBoolean;854  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;855  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;856  case Type::STK_Integral: return CK_IntegralToBoolean;857  case Type::STK_Floating: return CK_FloatingToBoolean;858  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;859  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;860  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;861  }862  llvm_unreachable("unknown scalar type kind");863}864 865/// Used to prune the decls of Sema's UnusedFileScopedDecls vector.866static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {867  if (D->getMostRecentDecl()->isUsed())868    return true;869 870  if (D->isExternallyVisible())871    return true;872 873  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {874    // If this is a function template and none of its specializations is used,875    // we should warn.876    if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())877      for (const auto *Spec : Template->specializations())878        if (ShouldRemoveFromUnused(SemaRef, Spec))879          return true;880 881    // UnusedFileScopedDecls stores the first declaration.882    // The declaration may have become definition so check again.883    const FunctionDecl *DeclToCheck;884    if (FD->hasBody(DeclToCheck))885      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);886 887    // Later redecls may add new information resulting in not having to warn,888    // so check again.889    DeclToCheck = FD->getMostRecentDecl();890    if (DeclToCheck != FD)891      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);892  }893 894  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {895    // If a variable usable in constant expressions is referenced,896    // don't warn if it isn't used: if the value of a variable is required897    // for the computation of a constant expression, it doesn't make sense to898    // warn even if the variable isn't odr-used.  (isReferenced doesn't899    // precisely reflect that, but it's a decent approximation.)900    if (VD->isReferenced() &&901        VD->mightBeUsableInConstantExpressions(SemaRef->Context))902      return true;903 904    if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())905      // If this is a variable template and none of its specializations is used,906      // we should warn.907      for (const auto *Spec : Template->specializations())908        if (ShouldRemoveFromUnused(SemaRef, Spec))909          return true;910 911    // UnusedFileScopedDecls stores the first declaration.912    // The declaration may have become definition so check again.913    const VarDecl *DeclToCheck = VD->getDefinition();914    if (DeclToCheck)915      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);916 917    // Later redecls may add new information resulting in not having to warn,918    // so check again.919    DeclToCheck = VD->getMostRecentDecl();920    if (DeclToCheck != VD)921      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);922  }923 924  return false;925}926 927static bool isFunctionOrVarDeclExternC(const NamedDecl *ND) {928  if (const auto *FD = dyn_cast<FunctionDecl>(ND))929    return FD->isExternC();930  return cast<VarDecl>(ND)->isExternC();931}932 933/// Determine whether ND is an external-linkage function or variable whose934/// type has no linkage.935bool Sema::isExternalWithNoLinkageType(const ValueDecl *VD) const {936  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,937  // because we also want to catch the case where its type has VisibleNoLinkage,938  // which does not affect the linkage of VD.939  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&940         !isExternalFormalLinkage(VD->getType()->getLinkage()) &&941         !isFunctionOrVarDeclExternC(VD);942}943 944/// Obtains a sorted list of functions and variables that are undefined but945/// ODR-used.946void Sema::getUndefinedButUsed(947    SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {948  for (const auto &UndefinedUse : UndefinedButUsed) {949    NamedDecl *ND = UndefinedUse.first;950 951    // Ignore attributes that have become invalid.952    if (ND->isInvalidDecl()) continue;953 954    // __attribute__((weakref)) is basically a definition.955    if (ND->hasAttr<WeakRefAttr>()) continue;956 957    if (isa<CXXDeductionGuideDecl>(ND))958      continue;959 960    if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {961      // An exported function will always be emitted when defined, so even if962      // the function is inline, it doesn't have to be emitted in this TU. An963      // imported function implies that it has been exported somewhere else.964      continue;965    }966 967    if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {968      if (FD->isDefined())969        continue;970      if (FD->isExternallyVisible() &&971          !isExternalWithNoLinkageType(FD) &&972          !FD->getMostRecentDecl()->isInlined() &&973          !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())974        continue;975      if (FD->getBuiltinID())976        continue;977    } else {978      const auto *VD = cast<VarDecl>(ND);979      if (VD->hasDefinition() != VarDecl::DeclarationOnly)980        continue;981      if (VD->isExternallyVisible() &&982          !isExternalWithNoLinkageType(VD) &&983          !VD->getMostRecentDecl()->isInline() &&984          !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())985        continue;986 987      // Skip VarDecls that lack formal definitions but which we know are in988      // fact defined somewhere.989      if (VD->isKnownToBeDefined())990        continue;991    }992 993    Undefined.push_back(std::make_pair(ND, UndefinedUse.second));994  }995}996 997/// checkUndefinedButUsed - Check for undefined objects with internal linkage998/// or that are inline.999static void checkUndefinedButUsed(Sema &S) {1000  if (S.UndefinedButUsed.empty()) return;1001 1002  // Collect all the still-undefined entities with internal linkage.1003  SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;1004  S.getUndefinedButUsed(Undefined);1005  S.UndefinedButUsed.clear();1006  if (Undefined.empty()) return;1007 1008  for (const auto &Undef : Undefined) {1009    ValueDecl *VD = cast<ValueDecl>(Undef.first);1010    SourceLocation UseLoc = Undef.second;1011 1012    if (S.isExternalWithNoLinkageType(VD)) {1013      // C++ [basic.link]p8:1014      //   A type without linkage shall not be used as the type of a variable1015      //   or function with external linkage unless1016      //    -- the entity has C language linkage1017      //    -- the entity is not odr-used or is defined in the same TU1018      //1019      // As an extension, accept this in cases where the type is externally1020      // visible, since the function or variable actually can be defined in1021      // another translation unit in that case.1022      S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())1023                                    ? diag::ext_undefined_internal_type1024                                    : diag::err_undefined_internal_type)1025        << isa<VarDecl>(VD) << VD;1026    } else if (!VD->isExternallyVisible()) {1027      // FIXME: We can promote this to an error. The function or variable can't1028      // be defined anywhere else, so the program must necessarily violate the1029      // one definition rule.1030      bool IsImplicitBase = false;1031      if (const auto *BaseD = dyn_cast<FunctionDecl>(VD)) {1032        auto *DVAttr = BaseD->getAttr<OMPDeclareVariantAttr>();1033        if (DVAttr && !DVAttr->getTraitInfo().isExtensionActive(1034                          llvm::omp::TraitProperty::1035                              implementation_extension_disable_implicit_base)) {1036          const auto *Func = cast<FunctionDecl>(1037              cast<DeclRefExpr>(DVAttr->getVariantFuncRef())->getDecl());1038          IsImplicitBase = BaseD->isImplicit() &&1039                           Func->getIdentifier()->isMangledOpenMPVariantName();1040        }1041      }1042      if (!S.getLangOpts().OpenMP || !IsImplicitBase)1043        S.Diag(VD->getLocation(), diag::warn_undefined_internal)1044            << isa<VarDecl>(VD) << VD;1045    } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {1046      (void)FD;1047      assert(FD->getMostRecentDecl()->isInlined() &&1048             "used object requires definition but isn't inline or internal?");1049      // FIXME: This is ill-formed; we should reject.1050      S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;1051    } else {1052      assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&1053             "used var requires definition but isn't inline or internal?");1054      S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;1055    }1056    if (UseLoc.isValid())1057      S.Diag(UseLoc, diag::note_used_here);1058  }1059}1060 1061void Sema::LoadExternalWeakUndeclaredIdentifiers() {1062  if (!ExternalSource)1063    return;1064 1065  SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;1066  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);1067  for (auto &WeakID : WeakIDs)1068    (void)WeakUndeclaredIdentifiers[WeakID.first].insert(WeakID.second);1069}1070 1071 1072typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;1073 1074/// Returns true, if all methods and nested classes of the given1075/// CXXRecordDecl are defined in this translation unit.1076///1077/// Should only be called from ActOnEndOfTranslationUnit so that all1078/// definitions are actually read.1079static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,1080                                            RecordCompleteMap &MNCComplete) {1081  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);1082  if (Cache != MNCComplete.end())1083    return Cache->second;1084  if (!RD->isCompleteDefinition())1085    return false;1086  bool Complete = true;1087  for (DeclContext::decl_iterator I = RD->decls_begin(),1088                                  E = RD->decls_end();1089       I != E && Complete; ++I) {1090    if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))1091      Complete = M->isDefined() || M->isDefaulted() ||1092                 (M->isPureVirtual() && !isa<CXXDestructorDecl>(M));1093    else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))1094      // If the template function is marked as late template parsed at this1095      // point, it has not been instantiated and therefore we have not1096      // performed semantic analysis on it yet, so we cannot know if the type1097      // can be considered complete.1098      Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&1099                  F->getTemplatedDecl()->isDefined();1100    else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {1101      if (R->isInjectedClassName())1102        continue;1103      if (R->hasDefinition())1104        Complete = MethodsAndNestedClassesComplete(R->getDefinition(),1105                                                   MNCComplete);1106      else1107        Complete = false;1108    }1109  }1110  MNCComplete[RD] = Complete;1111  return Complete;1112}1113 1114/// Returns true, if the given CXXRecordDecl is fully defined in this1115/// translation unit, i.e. all methods are defined or pure virtual and all1116/// friends, friend functions and nested classes are fully defined in this1117/// translation unit.1118///1119/// Should only be called from ActOnEndOfTranslationUnit so that all1120/// definitions are actually read.1121static bool IsRecordFullyDefined(const CXXRecordDecl *RD,1122                                 RecordCompleteMap &RecordsComplete,1123                                 RecordCompleteMap &MNCComplete) {1124  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);1125  if (Cache != RecordsComplete.end())1126    return Cache->second;1127  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);1128  for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),1129                                      E = RD->friend_end();1130       I != E && Complete; ++I) {1131    // Check if friend classes and methods are complete.1132    if (TypeSourceInfo *TSI = (*I)->getFriendType()) {1133      // Friend classes are available as the TypeSourceInfo of the FriendDecl.1134      if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())1135        Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);1136      else1137        Complete = false;1138    } else {1139      // Friend functions are available through the NamedDecl of FriendDecl.1140      if (const FunctionDecl *FD =1141          dyn_cast<FunctionDecl>((*I)->getFriendDecl()))1142        Complete = FD->isDefined();1143      else1144        // This is a template friend, give up.1145        Complete = false;1146    }1147  }1148  RecordsComplete[RD] = Complete;1149  return Complete;1150}1151 1152void Sema::emitAndClearUnusedLocalTypedefWarnings() {1153  if (ExternalSource)1154    ExternalSource->ReadUnusedLocalTypedefNameCandidates(1155        UnusedLocalTypedefNameCandidates);1156  for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {1157    if (TD->isReferenced())1158      continue;1159    Diag(TD->getLocation(), diag::warn_unused_local_typedef)1160        << isa<TypeAliasDecl>(TD) << TD->getDeclName();1161  }1162  UnusedLocalTypedefNameCandidates.clear();1163}1164 1165void Sema::ActOnStartOfTranslationUnit() {1166  if (getLangOpts().CPlusPlusModules &&1167      getLangOpts().getCompilingModule() == LangOptions::CMK_HeaderUnit)1168    HandleStartOfHeaderUnit();1169}1170 1171void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {1172  if (Kind == TUFragmentKind::Global) {1173    // Perform Pending Instantiations at the end of global module fragment so1174    // that the module ownership of TU-level decls won't get messed.1175    llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");1176    PerformPendingInstantiations();1177    return;1178  }1179 1180  // Transfer late parsed template instantiations over to the pending template1181  // instantiation list. During normal compilation, the late template parser1182  // will be installed and instantiating these templates will succeed.1183  //1184  // If we are building a TU prefix for serialization, it is also safe to1185  // transfer these over, even though they are not parsed. The end of the TU1186  // should be outside of any eager template instantiation scope, so when this1187  // AST is deserialized, these templates will not be parsed until the end of1188  // the combined TU.1189  PendingInstantiations.insert(PendingInstantiations.end(),1190                               LateParsedInstantiations.begin(),1191                               LateParsedInstantiations.end());1192  LateParsedInstantiations.clear();1193 1194  // If DefinedUsedVTables ends up marking any virtual member functions it1195  // might lead to more pending template instantiations, which we then need1196  // to instantiate.1197  DefineUsedVTables();1198 1199  // C++: Perform implicit template instantiations.1200  //1201  // FIXME: When we perform these implicit instantiations, we do not1202  // carefully keep track of the point of instantiation (C++ [temp.point]).1203  // This means that name lookup that occurs within the template1204  // instantiation will always happen at the end of the translation unit,1205  // so it will find some names that are not required to be found. This is1206  // valid, but we could do better by diagnosing if an instantiation uses a1207  // name that was not visible at its first point of instantiation.1208  if (ExternalSource) {1209    // Load pending instantiations from the external source.1210    SmallVector<PendingImplicitInstantiation, 4> Pending;1211    ExternalSource->ReadPendingInstantiations(Pending);1212    for (auto PII : Pending)1213      if (auto Func = dyn_cast<FunctionDecl>(PII.first))1214        Func->setInstantiationIsPending(true);1215    PendingInstantiations.insert(PendingInstantiations.begin(),1216                                 Pending.begin(), Pending.end());1217  }1218 1219  {1220    llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");1221    PerformPendingInstantiations();1222  }1223 1224  emitDeferredDiags();1225 1226  assert(LateParsedInstantiations.empty() &&1227         "end of TU template instantiation should not create more "1228         "late-parsed templates");1229}1230 1231void Sema::ActOnEndOfTranslationUnit() {1232  assert(DelayedDiagnostics.getCurrentPool() == nullptr1233         && "reached end of translation unit with a pool attached?");1234 1235  // If code completion is enabled, don't perform any end-of-translation-unit1236  // work.1237  if (PP.isCodeCompletionEnabled())1238    return;1239 1240  // Complete translation units and modules define vtables and perform implicit1241  // instantiations. PCH files do not.1242  if (TUKind != TU_Prefix) {1243    ObjC().DiagnoseUseOfUnimplementedSelectors();1244 1245    ActOnEndOfTranslationUnitFragment(1246        !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==1247                                     Module::PrivateModuleFragment1248            ? TUFragmentKind::Private1249            : TUFragmentKind::Normal);1250 1251    CheckDelayedMemberExceptionSpecs();1252  } else {1253    // If we are building a TU prefix for serialization, it is safe to transfer1254    // these over, even though they are not parsed. The end of the TU should be1255    // outside of any eager template instantiation scope, so when this AST is1256    // deserialized, these templates will not be parsed until the end of the1257    // combined TU.1258    PendingInstantiations.insert(PendingInstantiations.end(),1259                                 LateParsedInstantiations.begin(),1260                                 LateParsedInstantiations.end());1261    LateParsedInstantiations.clear();1262 1263    if (LangOpts.PCHInstantiateTemplates) {1264      llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");1265      PerformPendingInstantiations();1266    }1267  }1268 1269  DiagnoseUnterminatedPragmaAlignPack();1270  DiagnoseUnterminatedPragmaAttribute();1271  OpenMP().DiagnoseUnterminatedOpenMPDeclareTarget();1272  DiagnosePrecisionLossInComplexDivision();1273 1274  // All delayed member exception specs should be checked or we end up accepting1275  // incompatible declarations.1276  assert(DelayedOverridingExceptionSpecChecks.empty());1277  assert(DelayedEquivalentExceptionSpecChecks.empty());1278 1279  // All dllexport classes should have been processed already.1280  assert(DelayedDllExportClasses.empty());1281  assert(DelayedDllExportMemberFunctions.empty());1282 1283  // Remove file scoped decls that turned out to be used.1284  UnusedFileScopedDecls.erase(1285      std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),1286                     UnusedFileScopedDecls.end(),1287                     [this](const DeclaratorDecl *DD) {1288                       return ShouldRemoveFromUnused(this, DD);1289                     }),1290      UnusedFileScopedDecls.end());1291 1292  if (TUKind == TU_Prefix) {1293    // Translation unit prefixes don't need any of the checking below.1294    if (!PP.isIncrementalProcessingEnabled())1295      TUScope = nullptr;1296    return;1297  }1298 1299  // Check for #pragma weak identifiers that were never declared1300  LoadExternalWeakUndeclaredIdentifiers();1301  for (const auto &WeakIDs : WeakUndeclaredIdentifiers) {1302    if (WeakIDs.second.empty())1303      continue;1304 1305    Decl *PrevDecl = LookupSingleName(TUScope, WeakIDs.first, SourceLocation(),1306                                      LookupOrdinaryName);1307    if (PrevDecl != nullptr &&1308        !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))1309      for (const auto &WI : WeakIDs.second)1310        Diag(WI.getLocation(), diag::warn_attribute_wrong_decl_type)1311            << "'weak'" << /*isRegularKeyword=*/0 << ExpectedVariableOrFunction;1312    else1313      for (const auto &WI : WeakIDs.second)1314        Diag(WI.getLocation(), diag::warn_weak_identifier_undeclared)1315            << WeakIDs.first;1316  }1317 1318  if (LangOpts.CPlusPlus11 &&1319      !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))1320    CheckDelegatingCtorCycles();1321 1322  if (!Diags.hasErrorOccurred()) {1323    if (ExternalSource)1324      ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);1325    checkUndefinedButUsed(*this);1326  }1327 1328  // A global-module-fragment is only permitted within a module unit.1329  if (!ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==1330                                   Module::ExplicitGlobalModuleFragment) {1331    Diag(ModuleScopes.back().BeginLoc,1332         diag::err_module_declaration_missing_after_global_module_introducer);1333  } else if (getLangOpts().getCompilingModule() ==1334                 LangOptions::CMK_ModuleInterface &&1335             // We can't use ModuleScopes here since ModuleScopes is always1336             // empty if we're compiling the BMI.1337             !getASTContext().getCurrentNamedModule()) {1338    // If we are building a module interface unit, we should have seen the1339    // module declaration.1340    //1341    // FIXME: Make a better guess as to where to put the module declaration.1342    Diag(getSourceManager().getLocForStartOfFile(1343             getSourceManager().getMainFileID()),1344         diag::err_module_declaration_missing);1345  }1346 1347  // Now we can decide whether the modules we're building need an initializer.1348  if (Module *CurrentModule = getCurrentModule();1349      CurrentModule && CurrentModule->isInterfaceOrPartition()) {1350    auto DoesModNeedInit = [this](Module *M) {1351      if (!getASTContext().getModuleInitializers(M).empty())1352        return true;1353      for (auto [Exported, _] : M->Exports)1354        if (Exported->isNamedModuleInterfaceHasInit())1355          return true;1356      for (Module *I : M->Imports)1357        if (I->isNamedModuleInterfaceHasInit())1358          return true;1359 1360      return false;1361    };1362 1363    CurrentModule->NamedModuleHasInit =1364        DoesModNeedInit(CurrentModule) ||1365        llvm::any_of(CurrentModule->submodules(), DoesModNeedInit);1366  }1367 1368  if (TUKind == TU_ClangModule) {1369    // If we are building a module, resolve all of the exported declarations1370    // now.1371    if (Module *CurrentModule = PP.getCurrentModule()) {1372      ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();1373 1374      SmallVector<Module *, 2> Stack;1375      Stack.push_back(CurrentModule);1376      while (!Stack.empty()) {1377        Module *Mod = Stack.pop_back_val();1378 1379        // Resolve the exported declarations and conflicts.1380        // FIXME: Actually complain, once we figure out how to teach the1381        // diagnostic client to deal with complaints in the module map at this1382        // point.1383        ModMap.resolveExports(Mod, /*Complain=*/false);1384        ModMap.resolveUses(Mod, /*Complain=*/false);1385        ModMap.resolveConflicts(Mod, /*Complain=*/false);1386 1387        // Queue the submodules, so their exports will also be resolved.1388        auto SubmodulesRange = Mod->submodules();1389        Stack.append(SubmodulesRange.begin(), SubmodulesRange.end());1390      }1391    }1392 1393    // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for1394    // modules when they are built, not every time they are used.1395    emitAndClearUnusedLocalTypedefWarnings();1396  }1397 1398  // C++ standard modules. Diagnose cases where a function is declared inline1399  // in the module purview but has no definition before the end of the TU or1400  // the start of a Private Module Fragment (if one is present).1401  if (!PendingInlineFuncDecls.empty()) {1402    for (auto *D : PendingInlineFuncDecls) {1403      if (auto *FD = dyn_cast<FunctionDecl>(D)) {1404        bool DefInPMF = false;1405        if (auto *FDD = FD->getDefinition()) {1406          DefInPMF = FDD->getOwningModule()->isPrivateModule();1407          if (!DefInPMF)1408            continue;1409        }1410        Diag(FD->getLocation(), diag::err_export_inline_not_defined)1411            << DefInPMF;1412        // If we have a PMF it should be at the end of the ModuleScopes.1413        if (DefInPMF &&1414            ModuleScopes.back().Module->Kind == Module::PrivateModuleFragment) {1415          Diag(ModuleScopes.back().BeginLoc,1416               diag::note_private_module_fragment);1417        }1418      }1419    }1420    PendingInlineFuncDecls.clear();1421  }1422 1423  // C99 6.9.2p2:1424  //   A declaration of an identifier for an object that has file1425  //   scope without an initializer, and without a storage-class1426  //   specifier or with the storage-class specifier static,1427  //   constitutes a tentative definition. If a translation unit1428  //   contains one or more tentative definitions for an identifier,1429  //   and the translation unit contains no external definition for1430  //   that identifier, then the behavior is exactly as if the1431  //   translation unit contains a file scope declaration of that1432  //   identifier, with the composite type as of the end of the1433  //   translation unit, with an initializer equal to 0.1434  llvm::SmallPtrSet<VarDecl *, 32> Seen;1435  for (TentativeDefinitionsType::iterator1436           T = TentativeDefinitions.begin(ExternalSource.get()),1437           TEnd = TentativeDefinitions.end();1438       T != TEnd; ++T) {1439    VarDecl *VD = (*T)->getActingDefinition();1440 1441    // If the tentative definition was completed, getActingDefinition() returns1442    // null. If we've already seen this variable before, insert()'s second1443    // return value is false.1444    if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)1445      continue;1446 1447    if (const IncompleteArrayType *ArrayT1448        = Context.getAsIncompleteArrayType(VD->getType())) {1449      // Set the length of the array to 1 (C99 6.9.2p5).1450      Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);1451      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);1452      QualType T = Context.getConstantArrayType(1453          ArrayT->getElementType(), One, nullptr, ArraySizeModifier::Normal, 0);1454      VD->setType(T);1455    } else if (RequireCompleteType(VD->getLocation(), VD->getType(),1456                                   diag::err_tentative_def_incomplete_type))1457      VD->setInvalidDecl();1458 1459    // No initialization is performed for a tentative definition.1460    CheckCompleteVariableDeclaration(VD);1461 1462    // In C, if the definition is const-qualified and has no initializer, it1463    // is left uninitialized unless it has static or thread storage duration.1464    QualType Type = VD->getType();1465    if (!VD->isInvalidDecl() && !getLangOpts().CPlusPlus &&1466        Type.isConstQualified() && !VD->getAnyInitializer()) {1467      unsigned DiagID = diag::warn_default_init_const_unsafe;1468      if (VD->getStorageDuration() == SD_Static ||1469          VD->getStorageDuration() == SD_Thread)1470        DiagID = diag::warn_default_init_const;1471 1472      bool EmitCppCompat = !Diags.isIgnored(1473          diag::warn_cxx_compat_hack_fake_diagnostic_do_not_emit,1474          VD->getLocation());1475 1476      Diag(VD->getLocation(), DiagID) << Type << EmitCppCompat;1477    }1478 1479    // Notify the consumer that we've completed a tentative definition.1480    if (!VD->isInvalidDecl())1481      Consumer.CompleteTentativeDefinition(VD);1482  }1483 1484  // In incremental mode, tentative definitions belong to the current1485  // partial translation unit (PTU). Once they have been completed and1486  // emitted to codegen, drop them to prevent re-emission in future PTUs.1487  if (PP.isIncrementalProcessingEnabled())1488    TentativeDefinitions.erase(TentativeDefinitions.begin(ExternalSource.get()),1489                               TentativeDefinitions.end());1490 1491  for (auto *D : ExternalDeclarations) {1492    if (!D || D->isInvalidDecl() || D->getPreviousDecl() || !D->isUsed())1493      continue;1494 1495    Consumer.CompleteExternalDeclaration(D);1496  }1497 1498  if (LangOpts.HLSL)1499    HLSL().ActOnEndOfTranslationUnit(getASTContext().getTranslationUnitDecl());1500 1501  // If there were errors, disable 'unused' warnings since they will mostly be1502  // noise. Don't warn for a use from a module: either we should warn on all1503  // file-scope declarations in modules or not at all, but whether the1504  // declaration is used is immaterial.1505  if (!Diags.hasErrorOccurred() && TUKind != TU_ClangModule) {1506    // Output warning for unused file scoped decls.1507    for (UnusedFileScopedDeclsType::iterator1508             I = UnusedFileScopedDecls.begin(ExternalSource.get()),1509             E = UnusedFileScopedDecls.end();1510         I != E; ++I) {1511      if (ShouldRemoveFromUnused(this, *I))1512        continue;1513 1514      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {1515        const FunctionDecl *DiagD;1516        if (!FD->hasBody(DiagD))1517          DiagD = FD;1518        if (DiagD->isDeleted())1519          continue; // Deleted functions are supposed to be unused.1520        SourceRange DiagRange = DiagD->getLocation();1521        if (const ASTTemplateArgumentListInfo *ASTTAL =1522                DiagD->getTemplateSpecializationArgsAsWritten())1523          DiagRange.setEnd(ASTTAL->RAngleLoc);1524        if (DiagD->isReferenced()) {1525          if (isa<CXXMethodDecl>(DiagD))1526            Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)1527                << DiagD << DiagRange;1528          else {1529            if (FD->getStorageClass() == SC_Static &&1530                !FD->isInlineSpecified() &&1531                !SourceMgr.isInMainFile(1532                   SourceMgr.getExpansionLoc(FD->getLocation())))1533              Diag(DiagD->getLocation(),1534                   diag::warn_unneeded_static_internal_decl)1535                  << DiagD << DiagRange;1536            else1537              Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)1538                  << /*function=*/0 << DiagD << DiagRange;1539          }1540        } else if (!FD->isTargetMultiVersion() ||1541                   FD->isTargetMultiVersionDefault()) {1542          if (FD->getDescribedFunctionTemplate())1543            Diag(DiagD->getLocation(), diag::warn_unused_template)1544                << /*function=*/0 << DiagD << DiagRange;1545          else1546            Diag(DiagD->getLocation(), isa<CXXMethodDecl>(DiagD)1547                                           ? diag::warn_unused_member_function1548                                           : diag::warn_unused_function)1549                << DiagD << DiagRange;1550        }1551      } else {1552        const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();1553        if (!DiagD)1554          DiagD = cast<VarDecl>(*I);1555        SourceRange DiagRange = DiagD->getLocation();1556        if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(DiagD)) {1557          if (const ASTTemplateArgumentListInfo *ASTTAL =1558                  VTSD->getTemplateArgsAsWritten())1559            DiagRange.setEnd(ASTTAL->RAngleLoc);1560        }1561        if (DiagD->isReferenced()) {1562          Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)1563              << /*variable=*/1 << DiagD << DiagRange;1564        } else if (DiagD->getDescribedVarTemplate()) {1565          Diag(DiagD->getLocation(), diag::warn_unused_template)1566              << /*variable=*/1 << DiagD << DiagRange;1567        } else if (DiagD->getType().isConstQualified()) {1568          const SourceManager &SM = SourceMgr;1569          if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||1570              !PP.getLangOpts().IsHeaderFile)1571            Diag(DiagD->getLocation(), diag::warn_unused_const_variable)1572                << DiagD << DiagRange;1573        } else {1574          Diag(DiagD->getLocation(), diag::warn_unused_variable)1575              << DiagD << DiagRange;1576        }1577      }1578    }1579 1580    emitAndClearUnusedLocalTypedefWarnings();1581  }1582 1583  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {1584    // FIXME: Load additional unused private field candidates from the external1585    // source.1586    RecordCompleteMap RecordsComplete;1587    RecordCompleteMap MNCComplete;1588    for (const NamedDecl *D : UnusedPrivateFields) {1589      const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());1590      if (RD && !RD->isUnion() &&1591          IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {1592        Diag(D->getLocation(), diag::warn_unused_private_field)1593              << D->getDeclName();1594      }1595    }1596  }1597 1598  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {1599    if (ExternalSource)1600      ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);1601    for (const auto &DeletedFieldInfo : DeleteExprs) {1602      for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {1603        AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,1604                                  DeleteExprLoc.second);1605      }1606    }1607  }1608 1609  AnalysisWarnings.IssueWarnings(Context.getTranslationUnitDecl());1610 1611  if (Context.hasAnyFunctionEffects())1612    performFunctionEffectAnalysis(Context.getTranslationUnitDecl());1613 1614  // Check we've noticed that we're no longer parsing the initializer for every1615  // variable. If we miss cases, then at best we have a performance issue and1616  // at worst a rejects-valid bug.1617  assert(ParsingInitForAutoVars.empty() &&1618         "Didn't unmark var as having its initializer parsed");1619 1620  if (!PP.isIncrementalProcessingEnabled())1621    TUScope = nullptr;1622 1623  checkExposure(Context.getTranslationUnitDecl());1624}1625 1626 1627//===----------------------------------------------------------------------===//1628// Helper functions.1629//===----------------------------------------------------------------------===//1630 1631DeclContext *Sema::getFunctionLevelDeclContext(bool AllowLambda) const {1632  DeclContext *DC = CurContext;1633 1634  while (true) {1635    if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC) ||1636        isa<RequiresExprBodyDecl>(DC)) {1637      DC = DC->getParent();1638    } else if (!AllowLambda && isa<CXXMethodDecl>(DC) &&1639               cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&1640               cast<CXXRecordDecl>(DC->getParent())->isLambda()) {1641      DC = DC->getParent()->getParent();1642    } else break;1643  }1644 1645  return DC;1646}1647 1648/// getCurFunctionDecl - If inside of a function body, this returns a pointer1649/// to the function decl for the function being parsed.  If we're currently1650/// in a 'block', this returns the containing context.1651FunctionDecl *Sema::getCurFunctionDecl(bool AllowLambda) const {1652  DeclContext *DC = getFunctionLevelDeclContext(AllowLambda);1653  return dyn_cast<FunctionDecl>(DC);1654}1655 1656ObjCMethodDecl *Sema::getCurMethodDecl() {1657  DeclContext *DC = getFunctionLevelDeclContext();1658  while (isa<RecordDecl>(DC))1659    DC = DC->getParent();1660  return dyn_cast<ObjCMethodDecl>(DC);1661}1662 1663NamedDecl *Sema::getCurFunctionOrMethodDecl() const {1664  DeclContext *DC = getFunctionLevelDeclContext();1665  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))1666    return cast<NamedDecl>(DC);1667  return nullptr;1668}1669 1670LangAS Sema::getDefaultCXXMethodAddrSpace() const {1671  if (getLangOpts().OpenCL)1672    return getASTContext().getDefaultOpenCLPointeeAddrSpace();1673  return LangAS::Default;1674}1675 1676void Sema::EmitDiagnostic(unsigned DiagID, const DiagnosticBuilder &DB) {1677  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here1678  // and yet we also use the current diag ID on the DiagnosticsEngine. This has1679  // been made more painfully obvious by the refactor that introduced this1680  // function, but it is possible that the incoming argument can be1681  // eliminated. If it truly cannot be (for example, there is some reentrancy1682  // issue I am not seeing yet), then there should at least be a clarifying1683  // comment somewhere.1684  Diagnostic DiagInfo(&Diags, DB);1685  if (SFINAETrap *Trap = getSFINAEContext()) {1686    sema::TemplateDeductionInfo *Info = Trap->getDeductionInfo();1687    switch (DiagnosticIDs::getDiagnosticSFINAEResponse(DiagInfo.getID())) {1688    case DiagnosticIDs::SFINAE_Report:1689      // We'll report the diagnostic below.1690      break;1691 1692    case DiagnosticIDs::SFINAE_SubstitutionFailure:1693      // Count this failure so that we know that template argument deduction1694      // has failed.1695      Trap->setErrorOccurred();1696 1697      // Make a copy of this suppressed diagnostic and store it with the1698      // template-deduction information.1699      if (Info && !Info->hasSFINAEDiagnostic())1700        Info->addSFINAEDiagnostic(1701            DiagInfo.getLocation(),1702            PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));1703 1704      Diags.setLastDiagnosticIgnored(true);1705      return;1706 1707    case DiagnosticIDs::SFINAE_AccessControl: {1708      // Per C++ Core Issue 1170, access control is part of SFINAE.1709      // Additionally, the WithAccessChecking flag can be used to temporarily1710      // make access control a part of SFINAE for the purposes of checking1711      // type traits.1712      if (!Trap->withAccessChecking() && !getLangOpts().CPlusPlus11)1713        break;1714 1715      SourceLocation Loc = DiagInfo.getLocation();1716 1717      // Suppress this diagnostic.1718      Trap->setErrorOccurred();1719 1720      // Make a copy of this suppressed diagnostic and store it with the1721      // template-deduction information.1722      if (Info && !Info->hasSFINAEDiagnostic())1723        Info->addSFINAEDiagnostic(1724            DiagInfo.getLocation(),1725            PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));1726 1727      Diags.setLastDiagnosticIgnored(true);1728 1729      // Now produce a C++98 compatibility warning.1730      Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);1731 1732      // The last diagnostic which Sema produced was ignored. Suppress any1733      // notes attached to it.1734      Diags.setLastDiagnosticIgnored(true);1735      return;1736    }1737 1738    case DiagnosticIDs::SFINAE_Suppress:1739      if (DiagnosticsEngine::Level Level = getDiagnostics().getDiagnosticLevel(1740              DiagInfo.getID(), DiagInfo.getLocation());1741          Level == DiagnosticsEngine::Ignored)1742        return;1743      // Make a copy of this suppressed diagnostic and store it with the1744      // template-deduction information;1745      if (Info) {1746        Info->addSuppressedDiagnostic(1747            DiagInfo.getLocation(),1748            PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));1749        if (!Diags.getDiagnosticIDs()->isNote(DiagID))1750          PrintContextStack([Info](SourceLocation Loc, PartialDiagnostic PD) {1751            Info->addSuppressedDiagnostic(Loc, std::move(PD));1752          });1753      }1754 1755      // Suppress this diagnostic.1756      Diags.setLastDiagnosticIgnored(true);1757      return;1758    }1759  }1760 1761  // Copy the diagnostic printing policy over the ASTContext printing policy.1762  // TODO: Stop doing that.  See: https://reviews.llvm.org/D45093#10902921763  Context.setPrintingPolicy(getPrintingPolicy());1764 1765  // Emit the diagnostic.1766  if (!Diags.EmitDiagnostic(DB))1767    return;1768 1769  // If this is not a note, and we're in a template instantiation1770  // that is different from the last template instantiation where1771  // we emitted an error, print a template instantiation1772  // backtrace.1773  if (!Diags.getDiagnosticIDs()->isNote(DiagID))1774    PrintContextStack();1775}1776 1777bool Sema::hasUncompilableErrorOccurred() const {1778  if (getDiagnostics().hasUncompilableErrorOccurred())1779    return true;1780  auto *FD = dyn_cast<FunctionDecl>(CurContext);1781  if (!FD)1782    return false;1783  auto Loc = DeviceDeferredDiags.find(FD);1784  if (Loc == DeviceDeferredDiags.end())1785    return false;1786  for (auto PDAt : Loc->second) {1787    if (Diags.getDiagnosticIDs()->isDefaultMappingAsError(1788            PDAt.second.getDiagID()))1789      return true;1790  }1791  return false;1792}1793 1794// Print notes showing how we can reach FD starting from an a priori1795// known-callable function.1796static void emitCallStackNotes(Sema &S, const FunctionDecl *FD) {1797  auto FnIt = S.CUDA().DeviceKnownEmittedFns.find(FD);1798  while (FnIt != S.CUDA().DeviceKnownEmittedFns.end()) {1799    // Respect error limit.1800    if (S.Diags.hasFatalErrorOccurred())1801      return;1802    DiagnosticBuilder Builder(1803        S.Diags.Report(FnIt->second.Loc, diag::note_called_by));1804    Builder << FnIt->second.FD;1805    FnIt = S.CUDA().DeviceKnownEmittedFns.find(FnIt->second.FD);1806  }1807}1808 1809namespace {1810 1811/// Helper class that emits deferred diagnostic messages if an entity directly1812/// or indirectly using the function that causes the deferred diagnostic1813/// messages is known to be emitted.1814///1815/// During parsing of AST, certain diagnostic messages are recorded as deferred1816/// diagnostics since it is unknown whether the functions containing such1817/// diagnostics will be emitted. A list of potentially emitted functions and1818/// variables that may potentially trigger emission of functions are also1819/// recorded. DeferredDiagnosticsEmitter recursively visits used functions1820/// by each function to emit deferred diagnostics.1821///1822/// During the visit, certain OpenMP directives or initializer of variables1823/// with certain OpenMP attributes will cause subsequent visiting of any1824/// functions enter a state which is called OpenMP device context in this1825/// implementation. The state is exited when the directive or initializer is1826/// exited. This state can change the emission states of subsequent uses1827/// of functions.1828///1829/// Conceptually the functions or variables to be visited form a use graph1830/// where the parent node uses the child node. At any point of the visit,1831/// the tree nodes traversed from the tree root to the current node form a use1832/// stack. The emission state of the current node depends on two factors:1833///    1. the emission state of the root node1834///    2. whether the current node is in OpenMP device context1835/// If the function is decided to be emitted, its contained deferred diagnostics1836/// are emitted, together with the information about the use stack.1837///1838class DeferredDiagnosticsEmitter1839    : public UsedDeclVisitor<DeferredDiagnosticsEmitter> {1840public:1841  typedef UsedDeclVisitor<DeferredDiagnosticsEmitter> Inherited;1842 1843  // Whether the function is already in the current use-path.1844  llvm::SmallPtrSet<CanonicalDeclPtr<Decl>, 4> InUsePath;1845 1846  // The current use-path.1847  llvm::SmallVector<CanonicalDeclPtr<FunctionDecl>, 4> UsePath;1848 1849  // Whether the visiting of the function has been done. Done[0] is for the1850  // case not in OpenMP device context. Done[1] is for the case in OpenMP1851  // device context. We need two sets because diagnostics emission may be1852  // different depending on whether it is in OpenMP device context.1853  llvm::SmallPtrSet<CanonicalDeclPtr<Decl>, 4> DoneMap[2];1854 1855  // Emission state of the root node of the current use graph.1856  bool ShouldEmitRootNode;1857 1858  // Current OpenMP device context level. It is initialized to 0 and each1859  // entering of device context increases it by 1 and each exit decreases1860  // it by 1. Non-zero value indicates it is currently in device context.1861  unsigned InOMPDeviceContext;1862 1863  DeferredDiagnosticsEmitter(Sema &S)1864      : Inherited(S), ShouldEmitRootNode(false), InOMPDeviceContext(0) {}1865 1866  bool shouldVisitDiscardedStmt() const { return false; }1867 1868  void VisitOMPTargetDirective(OMPTargetDirective *Node) {1869    ++InOMPDeviceContext;1870    Inherited::VisitOMPTargetDirective(Node);1871    --InOMPDeviceContext;1872  }1873 1874  void visitUsedDecl(SourceLocation Loc, Decl *D) {1875    if (isa<VarDecl>(D))1876      return;1877    if (auto *FD = dyn_cast<FunctionDecl>(D))1878      checkFunc(Loc, FD);1879    else1880      Inherited::visitUsedDecl(Loc, D);1881  }1882 1883  // Visitor member and parent dtors called by this dtor.1884  void VisitCalledDestructors(CXXDestructorDecl *DD) {1885    const CXXRecordDecl *RD = DD->getParent();1886 1887    // Visit the dtors of all members1888    for (const FieldDecl *FD : RD->fields()) {1889      QualType FT = FD->getType();1890      if (const auto *ClassDecl = FT->getAsCXXRecordDecl();1891          ClassDecl &&1892          (ClassDecl->isBeingDefined() || ClassDecl->isCompleteDefinition()))1893        if (CXXDestructorDecl *MemberDtor = ClassDecl->getDestructor())1894          asImpl().visitUsedDecl(MemberDtor->getLocation(), MemberDtor);1895    }1896 1897    // Also visit base class dtors1898    for (const auto &Base : RD->bases()) {1899      QualType BaseType = Base.getType();1900      if (const auto *BaseDecl = BaseType->getAsCXXRecordDecl();1901          BaseDecl &&1902          (BaseDecl->isBeingDefined() || BaseDecl->isCompleteDefinition()))1903        if (CXXDestructorDecl *BaseDtor = BaseDecl->getDestructor())1904          asImpl().visitUsedDecl(BaseDtor->getLocation(), BaseDtor);1905    }1906  }1907 1908  void VisitDeclStmt(DeclStmt *DS) {1909    // Visit dtors called by variables that need destruction1910    for (auto *D : DS->decls())1911      if (auto *VD = dyn_cast<VarDecl>(D))1912        if (VD->isThisDeclarationADefinition() &&1913            VD->needsDestruction(S.Context)) {1914          QualType VT = VD->getType();1915          if (const auto *ClassDecl = VT->getAsCXXRecordDecl();1916              ClassDecl && (ClassDecl->isBeingDefined() ||1917                            ClassDecl->isCompleteDefinition()))1918            if (CXXDestructorDecl *Dtor = ClassDecl->getDestructor())1919              asImpl().visitUsedDecl(Dtor->getLocation(), Dtor);1920        }1921 1922    Inherited::VisitDeclStmt(DS);1923  }1924  void checkVar(VarDecl *VD) {1925    assert(VD->isFileVarDecl() &&1926           "Should only check file-scope variables");1927    if (auto *Init = VD->getInit()) {1928      auto DevTy = OMPDeclareTargetDeclAttr::getDeviceType(VD);1929      bool IsDev = DevTy && (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost ||1930                             *DevTy == OMPDeclareTargetDeclAttr::DT_Any);1931      if (IsDev)1932        ++InOMPDeviceContext;1933      this->Visit(Init);1934      if (IsDev)1935        --InOMPDeviceContext;1936    }1937  }1938 1939  void checkFunc(SourceLocation Loc, FunctionDecl *FD) {1940    auto &Done = DoneMap[InOMPDeviceContext > 0 ? 1 : 0];1941    FunctionDecl *Caller = UsePath.empty() ? nullptr : UsePath.back();1942    if ((!ShouldEmitRootNode && !S.getLangOpts().OpenMP && !Caller) ||1943        S.shouldIgnoreInHostDeviceCheck(FD) || InUsePath.count(FD))1944      return;1945    // Finalize analysis of OpenMP-specific constructs.1946    if (Caller && S.LangOpts.OpenMP && UsePath.size() == 1 &&1947        (ShouldEmitRootNode || InOMPDeviceContext))1948      S.OpenMP().finalizeOpenMPDelayedAnalysis(Caller, FD, Loc);1949    if (Caller)1950      S.CUDA().DeviceKnownEmittedFns[FD] = {Caller, Loc};1951    // Always emit deferred diagnostics for the direct users. This does not1952    // lead to explosion of diagnostics since each user is visited at most1953    // twice.1954    if (ShouldEmitRootNode || InOMPDeviceContext)1955      emitDeferredDiags(FD, Caller);1956    // Do not revisit a function if the function body has been completely1957    // visited before.1958    if (!Done.insert(FD).second)1959      return;1960    InUsePath.insert(FD);1961    UsePath.push_back(FD);1962    if (auto *S = FD->getBody()) {1963      this->Visit(S);1964    }1965    if (CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(FD))1966      asImpl().VisitCalledDestructors(Dtor);1967    UsePath.pop_back();1968    InUsePath.erase(FD);1969  }1970 1971  void checkRecordedDecl(Decl *D) {1972    if (auto *FD = dyn_cast<FunctionDecl>(D)) {1973      ShouldEmitRootNode = S.getEmissionStatus(FD, /*Final=*/true) ==1974                           Sema::FunctionEmissionStatus::Emitted;1975      checkFunc(SourceLocation(), FD);1976    } else1977      checkVar(cast<VarDecl>(D));1978  }1979 1980  // Emit any deferred diagnostics for FD1981  void emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack) {1982    auto It = S.DeviceDeferredDiags.find(FD);1983    if (It == S.DeviceDeferredDiags.end())1984      return;1985    bool HasWarningOrError = false;1986    bool FirstDiag = true;1987    for (PartialDiagnosticAt &PDAt : It->second) {1988      // Respect error limit.1989      if (S.Diags.hasFatalErrorOccurred())1990        return;1991      const SourceLocation &Loc = PDAt.first;1992      const PartialDiagnostic &PD = PDAt.second;1993      HasWarningOrError |=1994          S.getDiagnostics().getDiagnosticLevel(PD.getDiagID(), Loc) >=1995          DiagnosticsEngine::Warning;1996      {1997        DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));1998        PD.Emit(Builder);1999      }2000      // Emit the note on the first diagnostic in case too many diagnostics2001      // cause the note not emitted.2002      if (FirstDiag && HasWarningOrError && ShowCallStack) {2003        emitCallStackNotes(S, FD);2004        FirstDiag = false;2005      }2006    }2007  }2008};2009} // namespace2010 2011void Sema::emitDeferredDiags() {2012  if (ExternalSource)2013    ExternalSource->ReadDeclsToCheckForDeferredDiags(2014        DeclsToCheckForDeferredDiags);2015 2016  if ((DeviceDeferredDiags.empty() && !LangOpts.OpenMP) ||2017      DeclsToCheckForDeferredDiags.empty())2018    return;2019 2020  DeferredDiagnosticsEmitter DDE(*this);2021  for (auto *D : DeclsToCheckForDeferredDiags)2022    DDE.checkRecordedDecl(D);2023}2024 2025// In CUDA, there are some constructs which may appear in semantically-valid2026// code, but trigger errors if we ever generate code for the function in which2027// they appear.  Essentially every construct you're not allowed to use on the2028// device falls into this category, because you are allowed to use these2029// constructs in a __host__ __device__ function, but only if that function is2030// never codegen'ed on the device.2031//2032// To handle semantic checking for these constructs, we keep track of the set of2033// functions we know will be emitted, either because we could tell a priori that2034// they would be emitted, or because they were transitively called by a2035// known-emitted function.2036//2037// We also keep a partial call graph of which not-known-emitted functions call2038// which other not-known-emitted functions.2039//2040// When we see something which is illegal if the current function is emitted2041// (usually by way of DiagIfDeviceCode, DiagIfHostCode, or2042// CheckCall), we first check if the current function is known-emitted.  If2043// so, we immediately output the diagnostic.2044//2045// Otherwise, we "defer" the diagnostic.  It sits in Sema::DeviceDeferredDiags2046// until we discover that the function is known-emitted, at which point we take2047// it out of this map and emit the diagnostic.2048 2049Sema::SemaDiagnosticBuilder::SemaDiagnosticBuilder(Kind K, SourceLocation Loc,2050                                                   unsigned DiagID,2051                                                   const FunctionDecl *Fn,2052                                                   Sema &S)2053    : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),2054      ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {2055  switch (K) {2056  case K_Nop:2057    break;2058  case K_Immediate:2059  case K_ImmediateWithCallStack:2060    ImmediateDiag.emplace(2061        ImmediateDiagBuilder(S.Diags.Report(Loc, DiagID), S, DiagID));2062    break;2063  case K_Deferred:2064    assert(Fn && "Must have a function to attach the deferred diag to.");2065    auto &Diags = S.DeviceDeferredDiags[Fn];2066    PartialDiagId.emplace(Diags.size());2067    Diags.emplace_back(Loc, S.PDiag(DiagID));2068    break;2069  }2070}2071 2072Sema::SemaDiagnosticBuilder::SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D)2073    : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),2074      ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),2075      PartialDiagId(D.PartialDiagId) {2076  // Clean the previous diagnostics.2077  D.ShowCallStack = false;2078  D.ImmediateDiag.reset();2079  D.PartialDiagId.reset();2080}2081 2082Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {2083  if (ImmediateDiag) {2084    // Emit our diagnostic and, if it was a warning or error, output a callstack2085    // if Fn isn't a priori known-emitted.2086    ImmediateDiag.reset(); // Emit the immediate diag.2087 2088    if (ShowCallStack) {2089      bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(2090                                  DiagID, Loc) >= DiagnosticsEngine::Warning;2091      if (IsWarningOrError)2092        emitCallStackNotes(S, Fn);2093    }2094  } else {2095    assert((!PartialDiagId || ShowCallStack) &&2096           "Must always show call stack for deferred diags.");2097  }2098}2099 2100Sema::SemaDiagnosticBuilder2101Sema::targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD) {2102  FD = FD ? FD : getCurFunctionDecl();2103  if (LangOpts.OpenMP)2104    return LangOpts.OpenMPIsTargetDevice2105               ? OpenMP().diagIfOpenMPDeviceCode(Loc, DiagID, FD)2106               : OpenMP().diagIfOpenMPHostCode(Loc, DiagID, FD);2107  if (getLangOpts().CUDA)2108    return getLangOpts().CUDAIsDevice ? CUDA().DiagIfDeviceCode(Loc, DiagID)2109                                      : CUDA().DiagIfHostCode(Loc, DiagID);2110 2111  if (getLangOpts().SYCLIsDevice)2112    return SYCL().DiagIfDeviceCode(Loc, DiagID);2113 2114  return SemaDiagnosticBuilder(SemaDiagnosticBuilder::K_Immediate, Loc, DiagID,2115                               FD, *this);2116}2117 2118void Sema::checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D) {2119  if (isUnevaluatedContext() || Ty.isNull())2120    return;2121 2122  // The original idea behind checkTypeSupport function is that unused2123  // declarations can be replaced with an array of bytes of the same size during2124  // codegen, such replacement doesn't seem to be possible for types without2125  // constant byte size like zero length arrays. So, do a deep check for SYCL.2126  if (D && LangOpts.SYCLIsDevice) {2127    llvm::DenseSet<QualType> Visited;2128    SYCL().deepTypeCheckForDevice(Loc, Visited, D);2129  }2130 2131  Decl *C = cast<Decl>(getCurLexicalContext());2132 2133  // Memcpy operations for structs containing a member with unsupported type2134  // are ok, though.2135  if (const auto *MD = dyn_cast<CXXMethodDecl>(C)) {2136    if ((MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) &&2137        MD->isTrivial())2138      return;2139 2140    if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(MD))2141      if (Ctor->isCopyOrMoveConstructor() && Ctor->isTrivial())2142        return;2143  }2144 2145  // Try to associate errors with the lexical context, if that is a function, or2146  // the value declaration otherwise.2147  const FunctionDecl *FD = isa<FunctionDecl>(C)2148                               ? cast<FunctionDecl>(C)2149                               : dyn_cast_or_null<FunctionDecl>(D);2150 2151  auto CheckDeviceType = [&](QualType Ty) {2152    if (Ty->isDependentType())2153      return;2154 2155    if (Ty->isBitIntType()) {2156      if (!Context.getTargetInfo().hasBitIntType()) {2157        PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);2158        if (D)2159          PD << D;2160        else2161          PD << "expression";2162        targetDiag(Loc, PD, FD)2163            << false /*show bit size*/ << 0 /*bitsize*/ << false /*return*/2164            << Ty << Context.getTargetInfo().getTriple().str();2165      }2166      return;2167    }2168 2169    // Check if we are dealing with two 'long double' but with different2170    // semantics.2171    bool LongDoubleMismatched = false;2172    if (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128) {2173      const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(Ty);2174      if ((&Sem != &llvm::APFloat::PPCDoubleDouble() &&2175           !Context.getTargetInfo().hasFloat128Type()) ||2176          (&Sem == &llvm::APFloat::PPCDoubleDouble() &&2177           !Context.getTargetInfo().hasIbm128Type()))2178        LongDoubleMismatched = true;2179    }2180 2181    if ((Ty->isFloat16Type() && !Context.getTargetInfo().hasFloat16Type()) ||2182        (Ty->isFloat128Type() && !Context.getTargetInfo().hasFloat128Type()) ||2183        (Ty->isIbm128Type() && !Context.getTargetInfo().hasIbm128Type()) ||2184        (Ty->isIntegerType() && Context.getTypeSize(Ty) == 128 &&2185         !Context.getTargetInfo().hasInt128Type()) ||2186        (Ty->isBFloat16Type() && !Context.getTargetInfo().hasBFloat16Type() &&2187         !LangOpts.CUDAIsDevice) ||2188        LongDoubleMismatched) {2189      PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);2190      if (D)2191        PD << D;2192      else2193        PD << "expression";2194 2195      if (targetDiag(Loc, PD, FD)2196          << true /*show bit size*/2197          << static_cast<unsigned>(Context.getTypeSize(Ty)) << Ty2198          << false /*return*/ << Context.getTargetInfo().getTriple().str()) {2199        if (D)2200          D->setInvalidDecl();2201      }2202      if (D)2203        targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;2204    }2205  };2206 2207  auto CheckType = [&](QualType Ty, bool IsRetTy = false) {2208    if (LangOpts.SYCLIsDevice ||2209        (LangOpts.OpenMP && LangOpts.OpenMPIsTargetDevice) ||2210        LangOpts.CUDAIsDevice)2211      CheckDeviceType(Ty);2212 2213    QualType UnqualTy = Ty.getCanonicalType().getUnqualifiedType();2214    const TargetInfo &TI = Context.getTargetInfo();2215    if (!TI.hasLongDoubleType() && UnqualTy == Context.LongDoubleTy) {2216      PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);2217      if (D)2218        PD << D;2219      else2220        PD << "expression";2221 2222      if (Diag(Loc, PD) << false /*show bit size*/ << 0 << Ty2223                        << false /*return*/2224                        << TI.getTriple().str()) {2225        if (D)2226          D->setInvalidDecl();2227      }2228      if (D)2229        targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;2230    }2231 2232    bool IsDouble = UnqualTy == Context.DoubleTy;2233    bool IsFloat = UnqualTy == Context.FloatTy;2234    if (IsRetTy && !TI.hasFPReturn() && (IsDouble || IsFloat)) {2235      PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);2236      if (D)2237        PD << D;2238      else2239        PD << "expression";2240 2241      if (Diag(Loc, PD) << false /*show bit size*/ << 0 << Ty << true /*return*/2242                        << TI.getTriple().str()) {2243        if (D)2244          D->setInvalidDecl();2245      }2246      if (D)2247        targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;2248    }2249 2250    if (TI.hasRISCVVTypes() && Ty->isRVVSizelessBuiltinType() && FD) {2251      llvm::StringMap<bool> CallerFeatureMap;2252      Context.getFunctionFeatureMap(CallerFeatureMap, FD);2253      RISCV().checkRVVTypeSupport(Ty, Loc, D, CallerFeatureMap);2254    }2255 2256    // Don't allow SVE types in functions without a SVE target.2257    if (Ty->isSVESizelessBuiltinType() && FD) {2258      llvm::StringMap<bool> CallerFeatureMap;2259      Context.getFunctionFeatureMap(CallerFeatureMap, FD);2260      ARM().checkSVETypeSupport(Ty, Loc, FD, CallerFeatureMap);2261    }2262 2263    if (auto *VT = Ty->getAs<VectorType>();2264        VT && FD &&2265        (VT->getVectorKind() == VectorKind::SveFixedLengthData ||2266         VT->getVectorKind() == VectorKind::SveFixedLengthPredicate) &&2267        (LangOpts.VScaleMin != LangOpts.VScaleStreamingMin ||2268         LangOpts.VScaleMax != LangOpts.VScaleStreamingMax)) {2269      if (IsArmStreamingFunction(FD, /*IncludeLocallyStreaming=*/true)) {2270        Diag(Loc, diag::err_sve_fixed_vector_in_streaming_function)2271            << Ty << /*Streaming*/ 0;2272      } else if (const auto *FTy = FD->getType()->getAs<FunctionProtoType>()) {2273        if (FTy->getAArch64SMEAttributes() &2274            FunctionType::SME_PStateSMCompatibleMask) {2275          Diag(Loc, diag::err_sve_fixed_vector_in_streaming_function)2276              << Ty << /*StreamingCompatible*/ 1;2277        }2278      }2279    }2280  };2281 2282  CheckType(Ty);2283  if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {2284    for (const auto &ParamTy : FPTy->param_types())2285      CheckType(ParamTy);2286    CheckType(FPTy->getReturnType(), /*IsRetTy=*/true);2287  }2288  if (const auto *FNPTy = dyn_cast<FunctionNoProtoType>(Ty))2289    CheckType(FNPTy->getReturnType(), /*IsRetTy=*/true);2290}2291 2292bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {2293  SourceLocation loc = locref;2294  if (!loc.isMacroID()) return false;2295 2296  // There's no good way right now to look at the intermediate2297  // expansions, so just jump to the expansion location.2298  loc = getSourceManager().getExpansionLoc(loc);2299 2300  // If that's written with the name, stop here.2301  SmallString<16> buffer;2302  if (getPreprocessor().getSpelling(loc, buffer) == name) {2303    locref = loc;2304    return true;2305  }2306  return false;2307}2308 2309Scope *Sema::getScopeForContext(DeclContext *Ctx) {2310 2311  if (!Ctx)2312    return nullptr;2313 2314  Ctx = Ctx->getPrimaryContext();2315  for (Scope *S = getCurScope(); S; S = S->getParent()) {2316    // Ignore scopes that cannot have declarations. This is important for2317    // out-of-line definitions of static class members.2318    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))2319      if (DeclContext *Entity = S->getEntity())2320        if (Ctx == Entity->getPrimaryContext())2321          return S;2322  }2323 2324  return nullptr;2325}2326 2327/// Enter a new function scope2328void Sema::PushFunctionScope() {2329  if (FunctionScopes.empty() && CachedFunctionScope) {2330    // Use CachedFunctionScope to avoid allocating memory when possible.2331    CachedFunctionScope->Clear();2332    FunctionScopes.push_back(CachedFunctionScope.release());2333  } else {2334    FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));2335  }2336  if (LangOpts.OpenMP)2337    OpenMP().pushOpenMPFunctionRegion();2338}2339 2340void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {2341  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),2342                                              BlockScope, Block));2343  CapturingFunctionScopes++;2344}2345 2346LambdaScopeInfo *Sema::PushLambdaScope() {2347  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());2348  FunctionScopes.push_back(LSI);2349  CapturingFunctionScopes++;2350  return LSI;2351}2352 2353void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {2354  if (LambdaScopeInfo *const LSI = getCurLambda()) {2355    LSI->AutoTemplateParameterDepth = Depth;2356    return;2357  }2358  llvm_unreachable(2359      "Remove assertion if intentionally called in a non-lambda context.");2360}2361 2362// Check that the type of the VarDecl has an accessible copy constructor and2363// resolve its destructor's exception specification.2364// This also performs initialization of block variables when they are moved2365// to the heap. It uses the same rules as applicable for implicit moves2366// according to the C++ standard in effect ([class.copy.elision]p3).2367static void checkEscapingByref(VarDecl *VD, Sema &S) {2368  QualType T = VD->getType();2369  EnterExpressionEvaluationContext scope(2370      S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);2371  SourceLocation Loc = VD->getLocation();2372  Expr *VarRef =2373      new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);2374  ExprResult Result;2375  auto IE = InitializedEntity::InitializeBlock(Loc, T);2376  if (S.getLangOpts().CPlusPlus23) {2377    auto *E = ImplicitCastExpr::Create(S.Context, T, CK_NoOp, VarRef, nullptr,2378                                       VK_XValue, FPOptionsOverride());2379    Result = S.PerformCopyInitialization(IE, SourceLocation(), E);2380  } else {2381    Result = S.PerformMoveOrCopyInitialization(2382        IE, Sema::NamedReturnInfo{VD, Sema::NamedReturnInfo::MoveEligible},2383        VarRef);2384  }2385 2386  if (!Result.isInvalid()) {2387    Result = S.MaybeCreateExprWithCleanups(Result);2388    Expr *Init = Result.getAs<Expr>();2389    S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));2390  }2391 2392  // The destructor's exception specification is needed when IRGen generates2393  // block copy/destroy functions. Resolve it here.2394  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())2395    if (CXXDestructorDecl *DD = RD->getDestructor()) {2396      auto *FPT = DD->getType()->castAs<FunctionProtoType>();2397      S.ResolveExceptionSpec(Loc, FPT);2398    }2399}2400 2401static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {2402  // Set the EscapingByref flag of __block variables captured by2403  // escaping blocks.2404  for (const BlockDecl *BD : FSI.Blocks) {2405    for (const BlockDecl::Capture &BC : BD->captures()) {2406      VarDecl *VD = BC.getVariable();2407      if (VD->hasAttr<BlocksAttr>()) {2408        // Nothing to do if this is a __block variable captured by a2409        // non-escaping block.2410        if (BD->doesNotEscape())2411          continue;2412        VD->setEscapingByref();2413      }2414      // Check whether the captured variable is or contains an object of2415      // non-trivial C union type.2416      QualType CapType = BC.getVariable()->getType();2417      if (CapType.hasNonTrivialToPrimitiveDestructCUnion() ||2418          CapType.hasNonTrivialToPrimitiveCopyCUnion())2419        S.checkNonTrivialCUnion(BC.getVariable()->getType(),2420                                BD->getCaretLocation(),2421                                NonTrivialCUnionContext::BlockCapture,2422                                Sema::NTCUK_Destruct | Sema::NTCUK_Copy);2423    }2424  }2425 2426  for (VarDecl *VD : FSI.ByrefBlockVars) {2427    // __block variables might require us to capture a copy-initializer.2428    if (!VD->isEscapingByref())2429      continue;2430    // It's currently invalid to ever have a __block variable with an2431    // array type; should we diagnose that here?2432    // Regardless, we don't want to ignore array nesting when2433    // constructing this copy.2434    if (VD->getType()->isStructureOrClassType())2435      checkEscapingByref(VD, S);2436  }2437}2438 2439Sema::PoppedFunctionScopePtr2440Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,2441                           const Decl *D, QualType BlockType) {2442  assert(!FunctionScopes.empty() && "mismatched push/pop!");2443 2444  markEscapingByrefs(*FunctionScopes.back(), *this);2445 2446  PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),2447                               PoppedFunctionScopeDeleter(this));2448 2449  if (LangOpts.OpenMP)2450    OpenMP().popOpenMPFunctionRegion(Scope.get());2451 2452  // Issue any analysis-based warnings.2453  if (WP && D) {2454    inferNoReturnAttr(*this, D);2455    AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);2456  } else2457    for (const auto &PUD : Scope->PossiblyUnreachableDiags)2458      Diag(PUD.Loc, PUD.PD);2459 2460  return Scope;2461}2462 2463void Sema::PoppedFunctionScopeDeleter::2464operator()(sema::FunctionScopeInfo *Scope) const {2465  if (!Scope->isPlainFunction())2466    Self->CapturingFunctionScopes--;2467  // Stash the function scope for later reuse if it's for a normal function.2468  if (Scope->isPlainFunction() && !Self->CachedFunctionScope)2469    Self->CachedFunctionScope.reset(Scope);2470  else2471    delete Scope;2472}2473 2474void Sema::PushCompoundScope(bool IsStmtExpr) {2475  getCurFunction()->CompoundScopes.push_back(2476      CompoundScopeInfo(IsStmtExpr, getCurFPFeatures()));2477}2478 2479void Sema::PopCompoundScope() {2480  FunctionScopeInfo *CurFunction = getCurFunction();2481  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");2482 2483  CurFunction->CompoundScopes.pop_back();2484}2485 2486bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {2487  return getCurFunction()->hasUnrecoverableErrorOccurred();2488}2489 2490void Sema::setFunctionHasBranchIntoScope() {2491  if (!FunctionScopes.empty())2492    FunctionScopes.back()->setHasBranchIntoScope();2493}2494 2495void Sema::setFunctionHasBranchProtectedScope() {2496  if (!FunctionScopes.empty())2497    FunctionScopes.back()->setHasBranchProtectedScope();2498}2499 2500void Sema::setFunctionHasIndirectGoto() {2501  if (!FunctionScopes.empty())2502    FunctionScopes.back()->setHasIndirectGoto();2503}2504 2505void Sema::setFunctionHasMustTail() {2506  if (!FunctionScopes.empty())2507    FunctionScopes.back()->setHasMustTail();2508}2509 2510BlockScopeInfo *Sema::getCurBlock() {2511  if (FunctionScopes.empty())2512    return nullptr;2513 2514  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());2515  if (CurBSI && CurBSI->TheDecl &&2516      !CurBSI->TheDecl->Encloses(CurContext)) {2517    // We have switched contexts due to template instantiation.2518    assert(!CodeSynthesisContexts.empty());2519    return nullptr;2520  }2521 2522  return CurBSI;2523}2524 2525FunctionScopeInfo *Sema::getEnclosingFunction() const {2526  if (FunctionScopes.empty())2527    return nullptr;2528 2529  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {2530    if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))2531      continue;2532    return FunctionScopes[e];2533  }2534  return nullptr;2535}2536 2537CapturingScopeInfo *Sema::getEnclosingLambdaOrBlock() const {2538  for (auto *Scope : llvm::reverse(FunctionScopes)) {2539    if (auto *CSI = dyn_cast<CapturingScopeInfo>(Scope)) {2540      auto *LSI = dyn_cast<LambdaScopeInfo>(CSI);2541      if (LSI && LSI->Lambda && !LSI->Lambda->Encloses(CurContext) &&2542          LSI->AfterParameterList) {2543        // We have switched contexts due to template instantiation.2544        // FIXME: We should swap out the FunctionScopes during code synthesis2545        // so that we don't need to check for this.2546        assert(!CodeSynthesisContexts.empty());2547        return nullptr;2548      }2549      return CSI;2550    }2551  }2552  return nullptr;2553}2554 2555LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {2556  if (FunctionScopes.empty())2557    return nullptr;2558 2559  auto I = FunctionScopes.rbegin();2560  if (IgnoreNonLambdaCapturingScope) {2561    auto E = FunctionScopes.rend();2562    while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))2563      ++I;2564    if (I == E)2565      return nullptr;2566  }2567  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);2568  if (CurLSI && CurLSI->Lambda && CurLSI->CallOperator &&2569      !CurLSI->Lambda->Encloses(CurContext) && CurLSI->AfterParameterList) {2570    // We have switched contexts due to template instantiation.2571    assert(!CodeSynthesisContexts.empty());2572    return nullptr;2573  }2574 2575  return CurLSI;2576}2577 2578// We have a generic lambda if we parsed auto parameters, or we have2579// an associated template parameter list.2580LambdaScopeInfo *Sema::getCurGenericLambda() {2581  if (LambdaScopeInfo *LSI =  getCurLambda()) {2582    return (LSI->TemplateParams.size() ||2583                    LSI->GLTemplateParameterList) ? LSI : nullptr;2584  }2585  return nullptr;2586}2587 2588 2589void Sema::ActOnComment(SourceRange Comment) {2590  if (!LangOpts.RetainCommentsFromSystemHeaders &&2591      SourceMgr.isInSystemHeader(Comment.getBegin()))2592    return;2593  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);2594  if (RC.isAlmostTrailingComment() || RC.hasUnsupportedSplice(SourceMgr)) {2595    SourceRange MagicMarkerRange(Comment.getBegin(),2596                                 Comment.getBegin().getLocWithOffset(3));2597    StringRef MagicMarkerText;2598    switch (RC.getKind()) {2599    case RawComment::RCK_OrdinaryBCPL:2600      MagicMarkerText = "///<";2601      break;2602    case RawComment::RCK_OrdinaryC:2603      MagicMarkerText = "/**<";2604      break;2605    case RawComment::RCK_Invalid:2606      // FIXME: are there other scenarios that could produce an invalid2607      // raw comment here?2608      Diag(Comment.getBegin(), diag::warn_splice_in_doxygen_comment);2609      return;2610    default:2611      llvm_unreachable("if this is an almost Doxygen comment, "2612                       "it should be ordinary");2613    }2614    Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<2615      FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);2616  }2617  Context.addComment(RC);2618}2619 2620// Pin this vtable to this file.2621ExternalSemaSource::~ExternalSemaSource() {}2622char ExternalSemaSource::ID;2623 2624void ExternalSemaSource::ReadMethodPool(Selector Sel) { }2625void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }2626 2627void ExternalSemaSource::ReadKnownNamespaces(2628                           SmallVectorImpl<NamespaceDecl *> &Namespaces) {2629}2630 2631void ExternalSemaSource::ReadUndefinedButUsed(2632    llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}2633 2634void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<2635    FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}2636 2637bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,2638                         UnresolvedSetImpl &OverloadSet) {2639  ZeroArgCallReturnTy = QualType();2640  OverloadSet.clear();2641 2642  const OverloadExpr *Overloads = nullptr;2643  bool IsMemExpr = false;2644  if (E.getType() == Context.OverloadTy) {2645    OverloadExpr::FindResult FR = OverloadExpr::find(&E);2646 2647    // Ignore overloads that are pointer-to-member constants.2648    if (FR.HasFormOfMemberPointer)2649      return false;2650 2651    Overloads = FR.Expression;2652  } else if (E.getType() == Context.BoundMemberTy) {2653    Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());2654    IsMemExpr = true;2655  }2656 2657  bool Ambiguous = false;2658  bool IsMV = false;2659 2660  if (Overloads) {2661    for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),2662         DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {2663      OverloadSet.addDecl(*it);2664 2665      // Check whether the function is a non-template, non-member which takes no2666      // arguments.2667      if (IsMemExpr)2668        continue;2669      if (const FunctionDecl *OverloadDecl2670            = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {2671        if (OverloadDecl->getMinRequiredArguments() == 0) {2672          if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&2673              (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||2674                          OverloadDecl->isCPUSpecificMultiVersion()))) {2675            ZeroArgCallReturnTy = QualType();2676            Ambiguous = true;2677          } else {2678            ZeroArgCallReturnTy = OverloadDecl->getReturnType();2679            IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||2680                   OverloadDecl->isCPUSpecificMultiVersion();2681          }2682        }2683      }2684    }2685 2686    // If it's not a member, use better machinery to try to resolve the call2687    if (!IsMemExpr)2688      return !ZeroArgCallReturnTy.isNull();2689  }2690 2691  // Attempt to call the member with no arguments - this will correctly handle2692  // member templates with defaults/deduction of template arguments, overloads2693  // with default arguments, etc.2694  if (IsMemExpr && !E.isTypeDependent()) {2695    Sema::TentativeAnalysisScope Trap(*this);2696    ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(), {},2697                                             SourceLocation());2698    if (R.isUsable()) {2699      ZeroArgCallReturnTy = R.get()->getType();2700      return true;2701    }2702    return false;2703  }2704 2705  if (const auto *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {2706    if (const auto *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {2707      if (Fun->getMinRequiredArguments() == 0)2708        ZeroArgCallReturnTy = Fun->getReturnType();2709      return true;2710    }2711  }2712 2713  // We don't have an expression that's convenient to get a FunctionDecl from,2714  // but we can at least check if the type is "function of 0 arguments".2715  QualType ExprTy = E.getType();2716  const FunctionType *FunTy = nullptr;2717  QualType PointeeTy = ExprTy->getPointeeType();2718  if (!PointeeTy.isNull())2719    FunTy = PointeeTy->getAs<FunctionType>();2720  if (!FunTy)2721    FunTy = ExprTy->getAs<FunctionType>();2722 2723  if (const auto *FPT = dyn_cast_if_present<FunctionProtoType>(FunTy)) {2724    if (FPT->getNumParams() == 0)2725      ZeroArgCallReturnTy = FunTy->getReturnType();2726    return true;2727  }2728  return false;2729}2730 2731/// Give notes for a set of overloads.2732///2733/// A companion to tryExprAsCall. In cases when the name that the programmer2734/// wrote was an overloaded function, we may be able to make some guesses about2735/// plausible overloads based on their return types; such guesses can be handed2736/// off to this method to be emitted as notes.2737///2738/// \param Overloads - The overloads to note.2739/// \param FinalNoteLoc - If we've suppressed printing some overloads due to2740///  -fshow-overloads=best, this is the location to attach to the note about too2741///  many candidates. Typically this will be the location of the original2742///  ill-formed expression.2743static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,2744                          const SourceLocation FinalNoteLoc) {2745  unsigned ShownOverloads = 0;2746  unsigned SuppressedOverloads = 0;2747  for (UnresolvedSetImpl::iterator It = Overloads.begin(),2748       DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {2749    if (ShownOverloads >= S.Diags.getNumOverloadCandidatesToShow()) {2750      ++SuppressedOverloads;2751      continue;2752    }2753 2754    const NamedDecl *Fn = (*It)->getUnderlyingDecl();2755    // Don't print overloads for non-default multiversioned functions.2756    if (const auto *FD = Fn->getAsFunction()) {2757      if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&2758          !FD->getAttr<TargetAttr>()->isDefaultVersion())2759        continue;2760      if (FD->isMultiVersion() && FD->hasAttr<TargetVersionAttr>() &&2761          !FD->getAttr<TargetVersionAttr>()->isDefaultVersion())2762        continue;2763    }2764    S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);2765    ++ShownOverloads;2766  }2767 2768  S.Diags.overloadCandidatesShown(ShownOverloads);2769 2770  if (SuppressedOverloads)2771    S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)2772      << SuppressedOverloads;2773}2774 2775static void notePlausibleOverloads(Sema &S, SourceLocation Loc,2776                                   const UnresolvedSetImpl &Overloads,2777                                   bool (*IsPlausibleResult)(QualType)) {2778  if (!IsPlausibleResult)2779    return noteOverloads(S, Overloads, Loc);2780 2781  UnresolvedSet<2> PlausibleOverloads;2782  for (OverloadExpr::decls_iterator It = Overloads.begin(),2783         DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {2784    const auto *OverloadDecl = cast<FunctionDecl>(*It);2785    QualType OverloadResultTy = OverloadDecl->getReturnType();2786    if (IsPlausibleResult(OverloadResultTy))2787      PlausibleOverloads.addDecl(It.getDecl());2788  }2789  noteOverloads(S, PlausibleOverloads, Loc);2790}2791 2792/// Determine whether the given expression can be called by just2793/// putting parentheses after it.  Notably, expressions with unary2794/// operators can't be because the unary operator will start parsing2795/// outside the call.2796static bool IsCallableWithAppend(const Expr *E) {2797  E = E->IgnoreImplicit();2798  return (!isa<CStyleCastExpr>(E) &&2799          !isa<UnaryOperator>(E) &&2800          !isa<BinaryOperator>(E) &&2801          !isa<CXXOperatorCallExpr>(E));2802}2803 2804static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {2805  if (const auto *UO = dyn_cast<UnaryOperator>(E))2806    E = UO->getSubExpr();2807 2808  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {2809    if (ULE->getNumDecls() == 0)2810      return false;2811 2812    const NamedDecl *ND = *ULE->decls_begin();2813    if (const auto *FD = dyn_cast<FunctionDecl>(ND))2814      return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();2815  }2816  return false;2817}2818 2819bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,2820                                bool ForceComplain,2821                                bool (*IsPlausibleResult)(QualType)) {2822  SourceLocation Loc = E.get()->getExprLoc();2823  SourceRange Range = E.get()->getSourceRange();2824  UnresolvedSet<4> Overloads;2825 2826  // If this is a SFINAE context, don't try anything that might trigger ADL2827  // prematurely.2828  if (!isSFINAEContext()) {2829    QualType ZeroArgCallTy;2830    if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&2831        !ZeroArgCallTy.isNull() &&2832        (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {2833      // At this point, we know E is potentially callable with 02834      // arguments and that it returns something of a reasonable type,2835      // so we can emit a fixit and carry on pretending that E was2836      // actually a CallExpr.2837      SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());2838      bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());2839      Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range2840                    << (IsCallableWithAppend(E.get())2841                            ? FixItHint::CreateInsertion(ParenInsertionLoc,2842                                                         "()")2843                            : FixItHint());2844      if (!IsMV)2845        notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);2846 2847      // FIXME: Try this before emitting the fixit, and suppress diagnostics2848      // while doing so.2849      E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), {},2850                        Range.getEnd().getLocWithOffset(1));2851      return true;2852    }2853  }2854  if (!ForceComplain) return false;2855 2856  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());2857  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;2858  if (!IsMV)2859    notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);2860  E = ExprError();2861  return true;2862}2863 2864IdentifierInfo *Sema::getSuperIdentifier() const {2865  if (!Ident_super)2866    Ident_super = &Context.Idents.get("super");2867  return Ident_super;2868}2869 2870void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,2871                                   CapturedRegionKind K,2872                                   unsigned OpenMPCaptureLevel) {2873  auto *CSI = new CapturedRegionScopeInfo(2874      getDiagnostics(), S, CD, RD, CD->getContextParam(), K,2875      (getLangOpts().OpenMP && K == CR_OpenMP)2876          ? OpenMP().getOpenMPNestingLevel()2877          : 0,2878      OpenMPCaptureLevel);2879  CSI->ReturnType = Context.VoidTy;2880  FunctionScopes.push_back(CSI);2881  CapturingFunctionScopes++;2882}2883 2884CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {2885  if (FunctionScopes.empty())2886    return nullptr;2887 2888  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());2889}2890 2891const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &2892Sema::getMismatchingDeleteExpressions() const {2893  return DeleteExprs;2894}2895 2896Sema::FPFeaturesStateRAII::FPFeaturesStateRAII(Sema &S)2897    : S(S), OldFPFeaturesState(S.CurFPFeatures),2898      OldOverrides(S.FpPragmaStack.CurrentValue),2899      OldEvalMethod(S.PP.getCurrentFPEvalMethod()),2900      OldFPPragmaLocation(S.PP.getLastFPEvalPragmaLocation()) {}2901 2902Sema::FPFeaturesStateRAII::~FPFeaturesStateRAII() {2903  S.CurFPFeatures = OldFPFeaturesState;2904  S.FpPragmaStack.CurrentValue = OldOverrides;2905  S.PP.setCurrentFPEvalMethod(OldFPPragmaLocation, OldEvalMethod);2906}2907 2908bool Sema::isDeclaratorFunctionLike(Declarator &D) {2909  assert(D.getCXXScopeSpec().isSet() &&2910         "can only be called for qualified names");2911 2912  auto LR = LookupResult(*this, D.getIdentifier(), D.getBeginLoc(),2913                         LookupOrdinaryName, forRedeclarationInCurContext());2914  DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(),2915                                       !D.getDeclSpec().isFriendSpecified());2916  if (!DC)2917    return false;2918 2919  LookupQualifiedName(LR, DC);2920  bool Result = llvm::all_of(LR, [](Decl *Dcl) {2921    if (NamedDecl *ND = dyn_cast<NamedDecl>(Dcl)) {2922      ND = ND->getUnderlyingDecl();2923      return isa<FunctionDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||2924             isa<UsingDecl>(ND);2925    }2926    return false;2927  });2928  return Result;2929}2930 2931Attr *Sema::CreateAnnotationAttr(const AttributeCommonInfo &CI, StringRef Annot,2932                                 MutableArrayRef<Expr *> Args) {2933 2934  auto *A = AnnotateAttr::Create(Context, Annot, Args.data(), Args.size(), CI);2935  if (!ConstantFoldAttrArgs(2936          CI, MutableArrayRef<Expr *>(A->args_begin(), A->args_end()))) {2937    return nullptr;2938  }2939  return A;2940}2941 2942Attr *Sema::CreateAnnotationAttr(const ParsedAttr &AL) {2943  // Make sure that there is a string literal as the annotation's first2944  // argument.2945  StringRef Str;2946  if (!checkStringLiteralArgumentAttr(AL, 0, Str))2947    return nullptr;2948 2949  llvm::SmallVector<Expr *, 4> Args;2950  Args.reserve(AL.getNumArgs() - 1);2951  for (unsigned Idx = 1; Idx < AL.getNumArgs(); Idx++) {2952    assert(!AL.isArgIdent(Idx));2953    Args.push_back(AL.getArgAsExpr(Idx));2954  }2955 2956  return CreateAnnotationAttr(AL, Str, Args);2957}2958