//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements the actions class which performs semantic analysis and

// builds an AST out of a parse stream.

//

//===----------------------------------------------------------------------===//

#include "UsedDeclVisitor.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/ASTDiagnostic.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclFriend.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/PrettyDeclStackTrace.h"

#include "clang/AST/StmtCXX.h"

#include "clang/Basic/DarwinSDKInfo.h"

#include "clang/Basic/DiagnosticOptions.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/Stack.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Lex/HeaderSearch.h"

#include "clang/Lex/HeaderSearchOptions.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/CXXFieldCollector.h"

#include "clang/Sema/DelayedDiagnostic.h"

#include "clang/Sema/ExternalSemaSource.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/MultiplexExternalSemaSource.h"

#include "clang/Sema/ObjCMethodList.h"

#include "clang/Sema/Scope.h"

#include "clang/Sema/ScopeInfo.h"

#include "clang/Sema/SemaConsumer.h"

#include "clang/Sema/SemaInternal.h"

#include "clang/Sema/TemplateDeduction.h"

#include "clang/Sema/TemplateInstCallback.h"

#include "clang/Sema/TypoCorrection.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/Support/TimeProfiler.h"

using namespace clang;

using namespace sema;

SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {

  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);

}

ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }

DarwinSDKInfo *

Sema::getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,

                                              StringRef Platform) {

  if (CachedDarwinSDKInfo)

    return CachedDarwinSDKInfo->get();

  auto SDKInfo = parseDarwinSDKInfo(

      PP.getFileManager().getVirtualFileSystem(),

      PP.getHeaderSearchInfo().getHeaderSearchOpts().Sysroot);

  if (SDKInfo && *SDKInfo) {

    CachedDarwinSDKInfo = std::make_unique<DarwinSDKInfo>(std::move(**SDKInfo));

    return CachedDarwinSDKInfo->get();

  }

  if (!SDKInfo)

    llvm::consumeError(SDKInfo.takeError());

  Diag(Loc, diag::warn_missing_sdksettings_for_availability_checking)

      << Platform;

  CachedDarwinSDKInfo = std::unique_ptr<DarwinSDKInfo>();

  return nullptr;

}

IdentifierInfo *

Sema::InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,

                                                 unsigned int Index) {

  std::string InventedName;

  llvm::raw_string_ostream OS(InventedName);

  if (!ParamName)

    OS << "auto:" << Index + 1;

  else

    OS << ParamName->getName() << ":auto";

  OS.flush();

  return &Context.Idents.get(OS.str());

}

PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,

                                       const Preprocessor &PP) {

  PrintingPolicy Policy = Context.getPrintingPolicy();

  // In diagnostics, we print _Bool as bool if the latter is defined as the

  // former.

  Policy.Bool = Context.getLangOpts().Bool;

  if (!Policy.Bool) {

    if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {

      Policy.Bool = BoolMacro->isObjectLike() &&

                    BoolMacro->getNumTokens() == 1 &&

                    BoolMacro->getReplacementToken(0).is(tok::kw__Bool);

    }

  }

  return Policy;

}

void Sema::ActOnTranslationUnitScope(Scope *S) {

  TUScope = S;

  PushDeclContext(S, Context.getTranslationUnitDecl());

}

namespace clang {

namespace sema {

class SemaPPCallbacks : public PPCallbacks {

  Sema *S = nullptr;

  llvm::SmallVector<SourceLocation, 8> IncludeStack;

public:

  void set(Sema &S) { this->S = &S; }

  void reset() { S = nullptr; }

  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,

                           SrcMgr::CharacteristicKind FileType,

                           FileID PrevFID) override {

    if (!S)

      return;

    switch (Reason) {

    case EnterFile: {

      SourceManager &SM = S->getSourceManager();

      SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));

      if (IncludeLoc.isValid()) {

        if (llvm::timeTraceProfilerEnabled()) {

          const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));

          llvm::timeTraceProfilerBegin(

              "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));

        }

        IncludeStack.push_back(IncludeLoc);

        S->DiagnoseNonDefaultPragmaAlignPack(

            Sema::PragmaAlignPackDiagnoseKind::NonDefaultStateAtInclude,

            IncludeLoc);

      }

      break;

    }

    case ExitFile:

      if (!IncludeStack.empty()) {

        if (llvm::timeTraceProfilerEnabled())

          llvm::timeTraceProfilerEnd();

        S->DiagnoseNonDefaultPragmaAlignPack(

            Sema::PragmaAlignPackDiagnoseKind::ChangedStateAtExit,

            IncludeStack.pop_back_val());

      }

      break;

    default:

      break;

    }

  }

};

} // end namespace sema

} // end namespace clang

const unsigned Sema::MaxAlignmentExponent;

const unsigned Sema::MaximumAlignment;

Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,

           TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)

    : ExternalSource(nullptr), isMultiplexExternalSource(false),

      CurFPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),

      Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),

      SourceMgr(PP.getSourceManager()), CollectStats(false),

      CodeCompleter(CodeCompleter), CurContext(nullptr),

      OriginalLexicalContext(nullptr), MSStructPragmaOn(false),

      MSPointerToMemberRepresentationMethod(

          LangOpts.getMSPointerToMemberRepresentationMethod()),

      VtorDispStack(LangOpts.getVtorDispMode()),

      AlignPackStack(AlignPackInfo(getLangOpts().XLPragmaPack)),

      DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),

      CodeSegStack(nullptr), FpPragmaStack(FPOptionsOverride()),

      CurInitSeg(nullptr), VisContext(nullptr),

      PragmaAttributeCurrentTargetDecl(nullptr),

      IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),

      LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),

      StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),

      StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),

      MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),

      NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),

      ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),

      ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),

      DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),

      TUKind(TUKind), NumSFINAEErrors(0),

      FullyCheckedComparisonCategories(

          static_cast<unsigned>(ComparisonCategoryType::Last) + 1),

      SatisfactionCache(Context), AccessCheckingSFINAE(false),

      InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0),

      ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr),

      DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this),

      ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),

      CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {

  assert(pp.TUKind == TUKind);

  TUScope = nullptr;

  isConstantEvaluatedOverride = false;

  LoadedExternalKnownNamespaces = false;

  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; 
++I1.41M
)

    NSNumberLiteralMethods[I] = nullptr;

  if (getLangOpts().ObjC)

    NSAPIObj.reset(new NSAPI(Context));

  if (getLangOpts().CPlusPlus)

    FieldCollector.reset(new CXXFieldCollector());

  // Tell diagnostics how to render things from the AST library.

  Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);

  ExprEvalContexts.emplace_back(

      ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},

      nullptr, ExpressionEvaluationContextRecord::EK_Other);

  // Initialization of data sharing attributes stack for OpenMP

  InitDataSharingAttributesStack();

  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =

      std::make_unique<sema::SemaPPCallbacks>();

  SemaPPCallbackHandler = Callbacks.get();

  PP.addPPCallbacks(std::move(Callbacks));

  SemaPPCallbackHandler->set(*this);

  if (getLangOpts().getFPEvalMethod() == LangOptions::FEM_TargetDefault)

    // Use setting from TargetInfo.

    PP.setCurrentFPEvalMethod(ctxt.getTargetInfo().getFPEvalMethod());

  else

    // Set initial value of __FLT_EVAL_METHOD__ from the command line.

    PP.setCurrentFPEvalMethod(getLangOpts().getFPEvalMethod());

}

// Anchor Sema's type info to this TU.

void Sema::anchor() {}

void Sema::addImplicitTypedef(StringRef Name, QualType T) {

  DeclarationName DN = &Context.Idents.get(Name);

  if (IdResolver.begin(DN) == IdResolver.end())

    PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);

}

void Sema::Initialize() {

  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))

    SC->InitializeSema(*this);

  // Tell the external Sema source about this Sema object.

  if (ExternalSemaSource *ExternalSema

      = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))

    ExternalSema->InitializeSema(*this);

  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we

  // will not be able to merge any duplicate __va_list_tag decls correctly.

  VAListTagName = PP.getIdentifierInfo("__va_list_tag");

  if (!TUScope)

    return;

  // Initialize predefined 128-bit integer types, if needed.

  if (Context.getTargetInfo().hasInt128Type() ||

      
(15.8k
Context.getAuxTargetInfo()15.8k
 &&

       
Context.getAuxTargetInfo()->hasInt128Type()11
)) {

    // If either of the 128-bit integer types are unavailable to name lookup,

    // define them now.

    DeclarationName Int128 = &Context.Idents.get("__int128_t");

    if (IdResolver.begin(Int128) == IdResolver.end())

      PushOnScopeChains(Context.getInt128Decl(), TUScope);

    DeclarationName UInt128 = &Context.Idents.get("__uint128_t");

    if (IdResolver.begin(UInt128) == IdResolver.end())

      PushOnScopeChains(Context.getUInt128Decl(), TUScope);

  }

  // Initialize predefined Objective-C types:

  if (getLangOpts().ObjC) {

    // If 'SEL' does not yet refer to any declarations, make it refer to the

    // predefined 'SEL'.

    DeclarationName SEL = &Context.Idents.get("SEL");

    if (IdResolver.begin(SEL) == IdResolver.end())

      PushOnScopeChains(Context.getObjCSelDecl(), TUScope);

    // If 'id' does not yet refer to any declarations, make it refer to the

    // predefined 'id'.

    DeclarationName Id = &Context.Idents.get("id");

    if (IdResolver.begin(Id) == IdResolver.end())

      PushOnScopeChains(Context.getObjCIdDecl(), TUScope);

    // Create the built-in typedef for 'Class'.

    DeclarationName Class = &Context.Idents.get("Class");

    if (IdResolver.begin(Class) == IdResolver.end())

      PushOnScopeChains(Context.getObjCClassDecl(), TUScope);

    // Create the built-in forward declaratino for 'Protocol'.

    DeclarationName Protocol = &Context.Idents.get("Protocol");

    if (IdResolver.begin(Protocol) == IdResolver.end())

      PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);

  }

  // Create the internal type for the *StringMakeConstantString builtins.

  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");

  if (IdResolver.begin(ConstantString) == IdResolver.end())

    PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);

  // Initialize Microsoft "predefined C++ types".

  if (getLangOpts().MSVCCompat) {

    if (getLangOpts().CPlusPlus &&

        
IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()8.82k
)

      PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),

                        TUScope);

    addImplicitTypedef("size_t", Context.getSizeType());

  }

  // Initialize predefined OpenCL types and supported extensions and (optional)

  // core features.

  if (getLangOpts().OpenCL) {

    getOpenCLOptions().addSupport(

        Context.getTargetInfo().getSupportedOpenCLOpts(), getLangOpts());

    addImplicitTypedef("sampler_t", Context.OCLSamplerTy);

    addImplicitTypedef("event_t", Context.OCLEventTy);

    if (getLangOpts().OpenCLCPlusPlus || 
getLangOpts().OpenCLVersion >= 200615
) {

      addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);

      addImplicitTypedef("queue_t", Context.OCLQueueTy);

      if (getLangOpts().OpenCLPipes)

        addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);

      addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));

      addImplicitTypedef("atomic_uint",

                         Context.getAtomicType(Context.UnsignedIntTy));

      addImplicitTypedef("atomic_float",

                         Context.getAtomicType(Context.FloatTy));

      // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as

      // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.

      addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));

      // OpenCL v2.0 s6.13.11.6:

      // - The atomic_long and atomic_ulong types are supported if the

      //   cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics

      //   extensions are supported.

      // - The atomic_double type is only supported if double precision

      //   is supported and the cl_khr_int64_base_atomics and

      //   cl_khr_int64_extended_atomics extensions are supported.

      // - If the device address space is 64-bits, the data types

      //   atomic_intptr_t, atomic_uintptr_t, atomic_size_t and

      //   atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and

      //   cl_khr_int64_extended_atomics extensions are supported.

      auto AddPointerSizeDependentTypes = [&]() {

        auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());

        auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());

        auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());

        auto AtomicPtrDiffT =

            Context.getAtomicType(Context.getPointerDiffType());

        addImplicitTypedef("atomic_size_t", AtomicSizeT);

        addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);

        addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);

        addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);

      };

      if (Context.getTypeSize(Context.getSizeType()) == 32) {

        AddPointerSizeDependentTypes();

      }

      std::vector<QualType> Atomic64BitTypes;

      if (getOpenCLOptions().isSupported("cl_khr_int64_base_atomics",

                                         getLangOpts()) &&

          getOpenCLOptions().isSupported("cl_khr_int64_extended_atomics",

                                         getLangOpts())) {

        if (getOpenCLOptions().isSupported("cl_khr_fp64", getLangOpts())) {

          auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);

          addImplicitTypedef("atomic_double", AtomicDoubleT);

          Atomic64BitTypes.push_back(AtomicDoubleT);

        }

        auto AtomicLongT = Context.getAtomicType(Context.LongTy);

        auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);

        addImplicitTypedef("atomic_long", AtomicLongT);

        addImplicitTypedef("atomic_ulong", AtomicULongT);

        if (Context.getTypeSize(Context.getSizeType()) == 64) {

          AddPointerSizeDependentTypes();

        }

      }

    }

#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \

  if (getOpenCLOptions().isSupported(#Ext, getLangOpts())) {                   \

    addImplicitTypedef(#ExtType, Context.Id##Ty);                              \

  }

#include "clang/Basic/OpenCLExtensionTypes.def"

  }

  if (Context.getTargetInfo().hasAArch64SVETypes()) {

#define SVE_TYPE(Name, Id, SingletonId) \

    addImplicitTypedef(Name, Context.SingletonId);

#include "clang/Basic/AArch64SVEACLETypes.def"

  }

  if (Context.getTargetInfo().getTriple().isPPC64() &&

      
Context.getTargetInfo().hasFeature("paired-vector-memops")3.86k
) {

    if (Context.getTargetInfo().hasFeature("mma")) {

#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \

      addImplicitTypedef(#Name, Context.Id##Ty);

#include "clang/Basic/PPCTypes.def"

    }

#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \

    addImplicitTypedef(#Name, Context.Id##Ty);

#include "clang/Basic/PPCTypes.def"

  }

  if (Context.getTargetInfo().hasRISCVVTypes()) {

#define RVV_TYPE(Name, Id, SingletonId)                                        \

  addImplicitTypedef(Name, Context.SingletonId);

#include "clang/Basic/RISCVVTypes.def"

  }

  if (Context.getTargetInfo().hasBuiltinMSVaList()) {

    DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");

    if (IdResolver.begin(MSVaList) == IdResolver.end())

      PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);

  }

  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");

  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())

    PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);

}

Sema::~Sema() {

  assert(InstantiatingSpecializations.empty() &&

         "failed to clean up an InstantiatingTemplate?");

  if (VisContext) 
FreeVisContext()4
;

  // Kill all the active scopes.

  for (sema::FunctionScopeInfo *FSI : FunctionScopes)

    delete FSI;

  // Tell the SemaConsumer to forget about us; we're going out of scope.

  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))

    SC->ForgetSema();

  // Detach from the external Sema source.

  if (ExternalSemaSource *ExternalSema

        = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))

    ExternalSema->ForgetSema();

  // If Sema's ExternalSource is the multiplexer - we own it.

  if (isMultiplexExternalSource)

    delete ExternalSource;

  // Delete cached satisfactions.

  std::vector<ConstraintSatisfaction *> Satisfactions;

  Satisfactions.reserve(Satisfactions.size());

  for (auto &Node : SatisfactionCache)

    Satisfactions.push_back(&Node);

  for (auto *Node : Satisfactions)

    delete Node;

  threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);

  // Destroys data sharing attributes stack for OpenMP

  DestroyDataSharingAttributesStack();

  // Detach from the PP callback handler which outlives Sema since it's owned

  // by the preprocessor.

  SemaPPCallbackHandler->reset();

}

void Sema::warnStackExhausted(SourceLocation Loc) {

  // Only warn about this once.

  if (!WarnedStackExhausted) {

    Diag(Loc, diag::warn_stack_exhausted);

    WarnedStackExhausted = true;

  }

}

void Sema::runWithSufficientStackSpace(SourceLocation Loc,

                                       llvm::function_ref<void()> Fn) {

  clang::runWithSufficientStackSpace([&] 
{ warnStackExhausted(Loc); }11
, Fn);

}

/// makeUnavailableInSystemHeader - There is an error in the current

/// context.  If we're still in a system header, and we can plausibly

/// make the relevant declaration unavailable instead of erroring, do

/// so and return true.

bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,

                                      UnavailableAttr::ImplicitReason reason) {

  // If we're not in a function, it's an error.

  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);

  if (!fn) 
return false24
;

  // If we're in template instantiation, it's an error.

  if (inTemplateInstantiation())

    return false;

  // If that function's not in a system header, it's an error.

  if (!Context.getSourceManager().isInSystemHeader(loc))

    return false;

  // If the function is already unavailable, it's not an error.

  if (fn->hasAttr<UnavailableAttr>()) 
return true0
;

  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));

  return true;

}

ASTMutationListener *Sema::getASTMutationListener() const {

  return getASTConsumer().GetASTMutationListener();

}

///Registers an external source. If an external source already exists,

/// creates a multiplex external source and appends to it.

///

///\param[in] E - A non-null external sema source.

///

void Sema::addExternalSource(ExternalSemaSource *E) {

  assert(E && "Cannot use with NULL ptr");

  if (!ExternalSource) {

    ExternalSource = E;

    return;

  }

  if (isMultiplexExternalSource)

    static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);

  else {

    ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);

    isMultiplexExternalSource = true;

  }

}

/// Print out statistics about the semantic analysis.

void Sema::PrintStats() const {

  llvm::errs() << "\n*** Semantic Analysis Stats:\n";

  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";

  BumpAlloc.PrintStats();

  AnalysisWarnings.PrintStats();

}

void Sema::diagnoseNullableToNonnullConversion(QualType DstType,

                                               QualType SrcType,

                                               SourceLocation Loc) {

  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);

  if (!ExprNullability || 
(9.41k
*ExprNullability != NullabilityKind::Nullable9.41k
 &&

                           
*ExprNullability != NullabilityKind::NullableResult4.70k
))

    return;

  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);

  if (!TypeNullability || 
*TypeNullability != NullabilityKind::NonNull427
)

    return;

  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;

}

void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {

  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,

                      E->getBeginLoc()))

    return;

  // nullptr only exists from C++11 on, so don't warn on its absence earlier.

  if (!getLangOpts().CPlusPlus11)

    return;

  if (Kind != CK_NullToPointer && 
Kind != CK_NullToMemberPointer373
)

    return;

  if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())

    return;

  // Don't diagnose the conversion from a 0 literal to a null pointer argument

  // in a synthesized call to operator<=>.

  if (!CodeSynthesisContexts.empty() &&

      CodeSynthesisContexts.back().Kind ==

          CodeSynthesisContext::RewritingOperatorAsSpaceship)

    return;

  // If it is a macro from system header, and if the macro name is not "NULL",

  // do not warn.

  SourceLocation MaybeMacroLoc = E->getBeginLoc();

  if (Diags.getSuppressSystemWarnings() &&

      
SourceMgr.isInSystemMacro(MaybeMacroLoc)25
 &&

      
!findMacroSpelling(MaybeMacroLoc, "NULL")3
)

    return;

  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)

      << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");

}

/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.

/// If there is already an implicit cast, merge into the existing one.

/// The result is of the given category.

ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,

                                   CastKind Kind, ExprValueKind VK,

                                   const CXXCastPath *BasePath,

                                   CheckedConversionKind CCK) {

#ifndef NDEBUG

  if (VK == VK_PRValue && 
!E->isPRValue()11.2M
) {

    switch (Kind) {

    default:

      llvm_unreachable(

          ("can't implicitly cast glvalue to prvalue with this cast "

           "kind: " +

           std::string(CastExpr::getCastKindName(Kind)))

              .c_str());

    case CK_Dependent:

    case CK_LValueToRValue:

    case CK_ArrayToPointerDecay:

    case CK_FunctionToPointerDecay:

    case CK_ToVoid:

    case CK_NonAtomicToAtomic:

      break;

    }

  }

  assert((VK == VK_PRValue || Kind == CK_Dependent || !E->isPRValue()) &&

         "can't cast prvalue to glvalue");

#endif

  diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());

  diagnoseZeroToNullptrConversion(Kind, E);

  QualType ExprTy = Context.getCanonicalType(E->getType());

  QualType TypeTy = Context.getCanonicalType(Ty);

  if (ExprTy == TypeTy)

    return E;

  if (Kind == CK_ArrayToPointerDecay) {

    // C++1z [conv.array]: The temporary materialization conversion is applied.

    // We also use this to fuel C++ DR1213, which applies to C++11 onwards.

    if (getLangOpts().CPlusPlus && 
E->isPRValue()189k
) {

      // The temporary is an lvalue in C++98 and an xvalue otherwise.

      ExprResult Materialized = CreateMaterializeTemporaryExpr(

          E->getType(), E, !getLangOpts().CPlusPlus11);

      if (Materialized.isInvalid())

        return ExprError();

      E = Materialized.get();

    }

    // C17 6.7.1p6 footnote 124: The implementation can treat any register

    // declaration simply as an auto declaration. However, whether or not

    // addressable storage is actually used, the address of any part of an

    // object declared with storage-class specifier register cannot be

    // computed, either explicitly(by use of the unary & operator as discussed

    // in 6.5.3.2) or implicitly(by converting an array name to a pointer as

    // discussed in 6.3.2.1).Thus, the only operator that can be applied to an

    // array declared with storage-class specifier register is sizeof.

    if (VK == VK_PRValue && !getLangOpts().CPlusPlus && 
!E->isPRValue()58.5k
) {

      if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {

        if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {

          if (VD->getStorageClass() == SC_Register) {

            Diag(E->getExprLoc(), diag::err_typecheck_address_of)

                << /*register variable*/ 3 << E->getSourceRange();

            return ExprError();

          }

        }

      }

    }

  }

  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {

    if (ImpCast->getCastKind() == Kind && 
(21.3k
!BasePath21.3k
 || 
BasePath->empty()689
)) {

      ImpCast->setType(Ty);

      ImpCast->setValueKind(VK);

      return E;

    }

  }

  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK,

                                  CurFPFeatureOverrides());

}

/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding

/// to the conversion from scalar type ScalarTy to the Boolean type.

CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {

  switch (ScalarTy->getScalarTypeKind()) {

  case Type::STK_Bool: return CK_NoOp;

  case Type::STK_CPointer: return CK_PointerToBoolean;

  case Type::STK_BlockPointer: return CK_PointerToBoolean;

  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;

  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;

  case Type::STK_Integral: return CK_IntegralToBoolean;

  case Type::STK_Floating: return CK_FloatingToBoolean;

  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;

  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;

  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;

  }

  llvm_unreachable("unknown scalar type kind");

}

/// Used to prune the decls of Sema's UnusedFileScopedDecls vector.

static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {

  if (D->getMostRecentDecl()->isUsed())

    return true;

  if (D->isExternallyVisible())

    return true;

  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {

    // If this is a function template and none of its specializations is used,

    // we should warn.

    if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())

      for (const auto *Spec : Template->specializations())

        if (ShouldRemoveFromUnused(SemaRef, Spec))

          return true;

    // UnusedFileScopedDecls stores the first declaration.

    // The declaration may have become definition so check again.

    const FunctionDecl *DeclToCheck;

    if (FD->hasBody(DeclToCheck))

      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);

    // Later redecls may add new information resulting in not having to warn,

    // so check again.

    DeclToCheck = FD->getMostRecentDecl();

    if (DeclToCheck != FD)

      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);

  }

  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {

    // If a variable usable in constant expressions is referenced,

    // don't warn if it isn't used: if the value of a variable is required

    // for the computation of a constant expression, it doesn't make sense to

    // warn even if the variable isn't odr-used.  (isReferenced doesn't

    // precisely reflect that, but it's a decent approximation.)

    if (VD->isReferenced() &&

        
VD->mightBeUsableInConstantExpressions(SemaRef->Context)1.07k
)

      return true;

    if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())

      // If this is a variable template and none of its specializations is used,

      // we should warn.

      for (const auto *Spec : Template->specializations())

        if (ShouldRemoveFromUnused(SemaRef, Spec))

          return true;

    // UnusedFileScopedDecls stores the first declaration.

    // The declaration may have become definition so check again.

    const VarDecl *DeclToCheck = VD->getDefinition();

    if (DeclToCheck)

      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);

    // Later redecls may add new information resulting in not having to warn,

    // so check again.

    DeclToCheck = VD->getMostRecentDecl();

    if (DeclToCheck != VD)

      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);

  }

  return false;

}

static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {

  if (auto *FD = dyn_cast<FunctionDecl>(ND))

    return FD->isExternC();

  return cast<VarDecl>(ND)->isExternC();

}

/// Determine whether ND is an external-linkage function or variable whose

/// type has no linkage.

bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {

  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,

  // because we also want to catch the case where its type has VisibleNoLinkage,

  // which does not affect the linkage of VD.

  return getLangOpts().CPlusPlus && 
VD->hasExternalFormalLinkage()370k
 &&

         
!isExternalFormalLinkage(VD->getType()->getLinkage())369k
 &&

         
!isFunctionOrVarDeclExternC(VD)49
;

}

/// Obtains a sorted list of functions and variables that are undefined but

/// ODR-used.

void Sema::getUndefinedButUsed(

    SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {

  for (const auto &UndefinedUse : UndefinedButUsed) {

    NamedDecl *ND = UndefinedUse.first;

    // Ignore attributes that have become invalid.

    if (ND->isInvalidDecl()) 
continue0
;

    // __attribute__((weakref)) is basically a definition.

    if (ND->hasAttr<WeakRefAttr>()) 
continue0
;

    if (isa<CXXDeductionGuideDecl>(ND))

      continue;

    if (ND->hasAttr<DLLImportAttr>() || 
ND->hasAttr<DLLExportAttr>()156k
) {

      // An exported function will always be emitted when defined, so even if

      // the function is inline, it doesn't have to be emitted in this TU. An

      // imported function implies that it has been exported somewhere else.

      continue;

    }

    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {

      if (FD->isDefined())

        continue;

      if (FD->isExternallyVisible() &&

          
!isExternalWithNoLinkageType(FD)2.32k
 &&

          
!FD->getMostRecentDecl()->isInlined()2.32k
 &&

          
!FD->hasAttr<ExcludeFromExplicitInstantiationAttr>()6
)

        continue;

      if (FD->getBuiltinID())

        continue;

    } else {

      auto *VD = cast<VarDecl>(ND);

      if (VD->hasDefinition() != VarDecl::DeclarationOnly)

        continue;

      if (VD->isExternallyVisible() &&

          
!isExternalWithNoLinkageType(VD)2
 &&

          
!VD->getMostRecentDecl()->isInline()2
 &&

          
!VD->hasAttr<ExcludeFromExplicitInstantiationAttr>()0
)

        continue;

      // Skip VarDecls that lack formal definitions but which we know are in

      // fact defined somewhere.

      if (VD->isKnownToBeDefined())

        continue;

    }

    Undefined.push_back(std::make_pair(ND, UndefinedUse.second));

  }

}

/// checkUndefinedButUsed - Check for undefined objects with internal linkage

/// or that are inline.

static void checkUndefinedButUsed(Sema &S) {

  if (S.UndefinedButUsed.empty()) 
return65.0k
;

  // Collect all the still-undefined entities with internal linkage.

  SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;

  S.getUndefinedButUsed(Undefined);

  if (Undefined.empty()) 
return5.77k
;

  
for (auto Undef : Undefined)113
 {

    ValueDecl *VD = cast<ValueDecl>(Undef.first);

    SourceLocation UseLoc = Undef.second;

    if (S.isExternalWithNoLinkageType(VD)) {

      // C++ [basic.link]p8:

      //   A type without linkage shall not be used as the type of a variable

      //   or function with external linkage unless

      //    -- the entity has C language linkage

      //    -- the entity is not odr-used or is defined in the same TU

      //

      // As an extension, accept this in cases where the type is externally

      // visible, since the function or variable actually can be defined in

      // another translation unit in that case.

      S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())

                                    ? 
diag::ext_undefined_internal_type3

                                    : 
diag::err_undefined_internal_type4
)

        << isa<VarDecl>(VD) << VD;

    } else if (!VD->isExternallyVisible()) {

      // FIXME: We can promote this to an error. The function or variable can't

      // be defined anywhere else, so the program must necessarily violate the

      // one definition rule.

      bool IsImplicitBase = false;

      if (const auto *BaseD = dyn_cast<FunctionDecl>(VD)) {

        auto *DVAttr = BaseD->getAttr<OMPDeclareVariantAttr>();

        if (DVAttr && !DVAttr->getTraitInfo().isExtensionActive(

                          llvm::omp::TraitProperty::

                              implementation_extension_disable_implicit_base)) {

          const auto *Func = cast<FunctionDecl>(

              cast<DeclRefExpr>(DVAttr->getVariantFuncRef())->getDecl());

          IsImplicitBase = BaseD->isImplicit() &&

                           
Func->getIdentifier()->isMangledOpenMPVariantName()1.04k
;

        }

      }

      if (!S.getLangOpts().OpenMP || 
!IsImplicitBase1.04k
)

        S.Diag(VD->getLocation(), diag::warn_undefined_internal)

            << isa<VarDecl>(VD) << VD;

    } else 
if (auto *48
FD48
 = dyn_cast<FunctionDecl>(VD)) {

      (void)FD;

      assert(FD->getMostRecentDecl()->isInlined() &&

             "used object requires definition but isn't inline or internal?");

      // FIXME: This is ill-formed; we should reject.

      S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;

    } else {

      assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&

             "used var requires definition but isn't inline or internal?");

      S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;

    }

    if (UseLoc.isValid())

      S.Diag(UseLoc, diag::note_used_here);

  }

  S.UndefinedButUsed.clear();

}

void Sema::LoadExternalWeakUndeclaredIdentifiers() {

  if (!ExternalSource)

    return;

  SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;

  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);

  for (auto &WeakID : WeakIDs)

    WeakUndeclaredIdentifiers.insert(WeakID);

}

typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;

/// Returns true, if all methods and nested classes of the given

/// CXXRecordDecl are defined in this translation unit.

///

/// Should only be called from ActOnEndOfTranslationUnit so that all

/// definitions are actually read.

static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,

                                            RecordCompleteMap &MNCComplete) {

  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);

  if (Cache != MNCComplete.end())

    return Cache->second;

  if (!RD->isCompleteDefinition())

    return false;

  bool Complete = true;

  for (DeclContext::decl_iterator I = RD->decls_begin(),

                                  E = RD->decls_end();

       I != E && 
Complete410
; 
++I393
) {

    if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))

      Complete = M->isDefined() || 
M->isDefaulted()11
 ||

                 
(11
M->isPure()11
 && 
!isa<CXXDestructorDecl>(M)3
);

    else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))

      // If the template function is marked as late template parsed at this

      // point, it has not been instantiated and therefore we have not

      // performed semantic analysis on it yet, so we cannot know if the type

      // can be considered complete.

      Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&

                  
F->getTemplatedDecl()->isDefined()3
;

    else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {

      if (R->isInjectedClassName())

        continue;

      if (R->hasDefinition())

        Complete = MethodsAndNestedClassesComplete(R->getDefinition(),

                                                   MNCComplete);

      else

        Complete = false;

    }

  }

  MNCComplete[RD] = Complete;

  return Complete;

}

/// Returns true, if the given CXXRecordDecl is fully defined in this

/// translation unit, i.e. all methods are defined or pure virtual and all

/// friends, friend functions and nested classes are fully defined in this

/// translation unit.

///

/// Should only be called from ActOnEndOfTranslationUnit so that all

/// definitions are actually read.

static bool IsRecordFullyDefined(const CXXRecordDecl *RD,

                                 RecordCompleteMap &RecordsComplete,

                                 RecordCompleteMap &MNCComplete) {

  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);

  if (Cache != RecordsComplete.end())

    return Cache->second;

  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);

  for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),

                                      E = RD->friend_end();

       I != E && 
Complete39
; 
++I30
) {

    // Check if friend classes and methods are complete.

    if (TypeSourceInfo *TSI = (*I)->getFriendType()) {

      // Friend classes are available as the TypeSourceInfo of the FriendDecl.

      if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())

        Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);

      else

        Complete = false;

    } else {

      // Friend functions are available through the NamedDecl of FriendDecl.

      if (const FunctionDecl *FD =

          dyn_cast<FunctionDecl>((*I)->getFriendDecl()))

        Complete = FD->isDefined();

      else

        // This is a template friend, give up.

        Complete = false;

    }

  }

  RecordsComplete[RD] = Complete;

  return Complete;

}

void Sema::emitAndClearUnusedLocalTypedefWarnings() {

  if (ExternalSource)

    ExternalSource->ReadUnusedLocalTypedefNameCandidates(

        UnusedLocalTypedefNameCandidates);

  for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {

    if (TD->isReferenced())

      continue;

    Diag(TD->getLocation(), diag::warn_unused_local_typedef)

        << isa<TypeAliasDecl>(TD) << TD->getDeclName();

  }

  UnusedLocalTypedefNameCandidates.clear();

}

/// This is called before the very first declaration in the translation unit

/// is parsed. Note that the ASTContext may have already injected some

/// declarations.

void Sema::ActOnStartOfTranslationUnit() {

  if (getLangOpts().ModulesTS &&

      
(136
getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface136
 ||

       
getLangOpts().getCompilingModule() == LangOptions::CMK_None93
)) {

    // We start in an implied global module fragment.

    SourceLocation StartOfTU =

        SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());

    ActOnGlobalModuleFragmentDecl(StartOfTU);

    ModuleScopes.back().ImplicitGlobalModuleFragment = true;

  }

}

void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {

  // No explicit actions are required at the end of the global module fragment.

  if (Kind == TUFragmentKind::Global)

    return;

  // Transfer late parsed template instantiations over to the pending template

  // instantiation list. During normal compilation, the late template parser

  // will be installed and instantiating these templates will succeed.

  //

  // If we are building a TU prefix for serialization, it is also safe to

  // transfer these over, even though they are not parsed. The end of the TU

  // should be outside of any eager template instantiation scope, so when this

  // AST is deserialized, these templates will not be parsed until the end of