//===--- 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/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/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/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(); }

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) {

  TUScope = nullptr;

  isConstantEvaluatedOverride = false;

  LoadedExternalKnownNamespaces = false;

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

    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);

}

// 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() ||

      (Context.getAuxTargetInfo() &&

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

    // 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())

      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());

    getOpenCLOptions().enableSupportedCore(getLangOpts());

    addImplicitTypedef("sampler_t", Context.OCLSamplerTy);

    addImplicitTypedef("event_t", Context.OCLEventTy);

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

      addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);

      addImplicitTypedef("queue_t", Context.OCLQueueTy);

      addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);

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

      addImplicitTypedef("atomic_uint",

                         Context.getAtomicType(Context.UnsignedIntTy));

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

      addImplicitTypedef("atomic_long", AtomicLongT);

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

      addImplicitTypedef("atomic_ulong", AtomicULongT);

      addImplicitTypedef("atomic_float",

                         Context.getAtomicType(Context.FloatTy));

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

      addImplicitTypedef("atomic_double", AtomicDoubleT);

      // 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));

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

      addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);

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

      addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);

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

      addImplicitTypedef("atomic_size_t", AtomicSizeT);

      auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());

      addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);

      // 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.

      std::vector<QualType> Atomic64BitTypes;

      Atomic64BitTypes.push_back(AtomicLongT);

      Atomic64BitTypes.push_back(AtomicULongT);

      Atomic64BitTypes.push_back(AtomicDoubleT);

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

        Atomic64BitTypes.push_back(AtomicSizeT);

        Atomic64BitTypes.push_back(AtomicIntPtrT);

        Atomic64BitTypes.push_back(AtomicUIntPtrT);

        Atomic64BitTypes.push_back(AtomicPtrDiffT);

      }

      for (auto &I : Atomic64BitTypes)

        setOpenCLExtensionForType(I,

            "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");

      setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");

    }

    setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");

#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \

    setOpenCLExtensionForType(Context.Id, Ext);

#include "clang/Basic/OpenCLImageTypes.def"

#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \

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

    setOpenCLExtensionForType(Context.Id##Ty, #Ext);

#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")) {

    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().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); }, 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.87k
*ExprNullability != NullabilityKind::Nullable9.87k
 &&

                           *ExprNullability != NullabilityKind::NullableResult))

    return;

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

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

    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_NullToMemberPointer353
)

    return;

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

    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) &&

      !findMacroSpelling(MaybeMacroLoc, "NULL"))

    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_RValue && 
!E->isRValue()10.9M
) {

    switch (Kind) {

    default:

      llvm_unreachable(("can't implicitly cast lvalue to rvalue 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_RValue || Kind == CK_Dependent || !E->isRValue()) &&

         "can't cast rvalue to lvalue");

#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;

  // 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 (Kind == CK_ArrayToPointerDecay && 
getLangOpts().CPlusPlus209k
 &&

      E->getValueKind() == VK_RValue) {

    // 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();

  }

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

    if (ImpCast->getCastKind() == Kind && 
(17.5k
!BasePath17.5k
 || 
BasePath->empty()666
)) {

      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))

      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()252k
 &&

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

         !isFunctionOrVarDeclExternC(VD);

}

/// 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>()107k
) {

      // 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) &&

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

          !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())

        continue;

      if (FD->getBuiltinID())

        continue;

    } else {

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

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

        continue;

      if (VD->isExternallyVisible() &&

          !isExternalWithNoLinkageType(VD) &&

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

          !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())

        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()) 
return59.4k
;

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

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

  S.getUndefinedButUsed(Undefined);

  if (Undefined.empty()) 
return4.07k
;

  
for (auto Undef : Undefined)102
 {

    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_type

                                    : diag::err_undefined_internal_type)

        << 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.

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

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

    } else if (auto *FD = 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 && 
Complete287
; 
++I275
) {

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

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

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

    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();

    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 && 
Complete26
; 
++I20
) {

    // 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 &&

      (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||

       
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

  // the combined TU.

  PendingInstantiations.insert(PendingInstantiations.end(),

                               LateParsedInstantiations.begin(),

                               LateParsedInstantiations.end());

  LateParsedInstantiations.clear();

  // If DefinedUsedVTables ends up marking any virtual member functions it

  // might lead to more pending template instantiations, which we then need

  // to instantiate.

  DefineUsedVTables();

  // C++: Perform implicit template instantiations.

  //

  // FIXME: When we perform these implicit instantiations, we do not

  // carefully keep track of the point of instantiation (C++ [temp.point]).

  // This means that name lookup that occurs within the template

  // instantiation will always happen at the end of the translation unit,

  // so it will find some names that are not required to be found. This is

  // valid, but we could do better by diagnosing if an instantiation uses a

  // name that was not visible at its first point of instantiation.

  if (ExternalSource) {

    // Load pending instantiations from the external source.

    SmallVector<PendingImplicitInstantiation, 4> Pending;

    ExternalSource->ReadPendingInstantiations(Pending);

    for (auto PII : Pending)

      if (auto Func = dyn_cast<FunctionDecl>(PII.first))

        Func->setInstantiationIsPending(true);

    PendingInstantiations.insert(PendingInstantiations.begin(),

                                 Pending.begin(), Pending.end());

  }

  {

    llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");

    PerformPendingInstantiations();

  }

  emitDeferredDiags();

  assert(LateParsedInstantiations.empty() &&

         "end of TU template instantiation should not create more "

         "late-parsed templates");

  // Report diagnostics for uncorrected delayed typos. Ideally all of them

  // should have been corrected by that time, but it is very hard to cover all

  // cases in practice.

  for (const auto &Typo : DelayedTypos) {

    // We pass an empty TypoCorrection to indicate no correction was performed.

    Typo.second.DiagHandler(TypoCorrection());

  }

  DelayedTypos.clear();

}

/// ActOnEndOfTranslationUnit - This is called at the very end of the

/// translation unit when EOF is reached and all but the top-level scope is

/// popped.

void Sema::ActOnEndOfTranslationUnit() {

  assert(DelayedDiagnostics.getCurrentPool() == nullptr

         && "reached end of translation unit with a pool attached?");

  // If code completion is enabled, don't perform any end-of-translation-unit

  // work.

  if (PP.isCodeCompletionEnabled())

    return;

  // Complete translation units and modules define vtables and perform implicit

  // instantiations. PCH files do not.

  if (TUKind != TU_Prefix) {

    DiagnoseUseOfUnimplementedSelectors();

    ActOnEndOfTranslationUnitFragment(

        !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==

                                     Module::PrivateModuleFragment

            ? TUFragmentKind::Private

            : TUFragmentKind::Normal);

    if (LateTemplateParserCleanup)

      LateTemplateParserCleanup(OpaqueParser);

    CheckDelayedMemberExceptionSpecs();

  } else {

    // If we are building a TU prefix for serialization, it is 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 the

    // combined TU.

    PendingInstantiations.insert(PendingInstantiations.end(),

                                 LateParsedInstantiations.begin(),

                                 LateParsedInstantiations.end());

    LateParsedInstantiations.clear();

    if (LangOpts.PCHInstantiateTemplates) {

      llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");

      PerformPendingInstantiations();