/build/source/clang/lib/Sema/SemaTemplateVariadic.cpp

Bug Summary

File:	build/source/clang/lib/Sema/SemaTemplateVariadic.cpp
Warning:	line 710, column 11 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateVariadic.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/Sema -I /build/source/clang/lib/Sema -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -source-date-epoch 1679915782 -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-03-27-130437-16335-1 -x c++ /build/source/clang/lib/Sema/SemaTemplateVariadic.cpp

/build/source/clang/lib/Sema/SemaTemplateVariadic.cpp

→

1//===------- SemaTemplateVariadic.cpp - C++ Variadic Templates ------------===/
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===/
7//
8//  This file implements semantic analysis for C++0x variadic templates.
9//===----------------------------------------------------------------------===/

11#include "clang/Sema/Sema.h"
12#include "TypeLocBuilder.h"
13#include "clang/AST/Expr.h"
14#include "clang/AST/RecursiveASTVisitor.h"
15#include "clang/AST/TypeLoc.h"
16#include "clang/Sema/Lookup.h"
17#include "clang/Sema/ParsedTemplate.h"
18#include "clang/Sema/ScopeInfo.h"
19#include "clang/Sema/SemaInternal.h"
20#include "clang/Sema/Template.h"
21#include <optional>

23using namespace clang;

25//----------------------------------------------------------------------------
26// Visitor that collects unexpanded parameter packs
27//----------------------------------------------------------------------------

29namespace {
/// A class that collects unexpanded parameter packs.
class CollectUnexpandedParameterPacksVisitor :
  public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
{
  typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
    inherited;

  SmallVectorImpl<UnexpandedParameterPack> &Unexpanded;

  bool InLambda = false;
  unsigned DepthLimit = (unsigned)-1;

  void addUnexpanded(NamedDecl *ND, SourceLocation Loc = SourceLocation()) {
    if (auto *VD = dyn_cast<VarDecl>(ND)) {
      // For now, the only problematic case is a generic lambda's templated
      // call operator, so we don't need to look for all the other ways we
      // could have reached a dependent parameter pack.
      auto *FD = dyn_cast<FunctionDecl>(VD->getDeclContext());
      auto *FTD = FD ? FD->getDescribedFunctionTemplate() : nullptr;
      if (FTD && FTD->getTemplateParameters()->getDepth() >= DepthLimit)
        return;
    } else if (getDepthAndIndex(ND).first >= DepthLimit)
      return;

    Unexpanded.push_back({ND, Loc});
  }
  void addUnexpanded(const TemplateTypeParmType *T,
                     SourceLocation Loc = SourceLocation()) {
    if (T->getDepth() < DepthLimit)
      Unexpanded.push_back({T, Loc});
  }

public:
  explicit CollectUnexpandedParameterPacksVisitor(
      SmallVectorImpl<UnexpandedParameterPack> &Unexpanded)
      : Unexpanded(Unexpanded) {}

  bool shouldWalkTypesOfTypeLocs() const { return false; }

  //------------------------------------------------------------------------
  // Recording occurrences of (unexpanded) parameter packs.
  //------------------------------------------------------------------------

  /// Record occurrences of template type parameter packs.
  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
    if (TL.getTypePtr()->isParameterPack())
      addUnexpanded(TL.getTypePtr(), TL.getNameLoc());
    return true;
  }

  /// Record occurrences of template type parameter packs
  /// when we don't have proper source-location information for
  /// them.
  ///
  /// Ideally, this routine would never be used.
  bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
    if (T->isParameterPack())
      addUnexpanded(T);

    return true;
  }

  /// Record occurrences of function and non-type template
  /// parameter packs in an expression.
  bool VisitDeclRefExpr(DeclRefExpr *E) {
    if (E->getDecl()->isParameterPack())
      addUnexpanded(E->getDecl(), E->getLocation());

    return true;
  }

  /// Record occurrences of template template parameter packs.
  bool TraverseTemplateName(TemplateName Template) {
    if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>(
            Template.getAsTemplateDecl())) {
      if (TTP->isParameterPack())
        addUnexpanded(TTP);
    }

    return inherited::TraverseTemplateName(Template);
  }

  /// Suppress traversal into Objective-C container literal
  /// elements that are pack expansions.
  bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
    if (!E->containsUnexpandedParameterPack())
      return true;

    for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
      ObjCDictionaryElement Element = E->getKeyValueElement(I);
      if (Element.isPackExpansion())
        continue;

      TraverseStmt(Element.Key);
      TraverseStmt(Element.Value);
    }
    return true;
  }
  //------------------------------------------------------------------------
  // Pruning the search for unexpanded parameter packs.
  //------------------------------------------------------------------------

  /// Suppress traversal into statements and expressions that
  /// do not contain unexpanded parameter packs.
  bool TraverseStmt(Stmt *S) {
    Expr *E = dyn_cast_or_null<Expr>(S);
    if ((E && E->containsUnexpandedParameterPack()) || InLambda)
      return inherited::TraverseStmt(S);

    return true;
  }

  /// Suppress traversal into types that do not contain
  /// unexpanded parameter packs.
  bool TraverseType(QualType T) {
    if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda)
      return inherited::TraverseType(T);

    return true;
  }

  /// Suppress traversal into types with location information
  /// that do not contain unexpanded parameter packs.
  bool TraverseTypeLoc(TypeLoc TL) {
    if ((!TL.getType().isNull() &&
         TL.getType()->containsUnexpandedParameterPack()) ||
        InLambda)
      return inherited::TraverseTypeLoc(TL);

    return true;
  }

  /// Suppress traversal of parameter packs.
  bool TraverseDecl(Decl *D) {
    // A function parameter pack is a pack expansion, so cannot contain
    // an unexpanded parameter pack. Likewise for a template parameter
    // pack that contains any references to other packs.
    if (D && D->isParameterPack())
      return true;

    return inherited::TraverseDecl(D);
  }

  /// Suppress traversal of pack-expanded attributes.
  bool TraverseAttr(Attr *A) {
    if (A->isPackExpansion())
      return true;

    return inherited::TraverseAttr(A);
  }

  /// Suppress traversal of pack expansion expressions and types.
  ///@{
  bool TraversePackExpansionType(PackExpansionType *T) { return true; }
  bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; }
  bool TraversePackExpansionExpr(PackExpansionExpr *E) { return true; }
  bool TraverseCXXFoldExpr(CXXFoldExpr *E) { return true; }

  ///@}

  /// Suppress traversal of using-declaration pack expansion.
  bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
    if (D->isPackExpansion())
      return true;

    return inherited::TraverseUnresolvedUsingValueDecl(D);
  }

  /// Suppress traversal of using-declaration pack expansion.
  bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
    if (D->isPackExpansion())
      return true;

    return inherited::TraverseUnresolvedUsingTypenameDecl(D);
  }

  /// Suppress traversal of template argument pack expansions.
  bool TraverseTemplateArgument(const TemplateArgument &Arg) {
    if (Arg.isPackExpansion())
      return true;

    return inherited::TraverseTemplateArgument(Arg);
  }

  /// Suppress traversal of template argument pack expansions.
  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
    if (ArgLoc.getArgument().isPackExpansion())
      return true;

    return inherited::TraverseTemplateArgumentLoc(ArgLoc);
  }

  /// Suppress traversal of base specifier pack expansions.
  bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base) {
    if (Base.isPackExpansion())
      return true;

    return inherited::TraverseCXXBaseSpecifier(Base);
  }

  /// Suppress traversal of mem-initializer pack expansions.
  bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
    if (Init->isPackExpansion())
      return true;

    return inherited::TraverseConstructorInitializer(Init);
  }

  /// Note whether we're traversing a lambda containing an unexpanded
  /// parameter pack. In this case, the unexpanded pack can occur anywhere,
  /// including all the places where we normally wouldn't look. Within a
  /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit
  /// outside an expression.
  bool TraverseLambdaExpr(LambdaExpr *Lambda) {
    // The ContainsUnexpandedParameterPack bit on a lambda is always correct,
    // even if it's contained within another lambda.
    if (!Lambda->containsUnexpandedParameterPack())
      return true;

    bool WasInLambda = InLambda;
    unsigned OldDepthLimit = DepthLimit;

    InLambda = true;
    if (auto *TPL = Lambda->getTemplateParameterList())
      DepthLimit = TPL->getDepth();

    inherited::TraverseLambdaExpr(Lambda);

    InLambda = WasInLambda;
    DepthLimit = OldDepthLimit;
    return true;
  }

  /// Suppress traversal within pack expansions in lambda captures.
  bool TraverseLambdaCapture(LambdaExpr *Lambda, const LambdaCapture *C,
                             Expr *Init) {
    if (C->isPackExpansion())
      return true;

    return inherited::TraverseLambdaCapture(Lambda, C, Init);
  }
};
272}

274/// Determine whether it's possible for an unexpanded parameter pack to
275/// be valid in this location. This only happens when we're in a declaration
276/// that is nested within an expression that could be expanded, such as a
277/// lambda-expression within a function call.
278///
279/// This is conservatively correct, but may claim that some unexpanded packs are
280/// permitted when they are not.
281bool Sema::isUnexpandedParameterPackPermitted() {
for (auto *SI : FunctionScopes)
  if (isa<sema::LambdaScopeInfo>(SI))
    return true;
return false;
286}

288/// Diagnose all of the unexpanded parameter packs in the given
289/// vector.
290bool
291Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
                                     UnexpandedParameterPackContext UPPC,
                               ArrayRef<UnexpandedParameterPack> Unexpanded) {
if (Unexpanded.empty())
  return false;

// If we are within a lambda expression and referencing a pack that is not
// declared within the lambda itself, that lambda contains an unexpanded
// parameter pack, and we are done.
// FIXME: Store 'Unexpanded' on the lambda so we don't need to recompute it
// later.
SmallVector<UnexpandedParameterPack, 4> LambdaParamPackReferences;
if (auto *LSI = getEnclosingLambda()) {
  for (auto &Pack : Unexpanded) {
    auto DeclaresThisPack = [&](NamedDecl *LocalPack) {
      if (auto *TTPT = Pack.first.dyn_cast<const TemplateTypeParmType *>()) {
        auto *TTPD = dyn_cast<TemplateTypeParmDecl>(LocalPack);
        return TTPD && TTPD->getTypeForDecl() == TTPT;
      }
      return declaresSameEntity(Pack.first.get<NamedDecl *>(), LocalPack);
    };
    if (llvm::any_of(LSI->LocalPacks, DeclaresThisPack))
      LambdaParamPackReferences.push_back(Pack);
  }

  if (LambdaParamPackReferences.empty()) {
    // Construct in lambda only references packs declared outside the lambda.
    // That's OK for now, but the lambda itself is considered to contain an
    // unexpanded pack in this case, which will require expansion outside the
    // lambda.

    // We do not permit pack expansion that would duplicate a statement
    // expression, not even within a lambda.
    // FIXME: We could probably support this for statement expressions that
    // do not contain labels.
    // FIXME: This is insufficient to detect this problem; consider
    //   f( ({ bad: 0; }) + pack ... );
    bool EnclosingStmtExpr = false;
    for (unsigned N = FunctionScopes.size(); N; --N) {
      sema::FunctionScopeInfo *Func = FunctionScopes[N-1];
      if (llvm::any_of(
              Func->CompoundScopes,
              [](sema::CompoundScopeInfo &CSI) { return CSI.IsStmtExpr; })) {
        EnclosingStmtExpr = true;
        break;
      }
      // Coumpound-statements outside the lambda are OK for now; we'll check
      // for those when we finish handling the lambda.
      if (Func == LSI)
        break;
    }

    if (!EnclosingStmtExpr) {
      LSI->ContainsUnexpandedParameterPack = true;
      return false;
    }
  } else {
    Unexpanded = LambdaParamPackReferences;
  }
}

SmallVector<SourceLocation, 4> Locations;
SmallVector<IdentifierInfo *, 4> Names;
llvm::SmallPtrSet<IdentifierInfo *, 4> NamesKnown;

for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
  IdentifierInfo *Name = nullptr;
  if (const TemplateTypeParmType *TTP
        = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>())
    Name = TTP->getIdentifier();
  else
    Name = Unexpanded[I].first.get<NamedDecl *>()->getIdentifier();

  if (Name && NamesKnown.insert(Name).second)
    Names.push_back(Name);

  if (Unexpanded[I].second.isValid())
    Locations.push_back(Unexpanded[I].second);
}

auto DB = Diag(Loc, diag::err_unexpanded_parameter_pack)
          << (int)UPPC << (int)Names.size();
for (size_t I = 0, E = std::min(Names.size(), (size_t)2); I != E; ++I)
  DB << Names[I];

for (unsigned I = 0, N = Locations.size(); I != N; ++I)
  DB << SourceRange(Locations[I]);
return true;
379}

381bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
                                         TypeSourceInfo *T,
                                       UnexpandedParameterPackContext UPPC) {
// C++0x [temp.variadic]p5:
//   An appearance of a name of a parameter pack that is not expanded is
//   ill-formed.
if (!T->getType()->containsUnexpandedParameterPack())
  return false;

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(
                                                            T->getTypeLoc());
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 393, __extension__
 __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
395}

397bool Sema::DiagnoseUnexpandedParameterPack(Expr *E,
                                      UnexpandedParameterPackContext UPPC) {
// C++0x [temp.variadic]p5:
//   An appearance of a name of a parameter pack that is not expanded is
//   ill-formed.
if (!E->containsUnexpandedParameterPack())
  return false;

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E);
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 407, __extension__
 __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(E->getBeginLoc(), UPPC, Unexpanded);
409}

411bool Sema::DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE) {
if (!RE->containsUnexpandedParameterPack())
  return false;

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(RE);
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 417, __extension__
 __PRETTY_FUNCTION__));

// We only care about unexpanded references to the RequiresExpr's own
// parameter packs.
auto Parms = RE->getLocalParameters();
llvm::SmallPtrSet<NamedDecl*, 8> ParmSet(Parms.begin(), Parms.end());
SmallVector<UnexpandedParameterPack, 2> UnexpandedParms;
for (auto Parm : Unexpanded)
  if (ParmSet.contains(Parm.first.dyn_cast<NamedDecl *>()))
    UnexpandedParms.push_back(Parm);
if (UnexpandedParms.empty())
  return false;

return DiagnoseUnexpandedParameterPacks(RE->getBeginLoc(), UPPC_Requirement,
                                        UnexpandedParms);
432}

434bool Sema::DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
                                      UnexpandedParameterPackContext UPPC) {
// C++0x [temp.variadic]p5:
//   An appearance of a name of a parameter pack that is not expanded is
//   ill-formed.
if (!SS.getScopeRep() ||
    !SS.getScopeRep()->containsUnexpandedParameterPack())
  return false;

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseNestedNameSpecifier(SS.getScopeRep());
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 446, __extension__
 __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(SS.getRange().getBegin(),
                                        UPPC, Unexpanded);
449}

451bool Sema::DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
                                       UnexpandedParameterPackContext UPPC) {
// C++0x [temp.variadic]p5:
//   An appearance of a name of a parameter pack that is not expanded is
//   ill-formed.
switch (NameInfo.getName().getNameKind()) {
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXOperatorName:
case DeclarationName::CXXLiteralOperatorName:
case DeclarationName::CXXUsingDirective:
case DeclarationName::CXXDeductionGuideName:
  return false;

case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
  // FIXME: We shouldn't need this null check!
  if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
    return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC);

  if (!NameInfo.getName().getCXXNameType()->containsUnexpandedParameterPack())
    return false;

  break;
}

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseType(NameInfo.getName().getCXXNameType());
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 483, __extension__
 __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
485}

487bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
                                         TemplateName Template,
                                     UnexpandedParameterPackContext UPPC) {

if (Template.isNull() || !Template.containsUnexpandedParameterPack())
  return false;

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseTemplateName(Template);
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 497, __extension__
 __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
499}

501bool Sema::DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
                                       UnexpandedParameterPackContext UPPC) {
if (Arg.getArgument().isNull() ||
    !Arg.getArgument().containsUnexpandedParameterPack())
  return false;

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseTemplateArgumentLoc(Arg);
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 510, __extension__
 __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
512}

514void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg,
                 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseTemplateArgument(Arg);
518}

520void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
                 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseTemplateArgumentLoc(Arg);
524}

526void Sema::collectUnexpandedParameterPacks(QualType T,
                 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
529}

531void Sema::collectUnexpandedParameterPacks(TypeLoc TL,
                 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
534}

536void Sema::collectUnexpandedParameterPacks(
  NestedNameSpecifierLoc NNS,
  SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
CollectUnexpandedParameterPacksVisitor(Unexpanded)
    .TraverseNestedNameSpecifierLoc(NNS);
541}

543void Sema::collectUnexpandedParameterPacks(
  const DeclarationNameInfo &NameInfo,
  SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseDeclarationNameInfo(NameInfo);
548}


551ParsedTemplateArgument
552Sema::ActOnPackExpansion(const ParsedTemplateArgument &Arg,
                       SourceLocation EllipsisLoc) {
if (Arg.isInvalid())
  return Arg;

switch (Arg.getKind()) {
case ParsedTemplateArgument::Type: {
  TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc);
  if (Result.isInvalid())
    return ParsedTemplateArgument();

  return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(),
                                Arg.getLocation());
}

case ParsedTemplateArgument::NonType: {
  ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
  if (Result.isInvalid())
    return ParsedTemplateArgument();

  return ParsedTemplateArgument(Arg.getKind(), Result.get(),
                                Arg.getLocation());
}

case ParsedTemplateArgument::Template:
  if (!Arg.getAsTemplate().get().containsUnexpandedParameterPack()) {
    SourceRange R(Arg.getLocation());
    if (Arg.getScopeSpec().isValid())
      R.setBegin(Arg.getScopeSpec().getBeginLoc());
    Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
      << R;
    return ParsedTemplateArgument();
  }

  return Arg.getTemplatePackExpansion(EllipsisLoc);
}
llvm_unreachable("Unhandled template argument kind?")::llvm::llvm_unreachable_internal("Unhandled template argument kind?"
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 588);
589}

591TypeResult Sema::ActOnPackExpansion(ParsedType Type,
                                  SourceLocation EllipsisLoc) {
TypeSourceInfo *TSInfo;
GetTypeFromParser(Type, &TSInfo);
if (!TSInfo)
  return true;

TypeSourceInfo *TSResult =
    CheckPackExpansion(TSInfo, EllipsisLoc, std::nullopt);
if (!TSResult)
  return true;

return CreateParsedType(TSResult->getType(), TSResult);
604}

606TypeSourceInfo *
607Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc,
                       std::optional<unsigned> NumExpansions) {
// Create the pack expansion type and source-location information.
QualType Result = CheckPackExpansion(Pattern->getType(),
                                     Pattern->getTypeLoc().getSourceRange(),
                                     EllipsisLoc, NumExpansions);
if (Result.isNull())
  return nullptr;

TypeLocBuilder TLB;
TLB.pushFullCopy(Pattern->getTypeLoc());
PackExpansionTypeLoc TL = TLB.push<PackExpansionTypeLoc>(Result);
TL.setEllipsisLoc(EllipsisLoc);

return TLB.getTypeSourceInfo(Context, Result);
622}

624QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange,
                                SourceLocation EllipsisLoc,
                                std::optional<unsigned> NumExpansions) {
// C++11 [temp.variadic]p5:
//   The pattern of a pack expansion shall name one or more
//   parameter packs that are not expanded by a nested pack
//   expansion.
//
// A pattern containing a deduced type can't occur "naturally" but arises in
// the desugaring of an init-capture pack.
if (!Pattern->containsUnexpandedParameterPack() &&
    !Pattern->getContainedDeducedType()) {
  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
    << PatternRange;
  return QualType();
}

return Context.getPackExpansionType(Pattern, NumExpansions,
                                    /*ExpectPackInType=*/false);
643}

645ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
return CheckPackExpansion(Pattern, EllipsisLoc, std::nullopt);
647}

649ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
                                  std::optional<unsigned> NumExpansions) {
if (!Pattern)
  return ExprError();

// C++0x [temp.variadic]p5:
//   The pattern of a pack expansion shall name one or more
//   parameter packs that are not expanded by a nested pack
//   expansion.
if (!Pattern->containsUnexpandedParameterPack()) {
  Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
  << Pattern->getSourceRange();
  CorrectDelayedTyposInExpr(Pattern);
  return ExprError();
}

// Create the pack expansion expression and source-location information.
return new (Context)
  PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions);
668}

670bool Sema::CheckParameterPacksForExpansion(
  SourceLocation EllipsisLoc, SourceRange PatternRange,
  ArrayRef<UnexpandedParameterPack> Unexpanded,
  const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
  bool &RetainExpansion, std::optional<unsigned> &NumExpansions) {
ShouldExpand = true;
RetainExpansion = false;
std::pair<IdentifierInfo *, SourceLocation> FirstPack;
bool HaveFirstPack = false;
std::optional<unsigned> NumPartialExpansions;
SourceLocation PartiallySubstitutedPackLoc;

for (UnexpandedParameterPack ParmPack : Unexpanded) {
1
Assuming '__begin1' is not equal to '__end1'→
  // Compute the depth and index for this parameter pack.
  unsigned Depth = 0, Index = 0;
  IdentifierInfo *Name;
  bool IsVarDeclPack = false;

  if (const TemplateTypeParmType *TTP26.1
'TTP' is null
1
'TTP' is null
1
'TTP' is null
 =
2
←
Assuming 'TTP' is non-null→
3
←
Taking true branch→
27
←
Taking false branch→
          ParmPack.first.dyn_cast<const TemplateTypeParmType *>()) {
13
←
Calling 'PointerUnion::dyn_cast'→
26
←
Returning from 'PointerUnion::dyn_cast'→
    Depth = TTP->getDepth();
    Index = TTP->getIndex();
    Name = TTP->getIdentifier();
  } else {
    NamedDecl *ND = ParmPack.first.get<NamedDecl *>();
    if (isa<VarDecl>(ND))
28
←
Assuming 'ND' is a 'class clang::VarDecl &'→
29
←
Taking true branch→
      IsVarDeclPack = true;
    else
      std::tie(Depth, Index) = getDepthAndIndex(ND);

    Name = ND->getIdentifier();
  }

  // Determine the size of this argument pack.
  unsigned NewPackSize;
  if (IsVarDeclPack3.1
'IsVarDeclPack' is false
1
'IsVarDeclPack' is true
1
'IsVarDeclPack' is false
1
'IsVarDeclPack' is true
1
'IsVarDeclPack' is false
1
'IsVarDeclPack' is true
) {
30
←
Taking true branch→
    // Figure out whether we're instantiating to an argument pack or not.
    typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;

    llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation =
        CurrentInstantiationScope->findInstantiationOf(
31
←
Called C++ object pointer is null
            ParmPack.first.get<NamedDecl *>());
    if (Instantiation->is<DeclArgumentPack *>()) {
      // We could expand this function parameter pack.
      NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
    } else {
      // We can't expand this function parameter pack, so we can't expand
      // the pack expansion.
      ShouldExpand = false;
      continue;
    }
  } else {
    // If we don't have a template argument at this depth/index, then we
    // cannot expand the pack expansion. Make a note of this, but we still
    // want to check any parameter packs we *do* have arguments for.
    if (Depth >= TemplateArgs.getNumLevels() ||
4
←
Assuming the condition is false→
6
←
Taking false branch→
        !TemplateArgs.hasTemplateArgument(Depth, Index)) {
5
←
Assuming the condition is false→
      ShouldExpand = false;
      continue;
    }

    // Determine the size of the argument pack.
    NewPackSize = TemplateArgs(Depth, Index).pack_size();
  }

  // C++0x [temp.arg.explicit]p9:
  //   Template argument deduction can extend the sequence of template
  //   arguments corresponding to a template parameter pack, even when the
  //   sequence contains explicitly specified template arguments.
  if (!IsVarDeclPack6.1
'IsVarDeclPack' is false
1
'IsVarDeclPack' is false
1
'IsVarDeclPack' is false
 && CurrentInstantiationScope) {
7
←
Assuming field 'CurrentInstantiationScope' is null→
8
←
Assuming pointer value is null→
9
←
Taking false branch→
    if (NamedDecl *PartialPack =
            CurrentInstantiationScope->getPartiallySubstitutedPack()) {
      unsigned PartialDepth, PartialIndex;
      std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
      if (PartialDepth == Depth && PartialIndex == Index) {
        RetainExpansion = true;
        // We don't actually know the new pack size yet.
        NumPartialExpansions = NewPackSize;
        PartiallySubstitutedPackLoc = ParmPack.second;
        continue;
      }
    }
  }

  if (!NumExpansions) {
10
←
Assuming the condition is true→
11
←
Taking true branch→
    // The is the first pack we've seen for which we have an argument.
    // Record it.
    NumExpansions = NewPackSize;
    FirstPack.first = Name;
    FirstPack.second = ParmPack.second;
    HaveFirstPack = true;
    continue;
12
←
 Execution continues on line 682→
  }

  if (NewPackSize != *NumExpansions) {
    // C++0x [temp.variadic]p5:
    //   All of the parameter packs expanded by a pack expansion shall have
    //   the same number of arguments specified.
    if (HaveFirstPack)
      Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
          << FirstPack.first << Name << *NumExpansions << NewPackSize
          << SourceRange(FirstPack.second) << SourceRange(ParmPack.second);
    else
      Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
          << Name << *NumExpansions << NewPackSize
          << SourceRange(ParmPack.second);
    return true;
  }
}

// If we're performing a partial expansion but we also have a full expansion,
// expand to the number of common arguments. For example, given:
//
//   template<typename ...T> struct A {
//     template<typename ...U> void f(pair<T, U>...);
//   };
//
// ... a call to 'A<int, int>().f<int>' should expand the pack once and
// retain an expansion.
if (NumPartialExpansions) {
  if (NumExpansions && *NumExpansions < *NumPartialExpansions) {
    NamedDecl *PartialPack =
        CurrentInstantiationScope->getPartiallySubstitutedPack();
    Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_partial)
        << PartialPack << *NumPartialExpansions << *NumExpansions
        << SourceRange(PartiallySubstitutedPackLoc);
    return true;
  }

  NumExpansions = NumPartialExpansions;
}

return false;
803}

805std::optional<unsigned> Sema::getNumArgumentsInExpansion(
  QualType T, const MultiLevelTemplateArgumentList &TemplateArgs) {
QualType Pattern = cast<PackExpansionType>(T)->getPattern();
SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);

std::optional<unsigned> Result;
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
  // Compute the depth and index for this parameter pack.
  unsigned Depth;
  unsigned Index;

  if (const TemplateTypeParmType *TTP =
          Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
    Depth = TTP->getDepth();
    Index = TTP->getIndex();
  } else {
    NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
    if (isa<VarDecl>(ND)) {
      // Function parameter pack or init-capture pack.
      typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;

      llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation =
          CurrentInstantiationScope->findInstantiationOf(
              Unexpanded[I].first.get<NamedDecl *>());
      if (Instantiation->is<Decl *>())
        // The pattern refers to an unexpanded pack. We're not ready to expand
        // this pack yet.
        return std::nullopt;

      unsigned Size = Instantiation->get<DeclArgumentPack *>()->size();
      assert((!Result || *Result == Size) && "inconsistent pack sizes")(static_cast <bool> ((!Result || *Result == Size) &&
 "inconsistent pack sizes") ? void (0) : __assert_fail ("(!Result || *Result == Size) && \"inconsistent pack sizes\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 836, __extension__
 __PRETTY_FUNCTION__));
      Result = Size;
      continue;
    }

    std::tie(Depth, Index) = getDepthAndIndex(ND);
  }
  if (Depth >= TemplateArgs.getNumLevels() ||
      !TemplateArgs.hasTemplateArgument(Depth, Index))
    // The pattern refers to an unknown template argument. We're not ready to
    // expand this pack yet.
    return std::nullopt;

  // Determine the size of the argument pack.
  unsigned Size = TemplateArgs(Depth, Index).pack_size();
  assert((!Result || *Result == Size) && "inconsistent pack sizes")(static_cast <bool> ((!Result || *Result == Size) &&
 "inconsistent pack sizes") ? void (0) : __assert_fail ("(!Result || *Result == Size) && \"inconsistent pack sizes\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 851, __extension__
 __PRETTY_FUNCTION__));
  Result = Size;
}

return Result;
856}

858bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
const DeclSpec &DS = D.getDeclSpec();
switch (DS.getTypeSpecType()) {
case TST_typename:
case TST_typeof_unqualType:
case TST_typeofType:
864#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case TST_##Trait:
865#include "clang/Basic/TransformTypeTraits.def"
case TST_atomic: {
  QualType T = DS.getRepAsType().get();
  if (!T.isNull() && T->containsUnexpandedParameterPack())
    return true;
  break;
}

case TST_typeof_unqualExpr:
case TST_typeofExpr:
case TST_decltype:
case TST_bitint:
  if (DS.getRepAsExpr() &&
      DS.getRepAsExpr()->containsUnexpandedParameterPack())
    return true;
  break;

case TST_unspecified:
case TST_void:
case TST_char:
case TST_wchar:
case TST_char8:
case TST_char16:
case TST_char32:
case TST_int:
case TST_int128:
case TST_half:
case TST_float:
case TST_double:
case TST_Accum:
case TST_Fract:
case TST_Float16:
case TST_float128:
case TST_ibm128:
case TST_bool:
case TST_decimal32:
case TST_decimal64:
case TST_decimal128:
case TST_enum:
case TST_union:
case TST_struct:
case TST_interface:
case TST_class:
case TST_auto:
case TST_auto_type:
case TST_decltype_auto:
case TST_BFloat16:
912#define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
913#include "clang/Basic/OpenCLImageTypes.def"
case TST_unknown_anytype:
case TST_error:
  break;
}

for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
  const DeclaratorChunk &Chunk = D.getTypeObject(I);
  switch (Chunk.Kind) {
  case DeclaratorChunk::Pointer:
  case DeclaratorChunk::Reference:
  case DeclaratorChunk::Paren:
  case DeclaratorChunk::Pipe:
  case DeclaratorChunk::BlockPointer:
    // These declarator chunks cannot contain any parameter packs.
    break;

  case DeclaratorChunk::Array:
    if (Chunk.Arr.NumElts &&
        Chunk.Arr.NumElts->containsUnexpandedParameterPack())
      return true;
    break;
  case DeclaratorChunk::Function:
    for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
      ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
      QualType ParamTy = Param->getType();
      assert(!ParamTy.isNull() && "Couldn't parse type?")(static_cast <bool> (!ParamTy.isNull() && "Couldn't parse type?"
) ? void (0) : __assert_fail ("!ParamTy.isNull() && \"Couldn't parse type?\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 939, __extension__
 __PRETTY_FUNCTION__));
      if (ParamTy->containsUnexpandedParameterPack()) return true;
    }

    if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
      for (unsigned i = 0; i != Chunk.Fun.getNumExceptions(); ++i) {
        if (Chunk.Fun.Exceptions[i]
                .Ty.get()
                ->containsUnexpandedParameterPack())
          return true;
      }
    } else if (isComputedNoexcept(Chunk.Fun.getExceptionSpecType()) &&
               Chunk.Fun.NoexceptExpr->containsUnexpandedParameterPack())
      return true;

    if (Chunk.Fun.hasTrailingReturnType()) {
      QualType T = Chunk.Fun.getTrailingReturnType().get();
      if (!T.isNull() && T->containsUnexpandedParameterPack())
        return true;
    }
    break;

  case DeclaratorChunk::MemberPointer:
    if (Chunk.Mem.Scope().getScopeRep() &&
        Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack())
      return true;
    break;
  }
}

if (Expr *TRC = D.getTrailingRequiresClause())
  if (TRC->containsUnexpandedParameterPack())
    return true;

return false;
974}

976namespace {

978// Callback to only accept typo corrections that refer to parameter packs.
979class ParameterPackValidatorCCC final : public CorrectionCandidateCallback {
public:
bool ValidateCandidate(const TypoCorrection &candidate) override {
  NamedDecl *ND = candidate.getCorrectionDecl();
  return ND && ND->isParameterPack();
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return std::make_unique<ParameterPackValidatorCCC>(*this);
}
989};

991}

993/// Called when an expression computing the size of a parameter pack
994/// is parsed.
995///
996/// \code
997/// template<typename ...Types> struct count {
998///   static const unsigned value = sizeof...(Types);
999/// };
1000/// \endcode
1001///
1002//
1003/// \param OpLoc The location of the "sizeof" keyword.
1004/// \param Name The name of the parameter pack whose size will be determined.
1005/// \param NameLoc The source location of the name of the parameter pack.
1006/// \param RParenLoc The location of the closing parentheses.
1007ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
                                            SourceLocation OpLoc,
                                            IdentifierInfo &Name,
                                            SourceLocation NameLoc,
                                            SourceLocation RParenLoc) {
// C++0x [expr.sizeof]p5:
//   The identifier in a sizeof... expression shall name a parameter pack.
LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
LookupName(R, S);

NamedDecl *ParameterPack = nullptr;
switch (R.getResultKind()) {
case LookupResult::Found:
  ParameterPack = R.getFoundDecl();
  break;

case LookupResult::NotFound:
case LookupResult::NotFoundInCurrentInstantiation: {
  ParameterPackValidatorCCC CCC{};
  if (TypoCorrection Corrected =
          CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
                      CCC, CTK_ErrorRecovery)) {
    diagnoseTypo(Corrected,
                 PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
                 PDiag(diag::note_parameter_pack_here));
    ParameterPack = Corrected.getCorrectionDecl();
  }
  break;
}
case LookupResult::FoundOverloaded:
case LookupResult::FoundUnresolvedValue:
  break;

case LookupResult::Ambiguous:
  DiagnoseAmbiguousLookup(R);
  return ExprError();
}

if (!ParameterPack || !ParameterPack->isParameterPack()) {
  Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
    << &Name;
  return ExprError();
}

MarkAnyDeclReferenced(OpLoc, ParameterPack, true);

return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc,
                              RParenLoc);
1055}

1057TemplateArgumentLoc Sema::getTemplateArgumentPackExpansionPattern(
  TemplateArgumentLoc OrigLoc, SourceLocation &Ellipsis,
  std::optional<unsigned> &NumExpansions) const {
const TemplateArgument &Argument = OrigLoc.getArgument();
assert(Argument.isPackExpansion())(static_cast <bool> (Argument.isPackExpansion()) ? void
 (0) : __assert_fail ("Argument.isPackExpansion()", "clang/lib/Sema/SemaTemplateVariadic.cpp"
, 1061, __extension__ __PRETTY_FUNCTION__));
switch (Argument.getKind()) {
case TemplateArgument::Type: {
  // FIXME: We shouldn't ever have to worry about missing
  // type-source info!
  TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
  if (!ExpansionTSInfo)
    ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
                                                       Ellipsis);
  PackExpansionTypeLoc Expansion =
      ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
  Ellipsis = Expansion.getEllipsisLoc();

  TypeLoc Pattern = Expansion.getPatternLoc();
  NumExpansions = Expansion.getTypePtr()->getNumExpansions();

  // We need to copy the TypeLoc because TemplateArgumentLocs store a
  // TypeSourceInfo.
  // FIXME: Find some way to avoid the copy?
  TypeLocBuilder TLB;
  TLB.pushFullCopy(Pattern);
  TypeSourceInfo *PatternTSInfo =
      TLB.getTypeSourceInfo(Context, Pattern.getType());
  return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
                             PatternTSInfo);
}

case TemplateArgument::Expression: {
  PackExpansionExpr *Expansion
    = cast<PackExpansionExpr>(Argument.getAsExpr());
  Expr *Pattern = Expansion->getPattern();
  Ellipsis = Expansion->getEllipsisLoc();
  NumExpansions = Expansion->getNumExpansions();
  return TemplateArgumentLoc(Pattern, Pattern);
}

case TemplateArgument::TemplateExpansion:
  Ellipsis = OrigLoc.getTemplateEllipsisLoc();
  NumExpansions = Argument.getNumTemplateExpansions();
  return TemplateArgumentLoc(Context, Argument.getPackExpansionPattern(),
                             OrigLoc.getTemplateQualifierLoc(),
                             OrigLoc.getTemplateNameLoc());

case TemplateArgument::Declaration:
case TemplateArgument::NullPtr:
case TemplateArgument::Template:
case TemplateArgument::Integral:
case TemplateArgument::Pack:
case TemplateArgument::Null:
  return TemplateArgumentLoc();
}

llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!"
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 1113);
1114}

1116std::optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
assert(Arg.containsUnexpandedParameterPack())(static_cast <bool> (Arg.containsUnexpandedParameterPack
()) ? void (0) : __assert_fail ("Arg.containsUnexpandedParameterPack()"
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 1117, __extension__
 __PRETTY_FUNCTION__));

// If this is a substituted pack, grab that pack. If not, we don't know
// the size yet.
// FIXME: We could find a size in more cases by looking for a substituted
// pack anywhere within this argument, but that's not necessary in the common
// case for 'sizeof...(A)' handling.
TemplateArgument Pack;
switch (Arg.getKind()) {
case TemplateArgument::Type:
  if (auto *Subst = Arg.getAsType()->getAs<SubstTemplateTypeParmPackType>())
    Pack = Subst->getArgumentPack();
  else
    return std::nullopt;
  break;

case TemplateArgument::Expression:
  if (auto *Subst =
          dyn_cast<SubstNonTypeTemplateParmPackExpr>(Arg.getAsExpr()))
    Pack = Subst->getArgumentPack();
  else if (auto *Subst = dyn_cast<FunctionParmPackExpr>(Arg.getAsExpr()))  {
    for (VarDecl *PD : *Subst)
      if (PD->isParameterPack())
        return std::nullopt;
    return Subst->getNumExpansions();
  } else
    return std::nullopt;
  break;

case TemplateArgument::Template:
  if (SubstTemplateTemplateParmPackStorage *Subst =
          Arg.getAsTemplate().getAsSubstTemplateTemplateParmPack())
    Pack = Subst->getArgumentPack();
  else
    return std::nullopt;
  break;

case TemplateArgument::Declaration:
case TemplateArgument::NullPtr:
case TemplateArgument::TemplateExpansion:
case TemplateArgument::Integral:
case TemplateArgument::Pack:
case TemplateArgument::Null:
  return std::nullopt;
}

// Check that no argument in the pack is itself a pack expansion.
for (TemplateArgument Elem : Pack.pack_elements()) {
  // There's no point recursing in this case; we would have already
  // expanded this pack expansion into the enclosing pack if we could.
  if (Elem.isPackExpansion())
    return std::nullopt;
}
return Pack.pack_size();
1171}

1173static void CheckFoldOperand(Sema &S, Expr *E) {
if (!E)
  return;

E = E->IgnoreImpCasts();
auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
if ((OCE && OCE->isInfixBinaryOp()) || isa<BinaryOperator>(E) ||
    isa<AbstractConditionalOperator>(E)) {
  S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
      << E->getSourceRange()
      << FixItHint::CreateInsertion(E->getBeginLoc(), "(")
      << FixItHint::CreateInsertion(E->getEndLoc(), ")");
}
1186}

1188ExprResult Sema::ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS,
                                tok::TokenKind Operator,
                                SourceLocation EllipsisLoc, Expr *RHS,
                                SourceLocation RParenLoc) {
// LHS and RHS must be cast-expressions. We allow an arbitrary expression
// in the parser and reduce down to just cast-expressions here.
CheckFoldOperand(*this, LHS);
CheckFoldOperand(*this, RHS);

auto DiscardOperands = [&] {
  CorrectDelayedTyposInExpr(LHS);
  CorrectDelayedTyposInExpr(RHS);
};

// [expr.prim.fold]p3:
//   In a binary fold, op1 and op2 shall be the same fold-operator, and
//   either e1 shall contain an unexpanded parameter pack or e2 shall contain
//   an unexpanded parameter pack, but not both.
if (LHS && RHS &&
    LHS->containsUnexpandedParameterPack() ==
        RHS->containsUnexpandedParameterPack()) {
  DiscardOperands();
  return Diag(EllipsisLoc,
              LHS->containsUnexpandedParameterPack()
                  ? diag::err_fold_expression_packs_both_sides
                  : diag::err_pack_expansion_without_parameter_packs)
      << LHS->getSourceRange() << RHS->getSourceRange();
}

// [expr.prim.fold]p2:
//   In a unary fold, the cast-expression shall contain an unexpanded
//   parameter pack.
if (!LHS || !RHS) {
  Expr *Pack = LHS ? LHS : RHS;
  assert(Pack && "fold expression with neither LHS nor RHS")(static_cast <bool> (Pack && "fold expression with neither LHS nor RHS"
) ? void (0) : __assert_fail ("Pack && \"fold expression with neither LHS nor RHS\""
, "clang/lib/Sema/SemaTemplateVariadic.cpp", 1222, __extension__
 __PRETTY_FUNCTION__));
  if (!Pack->containsUnexpandedParameterPack()) {
    DiscardOperands();
    return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
           << Pack->getSourceRange();
  }
}

BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);

// Perform first-phase name lookup now.
UnresolvedLookupExpr *ULE = nullptr;
{
  UnresolvedSet<16> Functions;
  LookupBinOp(S, EllipsisLoc, Opc, Functions);
  if (!Functions.empty()) {
    DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(
        BinaryOperator::getOverloadedOperator(Opc));
    ExprResult Callee = CreateUnresolvedLookupExpr(
        /*NamingClass*/ nullptr, NestedNameSpecifierLoc(),
        DeclarationNameInfo(OpName, EllipsisLoc), Functions);
    if (Callee.isInvalid())
      return ExprError();
    ULE = cast<UnresolvedLookupExpr>(Callee.get());
  }
}

return BuildCXXFoldExpr(ULE, LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc,
                        std::nullopt);
1251}

1253ExprResult Sema::BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,
                                SourceLocation LParenLoc, Expr *LHS,
                                BinaryOperatorKind Operator,
                                SourceLocation EllipsisLoc, Expr *RHS,
                                SourceLocation RParenLoc,
                                std::optional<unsigned> NumExpansions) {
return new (Context)
    CXXFoldExpr(Context.DependentTy, Callee, LParenLoc, LHS, Operator,
                EllipsisLoc, RHS, RParenLoc, NumExpansions);
1262}

1264ExprResult Sema::BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
                                     BinaryOperatorKind Operator) {
// [temp.variadic]p9:
//   If N is zero for a unary fold-expression, the value of the expression is
//       &&  ->  true
//       ||  ->  false
//       ,   ->  void()
//   if the operator is not listed [above], the instantiation is ill-formed.
//
// Note that we need to use something like int() here, not merely 0, to
// prevent the result from being a null pointer constant.
QualType ScalarType;
switch (Operator) {
case BO_LOr:
  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
case BO_LAnd:
  return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
case BO_Comma:
  ScalarType = Context.VoidTy;
  break;

default:
  return Diag(EllipsisLoc, diag::err_fold_expression_empty)
      << BinaryOperator::getOpcodeStr(Operator);
}

return new (Context) CXXScalarValueInitExpr(
    ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
    EllipsisLoc);
1293}

←

/build/source/llvm/include/llvm/ADT/PointerUnion.h

→

1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file defines the PointerUnion class, which is a discriminated union of
11/// pointer types.
12///
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_ADT_POINTERUNION_H
16#define LLVM_ADT_POINTERUNION_H
17 
18#include "llvm/ADT/DenseMapInfo.h"
19#include "llvm/ADT/PointerIntPair.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/Support/Casting.h"
22#include "llvm/Support/PointerLikeTypeTraits.h"
23#include <algorithm>
24#include <cassert>
25#include <cstddef>
26#include <cstdint>
27 
28namespace llvm {
29 
30namespace pointer_union_detail {
31  /// Determine the number of bits required to store integers with values < n.
32  /// This is ceil(log2(n)).
33  constexpr int bitsRequired(unsigned n) {
34    return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
35  }
36 
37  template <typename... Ts> constexpr int lowBitsAvailable() {
38    return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
39  }
40 
41  /// Find the first type in a list of types.
42  template <typename T, typename...> struct GetFirstType {
43    using type = T;
44  };
45 
46  /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
47  /// for the template arguments.
48  template <typename ...PTs> class PointerUnionUIntTraits {
49  public:
50    static inline void *getAsVoidPointer(void *P) { return P; }
51    static inline void *getFromVoidPointer(void *P) { return P; }
52    static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
53  };
54 
55  template <typename Derived, typename ValTy, int I, typename ...Types>
56  class PointerUnionMembers;
57 
58  template <typename Derived, typename ValTy, int I>
59  class PointerUnionMembers<Derived, ValTy, I> {
60  protected:
61    ValTy Val;
62    PointerUnionMembers() = default;
63    PointerUnionMembers(ValTy Val) : Val(Val) {}
64 
65    friend struct PointerLikeTypeTraits<Derived>;
66  };
67 
68  template <typename Derived, typename ValTy, int I, typename Type,
69            typename ...Types>
70  class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
71      : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
72    using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
73  public:
74    using Base::Base;
75    PointerUnionMembers() = default;
76    PointerUnionMembers(Type V)
77        : Base(ValTy(const_cast<void *>(
78                         PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
79                     I)) {}
80 
81    using Base::operator=;
82    Derived &operator=(Type V) {
83      this->Val = ValTy(
84          const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
85          I);
86      return static_cast<Derived &>(*this);
87    };
88  };
89}
90 
91// This is a forward declaration of CastInfoPointerUnionImpl
92// Refer to its definition below for further details
93template <typename... PTs> struct CastInfoPointerUnionImpl;
94/// A discriminated union of two or more pointer types, with the discriminator
95/// in the low bit of the pointer.
96///
97/// This implementation is extremely efficient in space due to leveraging the
98/// low bits of the pointer, while exposing a natural and type-safe API.
99///
100/// Common use patterns would be something like this:
101///    PointerUnion<int*, float*> P;
102///    P = (int*)0;
103///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
104///    X = P.get<int*>();     // ok.
105///    Y = P.get<float*>();   // runtime assertion failure.
106///    Z = P.get<double*>();  // compile time failure.
107///    P = (float*)0;
108///    Y = P.get<float*>();   // ok.
109///    X = P.get<int*>();     // runtime assertion failure.
110///    PointerUnion<int*, int*> Q; // compile time failure.
111template <typename... PTs>
112class PointerUnion
113    : public pointer_union_detail::PointerUnionMembers<
114          PointerUnion<PTs...>,
115          PointerIntPair<
116              void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
117              pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
118          0, PTs...> {
119  static_assert(TypesAreDistinct<PTs...>::value,
120                "PointerUnion alternative types cannot be repeated");
121  // The first type is special because we want to directly cast a pointer to a
122  // default-initialized union to a pointer to the first type. But we don't
123  // want PointerUnion to be a 'template <typename First, typename ...Rest>'
124  // because it's much more convenient to have a name for the whole pack. So
125  // split off the first type here.
126  using First = TypeAtIndex<0, PTs...>;
127  using Base = typename PointerUnion::PointerUnionMembers;
128 
129  /// This is needed to give the CastInfo implementation below access
130  /// to protected members.
131  /// Refer to its definition for further details.
132  friend struct CastInfoPointerUnionImpl<PTs...>;
133 
134public:
135  PointerUnion() = default;
136 
137  PointerUnion(std::nullptr_t) : PointerUnion() {}
138  using Base::Base;
139 
140  /// Test if the pointer held in the union is null, regardless of
141  /// which type it is.
142  bool isNull() const { return !this->Val.getPointer(); }
143 
144  explicit operator bool() const { return !isNull(); }
145 
146  // FIXME: Replace the uses of is(), get() and dyn_cast() with
147  //        isa<T>, cast<T> and the llvm::dyn_cast<T>
148 
149  /// Test if the Union currently holds the type matching T.
150  template <typename T> inline bool is() const { return isa<T>(*this); }
151 
152  /// Returns the value of the specified pointer type.
153  ///
154  /// If the specified pointer type is incorrect, assert.
155  template <typename T> inline T get() const {
156    assert(isa<T>(*this) && "Invalid accessor called")(static_cast <bool> (isa<T>(*this) && "Invalid accessor called"
) ? void (0) : __assert_fail ("isa<T>(*this) && \"Invalid accessor called\""
, "llvm/include/llvm/ADT/PointerUnion.h", 156, __extension__ __PRETTY_FUNCTION__
));
157    return cast<T>(*this);
158  }
159 
160  /// Returns the current pointer if it is of the specified pointer type,
161  /// otherwise returns null.
162  template <typename T> inline T dyn_cast() const {
163    return llvm::dyn_cast_if_present<T>(*this);
14
←
Calling 'dyn_cast_if_present<const clang::TemplateTypeParmType *, llvm::PointerUnion<const clang::TemplateTypeParmType *, clang::NamedDecl *>>'→
24
←
Returning from 'dyn_cast_if_present<const clang::TemplateTypeParmType *, llvm::PointerUnion<const clang::TemplateTypeParmType *, clang::NamedDecl *>>'→
25
←
Returning null pointer, which participates in a condition later→
164  }
165 
166  /// If the union is set to the first pointer type get an address pointing to
167  /// it.
168  First const *getAddrOfPtr1() const {
169    return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
170  }
171 
172  /// If the union is set to the first pointer type get an address pointing to
173  /// it.
174  First *getAddrOfPtr1() {
175    assert(is<First>() && "Val is not the first pointer")(static_cast <bool> (is<First>() && "Val is not the first pointer"
) ? void (0) : __assert_fail ("is<First>() && \"Val is not the first pointer\""
, "llvm/include/llvm/ADT/PointerUnion.h", 175, __extension__ __PRETTY_FUNCTION__
));
176    assert((static_cast <bool> (PointerLikeTypeTraits<First>
::getAsVoidPointer(get<First>()) == this->Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "llvm/include/llvm/ADT/PointerUnion.h", 179, __extension__ __PRETTY_FUNCTION__
))
177        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==(static_cast <bool> (PointerLikeTypeTraits<First>
::getAsVoidPointer(get<First>()) == this->Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "llvm/include/llvm/ADT/PointerUnion.h", 179, __extension__ __PRETTY_FUNCTION__
))
178            this->Val.getPointer() &&(static_cast <bool> (PointerLikeTypeTraits<First>
::getAsVoidPointer(get<First>()) == this->Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "llvm/include/llvm/ADT/PointerUnion.h", 179, __extension__ __PRETTY_FUNCTION__
))
179        "Can't get the address because PointerLikeTypeTraits changes the ptr")(static_cast <bool> (PointerLikeTypeTraits<First>
::getAsVoidPointer(get<First>()) == this->Val.getPointer
() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? void (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "llvm/include/llvm/ADT/PointerUnion.h", 179, __extension__ __PRETTY_FUNCTION__
));
180    return const_cast<First *>(
181        reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
182  }
183 
184  /// Assignment from nullptr which just clears the union.
185  const PointerUnion &operator=(std::nullptr_t) {
186    this->Val.initWithPointer(nullptr);
187    return *this;
188  }
189 
190  /// Assignment from elements of the union.
191  using Base::operator=;
192 
193  void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
194  static inline PointerUnion getFromOpaqueValue(void *VP) {
195    PointerUnion V;
196    V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
197    return V;
198  }
199};
200 
201template <typename ...PTs>
202bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
203  return lhs.getOpaqueValue() == rhs.getOpaqueValue();
204}
205 
206template <typename ...PTs>
207bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
208  return lhs.getOpaqueValue() != rhs.getOpaqueValue();
209}
210 
211template <typename ...PTs>
212bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
213  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
214}
215 
216/// We can't (at least, at this moment with C++14) declare CastInfo
217/// as a friend of PointerUnion like this:
218/// ```
219///   template<typename To>
220///   friend struct CastInfo<To, PointerUnion<PTs...>>;
221/// ```
222/// The compiler complains 'Partial specialization cannot be declared as a
223/// friend'.
224/// So we define this struct to be a bridge between CastInfo and
225/// PointerUnion.
226template <typename... PTs> struct CastInfoPointerUnionImpl {
227  using From = PointerUnion<PTs...>;
228 
229  template <typename To> static inline bool isPossible(From &F) {
230    return F.Val.getInt() == FirstIndexOfType<To, PTs...>::value;
231  }
232 
233  template <typename To> static To doCast(From &F) {
234    assert(isPossible<To>(F) && "cast to an incompatible type !")(static_cast <bool> (isPossible<To>(F) &&
 "cast to an incompatible type !") ? void (0) : __assert_fail
 ("isPossible<To>(F) && \"cast to an incompatible type !\""
, "llvm/include/llvm/ADT/PointerUnion.h", 234, __extension__ __PRETTY_FUNCTION__
));
235    return PointerLikeTypeTraits<To>::getFromVoidPointer(F.Val.getPointer());
236  }
237};
238 
239// Specialization of CastInfo for PointerUnion
240template <typename To, typename... PTs>
241struct CastInfo<To, PointerUnion<PTs...>>
242    : public DefaultDoCastIfPossible<To, PointerUnion<PTs...>,
243                                     CastInfo<To, PointerUnion<PTs...>>> {
244  using From = PointerUnion<PTs...>;
245  using Impl = CastInfoPointerUnionImpl<PTs...>;
246 
247  static inline bool isPossible(From &f) {
248    return Impl::template isPossible<To>(f);
249  }
250 
251  static To doCast(From &f) { return Impl::template doCast<To>(f); }
252 
253  static inline To castFailed() { return To(); }
19
←
Returning null pointer, which participates in a condition later→
254};
255 
256template <typename To, typename... PTs>
257struct CastInfo<To, const PointerUnion<PTs...>>
258    : public ConstStrippingForwardingCast<To, const PointerUnion<PTs...>,
259                                          CastInfo<To, PointerUnion<PTs...>>> {
260};
261 
262// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
263// # low bits available = min(PT1bits,PT2bits)-1.
264template <typename ...PTs>
265struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
266  static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
267    return P.getOpaqueValue();
268  }
269 
270  static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
271    return PointerUnion<PTs...>::getFromOpaqueValue(P);
272  }
273 
274  // The number of bits available are the min of the pointer types minus the
275  // bits needed for the discriminator.
276  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
277      PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
278};
279 
280// Teach DenseMap how to use PointerUnions as keys.
281template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
282  using Union = PointerUnion<PTs...>;
283  using FirstInfo =
284      DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
285 
286  static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
287 
288  static inline Union getTombstoneKey() {
289    return Union(FirstInfo::getTombstoneKey());
290  }
291 
292  static unsigned getHashValue(const Union &UnionVal) {
293    intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
294    return DenseMapInfo<intptr_t>::getHashValue(key);
295  }
296 
297  static bool isEqual(const Union &LHS, const Union &RHS) {
298    return LHS == RHS;
299  }
300};
301 
302} // end namespace llvm
303 
304#endif // LLVM_ADT_POINTERUNION_H

←

/build/source/llvm/include/llvm/Support/Casting.h

1//===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(),
10// cast_if_present<X>(), and dyn_cast_if_present<X>() templates.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_SUPPORT_CASTING_H
15#define LLVM_SUPPORT_CASTING_H
16 
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/type_traits.h"
19#include <cassert>
20#include <memory>
21#include <optional>
22#include <type_traits>
23 
24namespace llvm {
25 
26//===----------------------------------------------------------------------===//
27// simplify_type
28//===----------------------------------------------------------------------===//
29 
30/// Define a template that can be specialized by smart pointers to reflect the
31/// fact that they are automatically dereferenced, and are not involved with the
32/// template selection process...  the default implementation is a noop.
33// TODO: rename this and/or replace it with other cast traits.
34template <typename From> struct simplify_type {
35  using SimpleType = From; // The real type this represents...
36 
37  // An accessor to get the real value...
38  static SimpleType &getSimplifiedValue(From &Val) { return Val; }
39};
40 
41template <typename From> struct simplify_type<const From> {
42  using NonConstSimpleType = typename simplify_type<From>::SimpleType;
43  using SimpleType = typename add_const_past_pointer<NonConstSimpleType>::type;
44  using RetType =
45      typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
46 
47  static RetType getSimplifiedValue(const From &Val) {
48    return simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val));
49  }
50};
51 
52// TODO: add this namespace once everyone is switched to using the new
53//       interface.
54// namespace detail {
55 
56//===----------------------------------------------------------------------===//
57// isa_impl
58//===----------------------------------------------------------------------===//
59 
60// The core of the implementation of isa<X> is here; To and From should be
61// the names of classes.  This template can be specialized to customize the
62// implementation of isa<> without rewriting it from scratch.
63template <typename To, typename From, typename Enabler = void> struct isa_impl {
64  static inline bool doit(const From &Val) { return To::classof(&Val); }
65};
66 
67// Always allow upcasts, and perform no dynamic check for them.
68template <typename To, typename From>
69struct isa_impl<To, From, std::enable_if_t<std::is_base_of<To, From>::value>> {
70  static inline bool doit(const From &) { return true; }
71};
72 
73template <typename To, typename From> struct isa_impl_cl {
74  static inline bool doit(const From &Val) {
75    return isa_impl<To, From>::doit(Val);
76  }
77};
78 
79template <typename To, typename From> struct isa_impl_cl<To, const From> {
80  static inline bool doit(const From &Val) {
81    return isa_impl<To, From>::doit(Val);
82  }
83};
84 
85template <typename To, typename From>
86struct isa_impl_cl<To, const std::unique_ptr<From>> {
87  static inline bool doit(const std::unique_ptr<From> &Val) {
88    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "llvm/include/llvm/Support/Casting.h", 88, __extension__ __PRETTY_FUNCTION__
));
89    return isa_impl_cl<To, From>::doit(*Val);
90  }
91};
92 
93template <typename To, typename From> struct isa_impl_cl<To, From *> {
94  static inline bool doit(const From *Val) {
95    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "llvm/include/llvm/Support/Casting.h", 95, __extension__ __PRETTY_FUNCTION__
));
96    return isa_impl<To, From>::doit(*Val);
97  }
98};
99 
100template <typename To, typename From> struct isa_impl_cl<To, From *const> {
101  static inline bool doit(const From *Val) {
102    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "llvm/include/llvm/Support/Casting.h", 102, __extension__ __PRETTY_FUNCTION__
));
103    return isa_impl<To, From>::doit(*Val);
104  }
105};
106 
107template <typename To, typename From> struct isa_impl_cl<To, const From *> {
108  static inline bool doit(const From *Val) {
109    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "llvm/include/llvm/Support/Casting.h", 109, __extension__ __PRETTY_FUNCTION__
));
110    return isa_impl<To, From>::doit(*Val);
111  }
112};
113 
114template <typename To, typename From>
115struct isa_impl_cl<To, const From *const> {
116  static inline bool doit(const From *Val) {
117    assert(Val && "isa<> used on a null pointer")(static_cast <bool> (Val && "isa<> used on a null pointer"
) ? void (0) : __assert_fail ("Val && \"isa<> used on a null pointer\""
, "llvm/include/llvm/Support/Casting.h", 117, __extension__ __PRETTY_FUNCTION__
));
118    return isa_impl<To, From>::doit(*Val);
119  }
120};
121 
122template <typename To, typename From, typename SimpleFrom>
123struct isa_impl_wrap {
124  // When From != SimplifiedType, we can simplify the type some more by using
125  // the simplify_type template.
126  static bool doit(const From &Val) {
127    return isa_impl_wrap<To, SimpleFrom,
128                         typename simplify_type<SimpleFrom>::SimpleType>::
129        doit(simplify_type<const From>::getSimplifiedValue(Val));
130  }
131};
132 
133template <typename To, typename FromTy>
134struct isa_impl_wrap<To, FromTy, FromTy> {
135  // When From == SimpleType, we are as simple as we are going to get.
136  static bool doit(const FromTy &Val) {
137    return isa_impl_cl<To, FromTy>::doit(Val);
138  }
139};
140 
141//===----------------------------------------------------------------------===//
142// cast_retty + cast_retty_impl
143//===----------------------------------------------------------------------===//
144 
145template <class To, class From> struct cast_retty;
146 
147// Calculate what type the 'cast' function should return, based on a requested
148// type of To and a source type of From.
149template <class To, class From> struct cast_retty_impl {
150  using ret_type = To &; // Normal case, return Ty&
151};
152template <class To, class From> struct cast_retty_impl<To, const From> {
153  using ret_type = const To &; // Normal case, return Ty&
154};
155 
156template <class To, class From> struct cast_retty_impl<To, From *> {
157  using ret_type = To *; // Pointer arg case, return Ty*
158};
159 
160template <class To, class From> struct cast_retty_impl<To, const From *> {
161  using ret_type = const To *; // Constant pointer arg case, return const Ty*
162};
163 
164template <class To, class From> struct cast_retty_impl<To, const From *const> {
165  using ret_type = const To *; // Constant pointer arg case, return const Ty*
166};
167 
168template <class To, class From>
169struct cast_retty_impl<To, std::unique_ptr<From>> {
170private:
171  using PointerType = typename cast_retty_impl<To, From *>::ret_type;
172  using ResultType = std::remove_pointer_t<PointerType>;
173 
174public:
175  using ret_type = std::unique_ptr<ResultType>;
176};
177 
178template <class To, class From, class SimpleFrom> struct cast_retty_wrap {
179  // When the simplified type and the from type are not the same, use the type
180  // simplifier to reduce the type, then reuse cast_retty_impl to get the
181  // resultant type.
182  using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
183};
184 
185template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
186  // When the simplified type is equal to the from type, use it directly.
187  using ret_type = typename cast_retty_impl<To, FromTy>::ret_type;
188};
189 
190template <class To, class From> struct cast_retty {
191  using ret_type = typename cast_retty_wrap<
192      To, From, typename simplify_type<From>::SimpleType>::ret_type;
193};
194 
195//===----------------------------------------------------------------------===//
196// cast_convert_val
197//===----------------------------------------------------------------------===//
198 
199// Ensure the non-simple values are converted using the simplify_type template
200// that may be specialized by smart pointers...
201//
202template <class To, class From, class SimpleFrom> struct cast_convert_val {
203  // This is not a simple type, use the template to simplify it...
204  static typename cast_retty<To, From>::ret_type doit(const From &Val) {
205    return cast_convert_val<To, SimpleFrom,
206                            typename simplify_type<SimpleFrom>::SimpleType>::
207        doit(simplify_type<From>::getSimplifiedValue(const_cast<From &>(Val)));
208  }
209};
210 
211template <class To, class FromTy> struct cast_convert_val<To, FromTy, FromTy> {
212  // If it's a reference, switch to a pointer to do the cast and then deref it.
213  static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
214    return *(std::remove_reference_t<typename cast_retty<To, FromTy>::ret_type>
215                 *)&const_cast<FromTy &>(Val);
216  }
217};
218 
219template <class To, class FromTy>
220struct cast_convert_val<To, FromTy *, FromTy *> {
221  // If it's a pointer, we can use c-style casting directly.
222  static typename cast_retty<To, FromTy *>::ret_type doit(const FromTy *Val) {
223    return (typename cast_retty<To, FromTy *>::ret_type) const_cast<FromTy *>(
224        Val);
225  }
226};
227 
228//===----------------------------------------------------------------------===//
229// is_simple_type
230//===----------------------------------------------------------------------===//
231 
232template <class X> struct is_simple_type {
233  static const bool value =
234      std::is_same<X, typename simplify_type<X>::SimpleType>::value;
235};
236 
237// } // namespace detail
238 
239//===----------------------------------------------------------------------===//
240// CastIsPossible
241//===----------------------------------------------------------------------===//
242 
243/// This struct provides a way to check if a given cast is possible. It provides
244/// a static function called isPossible that is used to check if a cast can be
245/// performed. It should be overridden like this:
246///
247/// template<> struct CastIsPossible<foo, bar> {
248///   static inline bool isPossible(const bar &b) {
249///     return bar.isFoo();
250///   }
251/// };
252template <typename To, typename From, typename Enable = void>
253struct CastIsPossible {
254  static inline bool isPossible(const From &f) {
255    return isa_impl_wrap<
256        To, const From,
257        typename simplify_type<const From>::SimpleType>::doit(f);
258  }
259};
260 
261// Needed for optional unwrapping. This could be implemented with isa_impl, but
262// we want to implement things in the new method and move old implementations
263// over. In fact, some of the isa_impl templates should be moved over to
264// CastIsPossible.
265template <typename To, typename From>
266struct CastIsPossible<To, std::optional<From>> {
267  static inline bool isPossible(const std::optional<From> &f) {
268    assert(f && "CastIsPossible::isPossible called on a nullopt!")(static_cast <bool> (f && "CastIsPossible::isPossible called on a nullopt!"
) ? void (0) : __assert_fail ("f && \"CastIsPossible::isPossible called on a nullopt!\""
, "llvm/include/llvm/Support/Casting.h", 268, __extension__ __PRETTY_FUNCTION__
));
269    return isa_impl_wrap<
270        To, const From,
271        typename simplify_type<const From>::SimpleType>::doit(*f);
272  }
273};
274 
275/// Upcasting (from derived to base) and casting from a type to itself should
276/// always be possible.
277template <typename To, typename From>
278struct CastIsPossible<To, From,
279                      std::enable_if_t<std::is_base_of<To, From>::value>> {
280  static inline bool isPossible(const From &f) { return true; }
281};
282 
283//===----------------------------------------------------------------------===//
284// Cast traits
285//===----------------------------------------------------------------------===//
286 
287/// All of these cast traits are meant to be implementations for useful casts
288/// that users may want to use that are outside the standard behavior. An
289/// example of how to use a special cast called `CastTrait` is:
290///
291/// template<> struct CastInfo<foo, bar> : public CastTrait<foo, bar> {};
292///
293/// Essentially, if your use case falls directly into one of the use cases
294/// supported by a given cast trait, simply inherit your special CastInfo
295/// directly from one of these to avoid having to reimplement the boilerplate
296/// `isPossible/castFailed/doCast/doCastIfPossible`. A cast trait can also
297/// provide a subset of those functions.
298 
299/// This cast trait just provides castFailed for the specified `To` type to make
300/// CastInfo specializations more declarative. In order to use this, the target
301/// result type must be `To` and `To` must be constructible from `nullptr`.
302template <typename To> struct NullableValueCastFailed {
303  static To castFailed() { return To(nullptr); }
304};
305 
306/// This cast trait just provides the default implementation of doCastIfPossible
307/// to make CastInfo specializations more declarative. The `Derived` template
308/// parameter *must* be provided for forwarding castFailed and doCast.
309template <typename To, typename From, typename Derived>
310struct DefaultDoCastIfPossible {
311  static To doCastIfPossible(From f) {
312    if (!Derived::isPossible(f))
313      return Derived::castFailed();
314    return Derived::doCast(f);
315  }
316};
317 
318namespace detail {
319/// A helper to derive the type to use with `Self` for cast traits, when the
320/// provided CRTP derived type is allowed to be void.
321template <typename OptionalDerived, typename Default>
322using SelfType = std::conditional_t<std::is_same<OptionalDerived, void>::value,
323                                    Default, OptionalDerived>;
324} // namespace detail
325 
326/// This cast trait provides casting for the specific case of casting to a
327/// value-typed object from a pointer-typed object. Note that `To` must be
328/// nullable/constructible from a pointer to `From` to use this cast.
329template <typename To, typename From, typename Derived = void>
330struct ValueFromPointerCast
331    : public CastIsPossible<To, From *>,
332      public NullableValueCastFailed<To>,
333      public DefaultDoCastIfPossible<
334          To, From *,
335          detail::SelfType<Derived, ValueFromPointerCast<To, From>>> {
336  static inline To doCast(From *f) { return To(f); }
337};
338 
339/// This cast trait provides std::unique_ptr casting. It has the semantics of
340/// moving the contents of the input unique_ptr into the output unique_ptr
341/// during the cast. It's also a good example of how to implement a move-only
342/// cast.
343template <typename To, typename From, typename Derived = void>
344struct UniquePtrCast : public CastIsPossible<To, From *> {
345  using Self = detail::SelfType<Derived, UniquePtrCast<To, From>>;
346  using CastResultType = std::unique_ptr<
347      std::remove_reference_t<typename cast_retty<To, From>::ret_type>>;
348 
349  static inline CastResultType doCast(std::unique_ptr<From> &&f) {
350    return CastResultType((typename CastResultType::element_type *)f.release());
351  }
352 
353  static inline CastResultType castFailed() { return CastResultType(nullptr); }
354 
355  static inline CastResultType doCastIfPossible(std::unique_ptr<From> &&f) {
356    if (!Self::isPossible(f))
357      return castFailed();
358    return doCast(f);
359  }
360};
361 
362/// This cast trait provides std::optional<T> casting. This means that if you
363/// have a value type, you can cast it to another value type and have dyn_cast
364/// return an std::optional<T>.
365template <typename To, typename From, typename Derived = void>
366struct OptionalValueCast
367    : public CastIsPossible<To, From>,
368      public DefaultDoCastIfPossible<
369          std::optional<To>, From,
370          detail::SelfType<Derived, OptionalValueCast<To, From>>> {
371  static inline std::optional<To> castFailed() { return std::optional<To>{}; }
372 
373  static inline std::optional<To> doCast(const From &f) { return To(f); }
374};
375 
376/// Provides a cast trait that strips `const` from types to make it easier to
377/// implement a const-version of a non-const cast. It just removes boilerplate
378/// and reduces the amount of code you as the user need to implement. You can
379/// use it like this:
380///
381/// template<> struct CastInfo<foo, bar> {
382///   ...verbose implementation...
383/// };
384///
385/// template<> struct CastInfo<foo, const bar> : public
386///        ConstStrippingForwardingCast<foo, const bar, CastInfo<foo, bar>> {};
387///
388template <typename To, typename From, typename ForwardTo>
389struct ConstStrippingForwardingCast {
390  // Remove the pointer if it exists, then we can get rid of consts/volatiles.
391  using DecayedFrom = std::remove_cv_t<std::remove_pointer_t<From>>;
392  // Now if it's a pointer, add it back. Otherwise, we want a ref.
393  using NonConstFrom = std::conditional_t<std::is_pointer<From>::value,
394                                          DecayedFrom *, DecayedFrom &>;
395 
396  static inline bool isPossible(const From &f) {
397    return ForwardTo::isPossible(const_cast<NonConstFrom>(f));
398  }
399 
400  static inline decltype(auto) castFailed() { return ForwardTo::castFailed(); }
18
←
Calling 'CastInfo::castFailed'→
20
←
Returning from 'CastInfo::castFailed'→
21
←
Returning null pointer, which participates in a condition later→
401 
402  static inline decltype(auto) doCast(const From &f) {
403    return ForwardTo::doCast(const_cast<NonConstFrom>(f));
404  }
405 
406  static inline decltype(auto) doCastIfPossible(const From &f) {
407    return ForwardTo::doCastIfPossible(const_cast<NonConstFrom>(f));
408  }
409};
410 
411/// Provides a cast trait that uses a defined pointer to pointer cast as a base
412/// for reference-to-reference casts. Note that it does not provide castFailed
413/// and doCastIfPossible because a pointer-to-pointer cast would likely just
414/// return `nullptr` which could cause nullptr dereference. You can use it like
415/// this:
416///
417///   template <> struct CastInfo<foo, bar *> { ... verbose implementation... };
418///
419///   template <>
420///   struct CastInfo<foo, bar>
421///       : public ForwardToPointerCast<foo, bar, CastInfo<foo, bar *>> {};
422///
423template <typename To, typename From, typename ForwardTo>
424struct ForwardToPointerCast {
425  static inline bool isPossible(const From &f) {
426    return ForwardTo::isPossible(&f);
427  }
428 
429  static inline decltype(auto) doCast(const From &f) {
430    return *ForwardTo::doCast(&f);
431  }
432};
433 
434//===----------------------------------------------------------------------===//
435// CastInfo
436//===----------------------------------------------------------------------===//
437 
438/// This struct provides a method for customizing the way a cast is performed.
439/// It inherits from CastIsPossible, to support the case of declaring many
440/// CastIsPossible specializations without having to specialize the full
441/// CastInfo.
442///
443/// In order to specialize different behaviors, specify different functions in
444/// your CastInfo specialization.
445/// For isa<> customization, provide:
446///
447///   `static bool isPossible(const From &f)`
448///
449/// For cast<> customization, provide:
450///
451///  `static To doCast(const From &f)`
452///
453/// For dyn_cast<> and the *_if_present<> variants' customization, provide:
454///
455///  `static To castFailed()` and `static To doCastIfPossible(const From &f)`
456///
457/// Your specialization might look something like this:
458///
459///  template<> struct CastInfo<foo, bar> : public CastIsPossible<foo, bar> {
460///    static inline foo doCast(const bar &b) {
461///      return foo(const_cast<bar &>(b));
462///    }
463///    static inline foo castFailed() { return foo(); }
464///    static inline foo doCastIfPossible(const bar &b) {
465///      if (!CastInfo<foo, bar>::isPossible(b))
466///        return castFailed();
467///      return doCast(b);
468///    }
469///  };
470 
471// The default implementations of CastInfo don't use cast traits for now because
472// we need to specify types all over the place due to the current expected
473// casting behavior and the way cast_retty works. New use cases can and should
474// take advantage of the cast traits whenever possible!
475 
476template <typename To, typename From, typename Enable = void>
477struct CastInfo : public CastIsPossible<To, From> {
478  using Self = CastInfo<To, From, Enable>;
479 
480  using CastReturnType = typename cast_retty<To, From>::ret_type;
481 
482  static inline CastReturnType doCast(const From &f) {
483    return cast_convert_val<
484        To, From,
485        typename simplify_type<From>::SimpleType>::doit(const_cast<From &>(f));
486  }
487 
488  // This assumes that you can construct the cast return type from `nullptr`.
489  // This is largely to support legacy use cases - if you don't want this
490  // behavior you should specialize CastInfo for your use case.
491  static inline CastReturnType castFailed() { return CastReturnType(nullptr); }
492 
493  static inline CastReturnType doCastIfPossible(const From &f) {
494    if (!Self::isPossible(f))
495      return castFailed();
496    return doCast(f);
497  }
498};
499 
500/// This struct provides an overload for CastInfo where From has simplify_type
501/// defined. This simply forwards to the appropriate CastInfo with the
502/// simplified type/value, so you don't have to implement both.
503template <typename To, typename From>
504struct CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> {
505  using Self = CastInfo<To, From>;
506  using SimpleFrom = typename simplify_type<From>::SimpleType;
507  using SimplifiedSelf = CastInfo<To, SimpleFrom>;
508 
509  static inline bool isPossible(From &f) {
510    return SimplifiedSelf::isPossible(
511        simplify_type<From>::getSimplifiedValue(f));
512  }
513 
514  static inline decltype(auto) doCast(From &f) {
515    return SimplifiedSelf::doCast(simplify_type<From>::getSimplifiedValue(f));
516  }
517 
518  static inline decltype(auto) castFailed() {
519    return SimplifiedSelf::castFailed();
520  }
521 
522  static inline decltype(auto) doCastIfPossible(From &f) {
523    return SimplifiedSelf::doCastIfPossible(
524        simplify_type<From>::getSimplifiedValue(f));
525  }
526};
527 
528//===----------------------------------------------------------------------===//
529// Pre-specialized CastInfo
530//===----------------------------------------------------------------------===//
531 
532/// Provide a CastInfo specialized for std::unique_ptr.
533template <typename To, typename From>
534struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {};
535 
536/// Provide a CastInfo specialized for std::optional<From>. It's assumed that if
537/// the input is std::optional<From> that the output can be std::optional<To>.
538/// If that's not the case, specialize CastInfo for your use case.
539template <typename To, typename From>
540struct CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> {
541};
542 
543/// isa<X> - Return true if the parameter to the template is an instance of one
544/// of the template type arguments.  Used like this:
545///
546///  if (isa<Type>(myVal)) { ... }
547///  if (isa<Type0, Type1, Type2>(myVal)) { ... }
548template <typename To, typename From>
549[[nodiscard]] inline bool isa(const From &Val) {
550  return CastInfo<To, const From>::isPossible(Val);
551}
552 
553template <typename First, typename Second, typename... Rest, typename From>
554[[nodiscard]] inline bool isa(const From &Val) {
555  return isa<First>(Val) || isa<Second, Rest...>(Val);
556}
557 
558/// cast<X> - Return the argument parameter cast to the specified type.  This
559/// casting operator asserts that the type is correct, so it does not return
560/// null on failure.  It does not allow a null argument (use cast_if_present for
561/// that). It is typically used like this:
562///
563///  cast<Instruction>(myVal)->getParent()
564 
565template <typename To, typename From>
566[[nodiscard]] inline decltype(auto) cast(const From &Val) {
567  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<To>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<To>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 567, __extension__ __PRETTY_FUNCTION__
));
568  return CastInfo<To, const From>::doCast(Val);
569}
570 
571template <typename To, typename From>
572[[nodiscard]] inline decltype(auto) cast(From &Val) {
573  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<To>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<To>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 573, __extension__ __PRETTY_FUNCTION__
));
574  return CastInfo<To, From>::doCast(Val);
575}
576 
577template <typename To, typename From>
578[[nodiscard]] inline decltype(auto) cast(From *Val) {
579  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<To>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<To>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 579, __extension__ __PRETTY_FUNCTION__
));
580  return CastInfo<To, From *>::doCast(Val);
581}
582 
583template <typename To, typename From>
584[[nodiscard]] inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
585  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!")(static_cast <bool> (isa<To>(Val) && "cast<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<To>(Val) && \"cast<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 585, __extension__ __PRETTY_FUNCTION__
));
586  return CastInfo<To, std::unique_ptr<From>>::doCast(std::move(Val));
587}
588 
589//===----------------------------------------------------------------------===//
590// ValueIsPresent
591//===----------------------------------------------------------------------===//
592 
593template <typename T>
594constexpr bool IsNullable =
595    std::is_pointer_v<T> || std::is_constructible_v<T, std::nullptr_t>;
596 
597/// ValueIsPresent provides a way to check if a value is, well, present. For
598/// pointers, this is the equivalent of checking against nullptr, for Optionals
599/// this is the equivalent of checking hasValue(). It also provides a method for
600/// unwrapping a value (think calling .value() on an optional).
601 
602// Generic values can't *not* be present.
603template <typename T, typename Enable = void> struct ValueIsPresent {
604  using UnwrappedType = T;
605  static inline bool isPresent(const T &t) { return true; }
606  static inline decltype(auto) unwrapValue(T &t) { return t; }
607};
608 
609// Optional provides its own way to check if something is present.
610template <typename T> struct ValueIsPresent<std::optional<T>> {
611  using UnwrappedType = T;
612  static inline bool isPresent(const std::optional<T> &t) {
613    return t.has_value();
614  }
615  static inline decltype(auto) unwrapValue(std::optional<T> &t) { return *t; }
616};
617 
618// If something is "nullable" then we just compare it to nullptr to see if it
619// exists.
620template <typename T>
621struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
622  using UnwrappedType = T;
623  static inline bool isPresent(const T &t) { return t != T(nullptr); }
624  static inline decltype(auto) unwrapValue(T &t) { return t; }
625};
626 
627namespace detail {
628// Convenience function we can use to check if a value is present. Because of
629// simplify_type, we have to call it on the simplified type for now.
630template <typename T> inline bool isPresent(const T &t) {
631  return ValueIsPresent<typename simplify_type<T>::SimpleType>::isPresent(
632      simplify_type<T>::getSimplifiedValue(const_cast<T &>(t)));
633}
634 
635// Convenience function we can use to unwrap a value.
636template <typename T> inline decltype(auto) unwrapValue(T &t) {
637  return ValueIsPresent<T>::unwrapValue(t);
638}
639} // namespace detail
640 
641/// dyn_cast<X> - Return the argument parameter cast to the specified type. This
642/// casting operator returns null if the argument is of the wrong type, so it
643/// can be used to test for a type as well as cast if successful. The value
644/// passed in must be present, if not, use dyn_cast_if_present. This should be
645/// used in the context of an if statement like this:
646///
647///  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
648 
649template <typename To, typename From>
650[[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) {
651  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value")(static_cast <bool> (detail::isPresent(Val) && "dyn_cast on a non-existent value"
) ? void (0) : __assert_fail ("detail::isPresent(Val) && \"dyn_cast on a non-existent value\""
, "llvm/include/llvm/Support/Casting.h", 651, __extension__ __PRETTY_FUNCTION__
));
652  return CastInfo<To, const From>::doCastIfPossible(Val);
653}
654 
655template <typename To, typename From>
656[[nodiscard]] inline decltype(auto) dyn_cast(From &Val) {
657  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value")(static_cast <bool> (detail::isPresent(Val) && "dyn_cast on a non-existent value"
) ? void (0) : __assert_fail ("detail::isPresent(Val) && \"dyn_cast on a non-existent value\""
, "llvm/include/llvm/Support/Casting.h", 657, __extension__ __PRETTY_FUNCTION__
));
658  return CastInfo<To, From>::doCastIfPossible(Val);
659}
660 
661template <typename To, typename From>
662[[nodiscard]] inline decltype(auto) dyn_cast(From *Val) {
663  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value")(static_cast <bool> (detail::isPresent(Val) && "dyn_cast on a non-existent value"
) ? void (0) : __assert_fail ("detail::isPresent(Val) && \"dyn_cast on a non-existent value\""
, "llvm/include/llvm/Support/Casting.h", 663, __extension__ __PRETTY_FUNCTION__
));
664  return CastInfo<To, From *>::doCastIfPossible(Val);
665}
666 
667template <typename To, typename From>
668[[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) {
669  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value")(static_cast <bool> (detail::isPresent(Val) && "dyn_cast on a non-existent value"
) ? void (0) : __assert_fail ("detail::isPresent(Val) && \"dyn_cast on a non-existent value\""
, "llvm/include/llvm/Support/Casting.h", 669, __extension__ __PRETTY_FUNCTION__
));
670  return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible(
671      std::forward<std::unique_ptr<From> &&>(Val));
672}
673 
674/// isa_and_present<X> - Functionally identical to isa, except that a null value
675/// is accepted.
676template <typename... X, class Y>
677[[nodiscard]] inline bool isa_and_present(const Y &Val) {
678  if (!detail::isPresent(Val))
679    return false;
680  return isa<X...>(Val);
681}
682 
683template <typename... X, class Y>
684[[nodiscard]] inline bool isa_and_nonnull(const Y &Val) {
685  return isa_and_present<X...>(Val);
686}
687 
688/// cast_if_present<X> - Functionally identical to cast, except that a null
689/// value is accepted.
690template <class X, class Y>
691[[nodiscard]] inline auto cast_if_present(const Y &Val) {
692  if (!detail::isPresent(Val))
693    return CastInfo<X, const Y>::castFailed();
694  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_if_present<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 694, __extension__ __PRETTY_FUNCTION__
));
695  return cast<X>(detail::unwrapValue(Val));
696}
697 
698template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y &Val) {
699  if (!detail::isPresent(Val))
700    return CastInfo<X, Y>::castFailed();
701  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_if_present<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 701, __extension__ __PRETTY_FUNCTION__
));
702  return cast<X>(detail::unwrapValue(Val));
703}
704 
705template <class X, class Y> [[nodiscard]] inline auto cast_if_present(Y *Val) {
706  if (!detail::isPresent(Val))
707    return CastInfo<X, Y *>::castFailed();
708  assert(isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!")(static_cast <bool> (isa<X>(Val) && "cast_if_present<Ty>() argument of incompatible type!"
) ? void (0) : __assert_fail ("isa<X>(Val) && \"cast_if_present<Ty>() argument of incompatible type!\""
, "llvm/include/llvm/Support/Casting.h", 708, __extension__ __PRETTY_FUNCTION__
));
709  return cast<X>(detail::unwrapValue(Val));
710}
711 
712template <class X, class Y>
713[[nodiscard]] inline auto cast_if_present(std::unique_ptr<Y> &&Val) {
714  if (!detail::isPresent(Val))
715    return UniquePtrCast<X, Y>::castFailed();
716  return UniquePtrCast<X, Y>::doCast(std::move(Val));
717}
718 
719// Provide a forwarding from cast_or_null to cast_if_present for current
720// users. This is deprecated and will be removed in a future patch, use
721// cast_if_present instead.
722template <class X, class Y> auto cast_or_null(const Y &Val) {
723  return cast_if_present<X>(Val);
724}
725 
726template <class X, class Y> auto cast_or_null(Y &Val) {
727  return cast_if_present<X>(Val);
728}
729 
730template <class X, class Y> auto cast_or_null(Y *Val) {
731  return cast_if_present<X>(Val);
732}
733 
734template <class X, class Y> auto cast_or_null(std::unique_ptr<Y> &&Val) {
735  return cast_if_present<X>(std::move(Val));
736}
737 
738/// dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a
739/// null (or none in the case of optionals) value is accepted.
740template <class X, class Y> auto dyn_cast_if_present(const Y &Val) {
741  if (!detail::isPresent(Val))
15
←
Assuming the condition is true→
16
←
Taking true branch→
742    return CastInfo<X, const Y>::castFailed();
17
←
Calling 'ConstStrippingForwardingCast::castFailed'→
22
←
Returning from 'ConstStrippingForwardingCast::castFailed'→
23
←
Returning null pointer, which participates in a condition later→
743  return CastInfo<X, const Y>::doCastIfPossible(detail::unwrapValue(Val));
744}
745 
746template <class X, class Y> auto dyn_cast_if_present(Y &Val) {
747  if (!detail::isPresent(Val))
748    return CastInfo<X, Y>::castFailed();
749  return CastInfo<X, Y>::doCastIfPossible(detail::unwrapValue(Val));
750}
751 
752template <class X, class Y> auto dyn_cast_if_present(Y *Val) {
753  if (!detail::isPresent(Val))
754    return CastInfo<X, Y *>::castFailed();
755  return CastInfo<X, Y *>::doCastIfPossible(detail::unwrapValue(Val));
756}
757 
758// Forwards to dyn_cast_if_present to avoid breaking current users. This is
759// deprecated and will be removed in a future patch, use
760// cast_if_present instead.
761template <class X, class Y> auto dyn_cast_or_null(const Y &Val) {
762  return dyn_cast_if_present<X>(Val);
763}
764 
765template <class X, class Y> auto dyn_cast_or_null(Y &Val) {
766  return dyn_cast_if_present<X>(Val);
767}
768 
769template <class X, class Y> auto dyn_cast_or_null(Y *Val) {
770  return dyn_cast_if_present<X>(Val);
771}
772 
773/// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
774/// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
775/// cast is successful, From refers to nullptr on exit and the casted value
776/// is returned.  If the cast is unsuccessful, the function returns nullptr
777/// and From is unchanged.
778template <class X, class Y>
779[[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
780unique_dyn_cast(std::unique_ptr<Y> &Val) {
781  if (!isa<X>(Val))
782    return nullptr;
783  return cast<X>(std::move(Val));
784}
785 
786template <class X, class Y>
787[[nodiscard]] inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val) {
788  return unique_dyn_cast<X, Y>(Val);
789}
790 
791// unique_dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast,
792// except that a null value is accepted.
793template <class X, class Y>
794[[nodiscard]] inline typename CastInfo<X, std::unique_ptr<Y>>::CastResultType
795unique_dyn_cast_or_null(std::unique_ptr<Y> &Val) {
796  if (!Val)
797    return nullptr;
798  return unique_dyn_cast<X, Y>(Val);
799}
800 
801template <class X, class Y>
802[[nodiscard]] inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val) {
803  return unique_dyn_cast_or_null<X, Y>(Val);
804}
805 
806} // end namespace llvm
807 
808#endif // LLVM_SUPPORT_CASTING_H