/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateVariadic.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateVariadic.cpp
Warning:	line 711, column 11 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateVariadic.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaTemplateVariadic.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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"

22using namespace clang;

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

28namespace {
/// 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);
  }
};
271}

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

287/// Diagnose all of the unexpanded parameter packs in the given
288/// vector.
289bool
290Sema::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 (std::find_if(LSI->LocalPacks.begin(), LSI->LocalPacks.end(),
                     DeclaresThisPack) != LSI->LocalPacks.end())
      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 (std::any_of(
              Func->CompoundScopes.begin(), Func->CompoundScopes.end(),
              [](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")((void)0);
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")((void)0);
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")((void)0);

// 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")((void)0);
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")((void)0);
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")((void)0);
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")((void)0);
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?")__builtin_unreachable();
589}

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

TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, None);
if (!TSResult)
  return true;

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

605TypeSourceInfo *
606Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc,
                       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);
621}

623QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange,
                                SourceLocation EllipsisLoc,
                                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);
642}

644ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
return CheckPackExpansion(Pattern, EllipsisLoc, None);
646}

648ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
                                  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);
667}

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

for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
2
←
Loop condition is true.  Entering loop body→
27
←
Loop condition is true.  Entering loop body→
                                               end = Unexpanded.end();
                                                i != end; ++i) {
1
Assuming 'i' is not equal to 'end'→
  // Compute the depth and index for this parameter pack.
  unsigned Depth = 0, Index = 0;
  IdentifierInfo *Name;
  bool IsVarDeclPack = false;

  if (const TemplateTypeParmType *TTP2.1
'TTP' is null
1
'TTP' is null
1
'TTP' is null
1
'TTP' is null
1
'TTP' is null
1
'TTP' is null

2.1	'TTP' is null
35.1	'TTP' is null

Taking false branch

Taking false branch

690 = i->first.dyn_cast<const TemplateTypeParmType *>()) {

←

Calling 'PointerUnion::dyn_cast'

→

←

Returning from 'PointerUnion::dyn_cast'

→

691 Depth = TTP->getDepth(); 692 Index = TTP->getIndex(); 693 Name = TTP->getIdentifier(); 694 } else { 695 NamedDecl *ND = i->first.get<NamedDecl *>(); 696 if (isa<VarDecl>(ND))

←

Assuming 'ND' is not a 'VarDecl'

Taking false branch

Assuming 'ND' is a 'VarDecl'

→

←

Taking true branch

→

697 IsVarDeclPack = true; 698 else 699 std::tie(Depth, Index) = getDepthAndIndex(ND); 700 701 Name = ND->getIdentifier(); 702 } 703 704 // Determine the size of this argument pack. 705 unsigned NewPackSize; 706 if (IsVarDeclPack

5.1	'IsVarDeclPack' is false
38.1	'IsVarDeclPack' is true

5.1	'IsVarDeclPack' is false
38.1	'IsVarDeclPack' is true

5.1	'IsVarDeclPack' is false
38.1	'IsVarDeclPack' is true

5.1	'IsVarDeclPack' is false
38.1	'IsVarDeclPack' is true

) {

Taking false branch

Taking true branch

707 // Figure out whether we're instantiating to an argument pack or not. 708 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; 709 710 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation 711 = CurrentInstantiationScope->findInstantiationOf(

←

Called C++ object pointer is null

712 i->first.get<NamedDecl *>()); 713 if (Instantiation->is<DeclArgumentPack *>()) { 714 // We could expand this function parameter pack. 715 NewPackSize = Instantiation->get<DeclArgumentPack *>()->size(); 716 } else { 717 // We can't expand this function parameter pack, so we can't expand 718 // the pack expansion. 719 ShouldExpand = false; 720 continue; 721 } 722 } else { 723 // If we don't have a template argument at this depth/index, then we 724 // cannot expand the pack expansion. Make a note of this, but we still 725 // want to check any parameter packs we *do* have arguments for. 726 if (Depth >= TemplateArgs.getNumLevels() ||

←

Assuming the condition is false

→

←

Taking false branch

→

727 !TemplateArgs.hasTemplateArgument(Depth, Index)) {

←

Calling 'MultiLevelTemplateArgumentList::hasTemplateArgument'

→

←

Returning from 'MultiLevelTemplateArgumentList::hasTemplateArgument'

→

728 ShouldExpand = false; 729 continue; 730 } 731 732 // Determine the size of the argument pack. 733 NewPackSize = TemplateArgs(Depth, Index).pack_size(); 734 } 735 736 // C++0x [temp.arg.explicit]p9: 737 // Template argument deduction can extend the sequence of template 738 // arguments corresponding to a template parameter pack, even when the 739 // sequence contains explicitly specified template arguments. 740 if (!IsVarDeclPack

19.1	'IsVarDeclPack' is false

19.1	'IsVarDeclPack' is false

19.1	'IsVarDeclPack' is false

19.1	'IsVarDeclPack' is false

&& CurrentInstantiationScope) {

←

Assuming field 'CurrentInstantiationScope' is null

→

←

Assuming pointer value is null

→

←

Taking false branch

→

741 if (NamedDecl *PartialPack 742 = CurrentInstantiationScope->getPartiallySubstitutedPack()){ 743 unsigned PartialDepth, PartialIndex; 744 std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack); 745 if (PartialDepth == Depth && PartialIndex == Index) { 746 RetainExpansion = true; 747 // We don't actually know the new pack size yet. 748 NumPartialExpansions = NewPackSize; 749 PartiallySubstitutedPackLoc = i->second; 750 continue; 751 } 752 } 753 } 754 755 if (!NumExpansions) {

←

Assuming the condition is false

→

←

Taking false branch

→

756 // The is the first pack we've seen for which we have an argument. 757 // Record it. 758 NumExpansions = NewPackSize; 759 FirstPack.first = Name; 760 FirstPack.second = i->second; 761 HaveFirstPack = true; 762 continue; 763 } 764 765 if (NewPackSize != *NumExpansions) {

←

Assuming the condition is false

→

←

Taking false branch

→

766 // C++0x [temp.variadic]p5: 767 // All of the parameter packs expanded by a pack expansion shall have 768 // the same number of arguments specified. 769 if (HaveFirstPack) 770 Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict) 771 << FirstPack.first << Name << *NumExpansions << NewPackSize 772 << SourceRange(FirstPack.second) << SourceRange(i->second); 773 else 774 Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel) 775 << Name << *NumExpansions << NewPackSize 776 << SourceRange(i->second); 777 return true; 778 } 779 } 780 781 // If we're performing a partial expansion but we also have a full expansion, 782 // expand to the number of common arguments. For example, given: 783 // 784 // template<typename ...T> struct A { 785 // template<typename ...U> void f(pair<T, U>...); 786 // }; 787 // 788 // ... a call to 'A<int, int>().f<int>' should expand the pack once and 789 // retain an expansion. 790 if (NumPartialExpansions) { 791 if (NumExpansions && *NumExpansions < *NumPartialExpansions) { 792 NamedDecl *PartialPack = 793 CurrentInstantiationScope->getPartiallySubstitutedPack(); 794 Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_partial) 795 << PartialPack << *NumPartialExpansions << *NumExpansions 796 << SourceRange(PartiallySubstitutedPackLoc); 797 return true; 798 } 799 800 NumExpansions = NumPartialExpansions; 801 } 802 803 return false; 804} 805 806Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T, 807 const MultiLevelTemplateArgumentList &TemplateArgs) { 808 QualType Pattern = cast<PackExpansionType>(T)->getPattern(); 809 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 810 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern); 811 812 Optional<unsigned> Result; 813 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { 814 // Compute the depth and index for this parameter pack. 815 unsigned Depth; 816 unsigned Index; 817 818 if (const TemplateTypeParmType *TTP 819 = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) { 820 Depth = TTP->getDepth(); 821 Index = TTP->getIndex(); 822 } else { 823 NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>(); 824 if (isa<VarDecl>(ND)) { 825 // Function parameter pack or init-capture pack. 826 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; 827 828 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation 829 = CurrentInstantiationScope->findInstantiationOf( 830 Unexpanded[I].first.get<NamedDecl *>()); 831 if (Instantiation->is<Decl*>()) 832 // The pattern refers to an unexpanded pack. We're not ready to expand 833 // this pack yet. 834 return None; 835 836 unsigned Size = Instantiation->get<DeclArgumentPack *>()->size(); 837 assert((!Result || *Result == Size) && "inconsistent pack sizes")((void)0); 838 Result = Size; 839 continue; 840 } 841 842 std::tie(Depth, Index) = getDepthAndIndex(ND); 843 } 844 if (Depth >= TemplateArgs.getNumLevels() || 845 !TemplateArgs.hasTemplateArgument(Depth, Index)) 846 // The pattern refers to an unknown template argument. We're not ready to 847 // expand this pack yet. 848 return None; 849 850 // Determine the size of the argument pack. 851 unsigned Size = TemplateArgs(Depth, Index).pack_size(); 852 assert((!Result || *Result == Size) && "inconsistent pack sizes")((void)0); 853 Result = Size; 854 } 855 856 return Result; 857} 858 859bool Sema::containsUnexpandedParameterPacks(Declarator &D) { 860 const DeclSpec &DS = D.getDeclSpec(); 861 switch (DS.getTypeSpecType()) { 862 case TST_typename: 863 case TST_typeofType: 864 case TST_underlyingType: 865 case TST_atomic: { 866 QualType T = DS.getRepAsType().get(); 867 if (!T.isNull() && T->containsUnexpandedParameterPack()) 868 return true; 869 break; 870 } 871 872 case TST_typeofExpr: 873 case TST_decltype: 874 case TST_extint: 875 if (DS.getRepAsExpr() && 876 DS.getRepAsExpr()->containsUnexpandedParameterPack()) 877 return true; 878 break; 879 880 case TST_unspecified: 881 case TST_void: 882 case TST_char: 883 case TST_wchar: 884 case TST_char8: 885 case TST_char16: 886 case TST_char32: 887 case TST_int: 888 case TST_int128: 889 case TST_half: 890 case TST_float: 891 case TST_double: 892 case TST_Accum: 893 case TST_Fract: 894 case TST_Float16: 895 case TST_float128: 896 case TST_bool: 897 case TST_decimal32: 898 case TST_decimal64: 899 case TST_decimal128: 900 case TST_enum: 901 case TST_union: 902 case TST_struct: 903 case TST_interface: 904 case TST_class: 905 case TST_auto: 906 case TST_auto_type: 907 case TST_decltype_auto: 908 case TST_BFloat16: 909#define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t: 910#include "clang/Basic/OpenCLImageTypes.def" 911 case TST_unknown_anytype: 912 case TST_error: 913 break; 914 } 915 916 for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) { 917 const DeclaratorChunk &Chunk = D.getTypeObject(I); 918 switch (Chunk.Kind) { 919 case DeclaratorChunk::Pointer: 920 case DeclaratorChunk::Reference: 921 case DeclaratorChunk::Paren: 922 case DeclaratorChunk::Pipe: 923 case DeclaratorChunk::BlockPointer: 924 // These declarator chunks cannot contain any parameter packs. 925 break; 926 927 case DeclaratorChunk::Array: 928 if (Chunk.Arr.NumElts && 929 Chunk.Arr.NumElts->containsUnexpandedParameterPack()) 930 return true; 931 break; 932 case DeclaratorChunk::Function: 933 for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) { 934 ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param); 935 QualType ParamTy = Param->getType(); 936 assert(!ParamTy.isNull() && "Couldn't parse type?")((void)0); 937 if (ParamTy->containsUnexpandedParameterPack()) return true; 938 } 939 940 if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) { 941 for (unsigned i = 0; i != Chunk.Fun.getNumExceptions(); ++i) { 942 if (Chunk.Fun.Exceptions[i] 943 .Ty.get() 944 ->containsUnexpandedParameterPack()) 945 return true; 946 } 947 } else if (isComputedNoexcept(Chunk.Fun.getExceptionSpecType()) && 948 Chunk.Fun.NoexceptExpr->containsUnexpandedParameterPack()) 949 return true; 950 951 if (Chunk.Fun.hasTrailingReturnType()) { 952 QualType T = Chunk.Fun.getTrailingReturnType().get(); 953 if (!T.isNull() && T->containsUnexpandedParameterPack()) 954 return true; 955 } 956 break; 957 958 case DeclaratorChunk::MemberPointer: 959 if (Chunk.Mem.Scope().getScopeRep() && 960 Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack()) 961 return true; 962 break; 963 } 964 } 965 966 if (Expr *TRC = D.getTrailingRequiresClause()) 967 if (TRC->containsUnexpandedParameterPack()) 968 return true; 969 970 return false; 971} 972 973namespace { 974 975// Callback to only accept typo corrections that refer to parameter packs. 976class ParameterPackValidatorCCC final : public CorrectionCandidateCallback { 977 public: 978 bool ValidateCandidate(const TypoCorrection &candidate) override { 979 NamedDecl *ND = candidate.getCorrectionDecl(); 980 return ND && ND->isParameterPack(); 981 } 982 983 std::unique_ptr<CorrectionCandidateCallback> clone() override { 984 return std::make_unique<ParameterPackValidatorCCC>(*this); 985 } 986}; 987 988} 989 990/// Called when an expression computing the size of a parameter pack 991/// is parsed. 992/// 993/// \code 994/// template<typename ...Types> struct count { 995/// static const unsigned value = sizeof...(Types); 996/// }; 997/// \endcode 998/// 999// 1000/// \param OpLoc The location of the "sizeof" keyword. 1001/// \param Name The name of the parameter pack whose size will be determined. 1002/// \param NameLoc The source location of the name of the parameter pack. 1003/// \param RParenLoc The location of the closing parentheses. 1004ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S, 1005 SourceLocation OpLoc, 1006 IdentifierInfo &Name, 1007 SourceLocation NameLoc, 1008 SourceLocation RParenLoc) { 1009 // C++0x [expr.sizeof]p5: 1010 // The identifier in a sizeof... expression shall name a parameter pack. 1011 LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName); 1012 LookupName(R, S); 1013 1014 NamedDecl *ParameterPack = nullptr; 1015 switch (R.getResultKind()) { 1016 case LookupResult::Found: 1017 ParameterPack = R.getFoundDecl(); 1018 break; 1019 1020 case LookupResult::NotFound: 1021 case LookupResult::NotFoundInCurrentInstantiation: { 1022 ParameterPackValidatorCCC CCC{}; 1023 if (TypoCorrection Corrected = 1024 CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr, 1025 CCC, CTK_ErrorRecovery)) { 1026 diagnoseTypo(Corrected, 1027 PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name, 1028 PDiag(diag::note_parameter_pack_here)); 1029 ParameterPack = Corrected.getCorrectionDecl(); 1030 } 1031 break; 1032 } 1033 case LookupResult::FoundOverloaded: 1034 case LookupResult::FoundUnresolvedValue: 1035 break; 1036 1037 case LookupResult::Ambiguous: 1038 DiagnoseAmbiguousLookup(R); 1039 return ExprError(); 1040 } 1041 1042 if (!ParameterPack || !ParameterPack->isParameterPack()) { 1043 Diag(NameLoc, diag::err_sizeof_pack_no_pack_name) 1044 << &Name; 1045 return ExprError(); 1046 } 1047 1048 MarkAnyDeclReferenced(OpLoc, ParameterPack, true); 1049 1050 return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc, 1051 RParenLoc); 1052} 1053 1054TemplateArgumentLoc 1055Sema::getTemplateArgumentPackExpansionPattern( 1056 TemplateArgumentLoc OrigLoc, 1057 SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const { 1058 const TemplateArgument &Argument = OrigLoc.getArgument(); 1059 assert(Argument.isPackExpansion())((void)0); 1060 switch (Argument.getKind()) { 1061 case TemplateArgument::Type: { 1062 // FIXME: We shouldn't ever have to worry about missing 1063 // type-source info! 1064 TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo(); 1065 if (!ExpansionTSInfo) 1066 ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(), 1067 Ellipsis); 1068 PackExpansionTypeLoc Expansion = 1069 ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>(); 1070 Ellipsis = Expansion.getEllipsisLoc(); 1071 1072 TypeLoc Pattern = Expansion.getPatternLoc(); 1073 NumExpansions = Expansion.getTypePtr()->getNumExpansions(); 1074 1075 // We need to copy the TypeLoc because TemplateArgumentLocs store a 1076 // TypeSourceInfo. 1077 // FIXME: Find some way to avoid the copy? 1078 TypeLocBuilder TLB; 1079 TLB.pushFullCopy(Pattern); 1080 TypeSourceInfo *PatternTSInfo = 1081 TLB.getTypeSourceInfo(Context, Pattern.getType()); 1082 return TemplateArgumentLoc(TemplateArgument(Pattern.getType()), 1083 PatternTSInfo); 1084 } 1085 1086 case TemplateArgument::Expression: { 1087 PackExpansionExpr *Expansion 1088 = cast<PackExpansionExpr>(Argument.getAsExpr()); 1089 Expr *Pattern = Expansion->getPattern(); 1090 Ellipsis = Expansion->getEllipsisLoc(); 1091 NumExpansions = Expansion->getNumExpansions(); 1092 return TemplateArgumentLoc(Pattern, Pattern); 1093 } 1094 1095 case TemplateArgument::TemplateExpansion: 1096 Ellipsis = OrigLoc.getTemplateEllipsisLoc(); 1097 NumExpansions = Argument.getNumTemplateExpansions(); 1098 return TemplateArgumentLoc(Context, Argument.getPackExpansionPattern(), 1099 OrigLoc.getTemplateQualifierLoc(), 1100 OrigLoc.getTemplateNameLoc()); 1101 1102 case TemplateArgument::Declaration: 1103 case TemplateArgument::NullPtr: 1104 case TemplateArgument::Template: 1105 case TemplateArgument::Integral: 1106 case TemplateArgument::Pack: 1107 case TemplateArgument::Null: 1108 return TemplateArgumentLoc(); 1109 } 1110 1111 llvm_unreachable("Invalid TemplateArgument Kind!")__builtin_unreachable(); 1112} 1113 1114Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) { 1115 assert(Arg.containsUnexpandedParameterPack())((void)0); 1116 1117 // If this is a substituted pack, grab that pack. If not, we don't know 1118 // the size yet. 1119 // FIXME: We could find a size in more cases by looking for a substituted 1120 // pack anywhere within this argument, but that's not necessary in the common 1121 // case for 'sizeof...(A)' handling. 1122 TemplateArgument Pack; 1123 switch (Arg.getKind()) { 1124 case TemplateArgument::Type: 1125 if (auto *Subst = Arg.getAsType()->getAs<SubstTemplateTypeParmPackType>()) 1126 Pack = Subst->getArgumentPack(); 1127 else 1128 return None; 1129 break; 1130 1131 case TemplateArgument::Expression: 1132 if (auto *Subst = 1133 dyn_cast<SubstNonTypeTemplateParmPackExpr>(Arg.getAsExpr())) 1134 Pack = Subst->getArgumentPack(); 1135 else if (auto *Subst = dyn_cast<FunctionParmPackExpr>(Arg.getAsExpr())) { 1136 for (VarDecl *PD : *Subst) 1137 if (PD->isParameterPack()) 1138 return None; 1139 return Subst->getNumExpansions(); 1140 } else 1141 return None; 1142 break; 1143 1144 case TemplateArgument::Template: 1145 if (SubstTemplateTemplateParmPackStorage *Subst = 1146 Arg.getAsTemplate().getAsSubstTemplateTemplateParmPack()) 1147 Pack = Subst->getArgumentPack(); 1148 else 1149 return None; 1150 break; 1151 1152 case TemplateArgument::Declaration: 1153 case TemplateArgument::NullPtr: 1154 case TemplateArgument::TemplateExpansion: 1155 case TemplateArgument::Integral: 1156 case TemplateArgument::Pack: 1157 case TemplateArgument::Null: 1158 return None; 1159 } 1160 1161 // Check that no argument in the pack is itself a pack expansion. 1162 for (TemplateArgument Elem : Pack.pack_elements()) { 1163 // There's no point recursing in this case; we would have already 1164 // expanded this pack expansion into the enclosing pack if we could. 1165 if (Elem.isPackExpansion()) 1166 return None; 1167 } 1168 return Pack.pack_size(); 1169} 1170 1171static void CheckFoldOperand(Sema &S, Expr *E) { 1172 if (!E) 1173 return; 1174 1175 E = E->IgnoreImpCasts(); 1176 auto *OCE = dyn_cast<CXXOperatorCallExpr>(E); 1177 if ((OCE && OCE->isInfixBinaryOp()) || isa<BinaryOperator>(E) || 1178 isa<AbstractConditionalOperator>(E)) { 1179 S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand) 1180 << E->getSourceRange() 1181 << FixItHint::CreateInsertion(E->getBeginLoc(), "(") 1182 << FixItHint::CreateInsertion(E->getEndLoc(), ")"); 1183 } 1184} 1185 1186ExprResult Sema::ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS, 1187 tok::TokenKind Operator, 1188 SourceLocation EllipsisLoc, Expr *RHS, 1189 SourceLocation RParenLoc) { 1190 // LHS and RHS must be cast-expressions. We allow an arbitrary expression 1191 // in the parser and reduce down to just cast-expressions here. 1192 CheckFoldOperand(*this, LHS); 1193 CheckFoldOperand(*this, RHS); 1194 1195 auto DiscardOperands = [&] { 1196 CorrectDelayedTyposInExpr(LHS); 1197 CorrectDelayedTyposInExpr(RHS); 1198 }; 1199 1200 // [expr.prim.fold]p3: 1201 // In a binary fold, op1 and op2 shall be the same fold-operator, and 1202 // either e1 shall contain an unexpanded parameter pack or e2 shall contain 1203 // an unexpanded parameter pack, but not both. 1204 if (LHS && RHS && 1205 LHS->containsUnexpandedParameterPack() == 1206 RHS->containsUnexpandedParameterPack()) { 1207 DiscardOperands(); 1208 return Diag(EllipsisLoc, 1209 LHS->containsUnexpandedParameterPack() 1210 ? diag::err_fold_expression_packs_both_sides 1211 : diag::err_pack_expansion_without_parameter_packs) 1212 << LHS->getSourceRange() << RHS->getSourceRange(); 1213 } 1214 1215 // [expr.prim.fold]p2: 1216 // In a unary fold, the cast-expression shall contain an unexpanded 1217 // parameter pack. 1218 if (!LHS || !RHS) { 1219 Expr *Pack = LHS ? LHS : RHS; 1220 assert(Pack && "fold expression with neither LHS nor RHS")((void)0); 1221 DiscardOperands(); 1222 if (!Pack->containsUnexpandedParameterPack()) 1223 return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) 1224 << Pack->getSourceRange(); 1225 } 1226 1227 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator); 1228 1229 // Perform first-phase name lookup now. 1230 UnresolvedLookupExpr *ULE = nullptr; 1231 { 1232 UnresolvedSet<16> Functions; 1233 LookupBinOp(S, EllipsisLoc, Opc, Functions); 1234 if (!Functions.empty()) { 1235 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName( 1236 BinaryOperator::getOverloadedOperator(Opc)); 1237 ExprResult Callee = CreateUnresolvedLookupExpr( 1238 /*NamingClass*/ nullptr, NestedNameSpecifierLoc(), 1239 DeclarationNameInfo(OpName, EllipsisLoc), Functions); 1240 if (Callee.isInvalid()) 1241 return ExprError(); 1242 ULE = cast<UnresolvedLookupExpr>(Callee.get()); 1243 } 1244 } 1245 1246 return BuildCXXFoldExpr(ULE, LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc, 1247 None); 1248} 1249 1250ExprResult Sema::BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, 1251 SourceLocation LParenLoc, Expr *LHS, 1252 BinaryOperatorKind Operator, 1253 SourceLocation EllipsisLoc, Expr *RHS, 1254 SourceLocation RParenLoc, 1255 Optional<unsigned> NumExpansions) { 1256 return new (Context) 1257 CXXFoldExpr(Context.DependentTy, Callee, LParenLoc, LHS, Operator, 1258 EllipsisLoc, RHS, RParenLoc, NumExpansions); 1259} 1260 1261ExprResult Sema::BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, 1262 BinaryOperatorKind Operator) { 1263 // [temp.variadic]p9: 1264 // If N is zero for a unary fold-expression, the value of the expression is 1265 // && -> true 1266 // || -> false 1267 // , -> void() 1268 // if the operator is not listed [above], the instantiation is ill-formed. 1269 // 1270 // Note that we need to use something like int() here, not merely 0, to 1271 // prevent the result from being a null pointer constant. 1272 QualType ScalarType; 1273 switch (Operator) { 1274 case BO_LOr: 1275 return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false); 1276 case BO_LAnd: 1277 return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true); 1278 case BO_Comma: 1279 ScalarType = Context.VoidTy; 1280 break; 1281 1282 default: 1283 return Diag(EllipsisLoc, diag::err_fold_expression_empty) 1284 << BinaryOperator::getOpcodeStr(Operator); 1285 } 1286 1287 return new (Context) CXXScalarValueInitExpr( 1288 ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc), 1289 EllipsisLoc); 1290}

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/Sema/Template.h

→

1//===- SemaTemplate.h - C++ Templates ---------------------------*- 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// This file provides types used in the semantic analysis of C++ templates.
9//
10//===----------------------------------------------------------------------===//

12#ifndef LLVM_CLANG_SEMA_TEMPLATE_H
13#define LLVM_CLANG_SEMA_TEMPLATE_H

15#include "clang/AST/DeclTemplate.h"
16#include "clang/AST/DeclVisitor.h"
17#include "clang/AST/TemplateBase.h"
18#include "clang/AST/Type.h"
19#include "clang/Basic/LLVM.h"
20#include "clang/Sema/Sema.h"
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/ADT/DenseMap.h"
23#include "llvm/ADT/PointerUnion.h"
24#include "llvm/ADT/SmallVector.h"
25#include <cassert>
26#include <utility>

28namespace clang {

30class ASTContext;
31class BindingDecl;
32class CXXMethodDecl;
33class Decl;
34class DeclaratorDecl;
35class DeclContext;
36class EnumDecl;
37class FunctionDecl;
38class NamedDecl;
39class ParmVarDecl;
40class TagDecl;
41class TypedefNameDecl;
42class TypeSourceInfo;
43class VarDecl;

45/// The kind of template substitution being performed.
46enum class TemplateSubstitutionKind : char {
/// We are substituting template parameters for template arguments in order
/// to form a template specialization.
Specialization,
/// We are substituting template parameters for (typically) other template
/// parameters in order to rewrite a declaration as a different declaration
/// (for example, when forming a deduction guide from a constructor).
Rewrite,
54};

/// Data structure that captures multiple levels of template argument
/// lists for use in template instantiation.
///
/// Multiple levels of template arguments occur when instantiating the
/// definitions of member templates. For example:
///
/// \code
/// template<typename T>
/// struct X {
///   template<T Value>
///   struct Y {
///     void f();
///   };
/// };
/// \endcode
///
/// When instantiating X<int>::Y<17>::f, the multi-level template argument
/// list will contain a template argument list (int) at depth 0 and a
/// template argument list (17) at depth 1.
class MultiLevelTemplateArgumentList {
  /// The template argument list at a certain template depth
  using ArgList = ArrayRef<TemplateArgument>;

  /// The template argument lists, stored from the innermost template
  /// argument list (first) to the outermost template argument list (last).
  SmallVector<ArgList, 4> TemplateArgumentLists;

  /// The number of outer levels of template arguments that are not
  /// being substituted.
  unsigned NumRetainedOuterLevels = 0;

  /// The kind of substitution described by this argument list.
  TemplateSubstitutionKind Kind = TemplateSubstitutionKind::Specialization;

public:
  /// Construct an empty set of template argument lists.
  MultiLevelTemplateArgumentList() = default;

  /// Construct a single-level template argument list.
  explicit
  MultiLevelTemplateArgumentList(const TemplateArgumentList &TemplateArgs) {
    addOuterTemplateArguments(&TemplateArgs);
  }

  void setKind(TemplateSubstitutionKind K) { Kind = K; }

  /// Determine the kind of template substitution being performed.
  TemplateSubstitutionKind getKind() const { return Kind; }

  /// Determine whether we are rewriting template parameters rather than
  /// substituting for them. If so, we should not leave references to the
  /// original template parameters behind.
  bool isRewrite() const {
    return Kind == TemplateSubstitutionKind::Rewrite;
  }

  /// Determine the number of levels in this template argument
  /// list.
  unsigned getNumLevels() const {
    return TemplateArgumentLists.size() + NumRetainedOuterLevels;
  }

  /// Determine the number of substituted levels in this template
  /// argument list.
  unsigned getNumSubstitutedLevels() const {
    return TemplateArgumentLists.size();
  }

  unsigned getNumRetainedOuterLevels() const {
    return NumRetainedOuterLevels;
  }

  /// Determine how many of the \p OldDepth outermost template parameter
  /// lists would be removed by substituting these arguments.
  unsigned getNewDepth(unsigned OldDepth) const {
    if (OldDepth < NumRetainedOuterLevels)
      return OldDepth;
    if (OldDepth < getNumLevels())
      return NumRetainedOuterLevels;
    return OldDepth - TemplateArgumentLists.size();
  }

  /// Retrieve the template argument at a given depth and index.
  const TemplateArgument &operator()(unsigned Depth, unsigned Index) const {
    assert(NumRetainedOuterLevels <= Depth && Depth < getNumLevels())((void)0);
    assert(Index < TemplateArgumentLists[getNumLevels() - Depth - 1].size())((void)0);
    return TemplateArgumentLists[getNumLevels() - Depth - 1][Index];
  }

  /// Determine whether there is a non-NULL template argument at the
  /// given depth and index.
  ///
  /// There must exist a template argument list at the given depth.
  bool hasTemplateArgument(unsigned Depth, unsigned Index) const {
    assert(Depth < getNumLevels())((void)0);

    if (Depth < NumRetainedOuterLevels)
9
←
Assuming 'Depth' is >= field 'NumRetainedOuterLevels'→
10
←
Taking false branch→
      return false;

    if (Index >= TemplateArgumentLists[getNumLevels() - Depth - 1].size())
11
←
Assuming the condition is false→
12
←
Taking false branch→
      return false;

    return !(*this)(Depth, Index).isNull();
13
←
Calling 'TemplateArgument::isNull'→
16
←
Returning from 'TemplateArgument::isNull'→
17
←
Returning the value 1, which participates in a condition later→
  }

  /// Clear out a specific template argument.
  void setArgument(unsigned Depth, unsigned Index,
                   TemplateArgument Arg) {
    assert(NumRetainedOuterLevels <= Depth && Depth < getNumLevels())((void)0);
    assert(Index < TemplateArgumentLists[getNumLevels() - Depth - 1].size())((void)0);
    const_cast<TemplateArgument&>(
              TemplateArgumentLists[getNumLevels() - Depth - 1][Index])
      = Arg;
  }

  /// Add a new outermost level to the multi-level template argument
  /// list.
  void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs) {
    addOuterTemplateArguments(ArgList(TemplateArgs->data(),
                                      TemplateArgs->size()));
  }

  /// Add a new outmost level to the multi-level template argument
  /// list.
  void addOuterTemplateArguments(ArgList Args) {
    assert(!NumRetainedOuterLevels &&((void)0)
           "substituted args outside retained args?")((void)0);
    TemplateArgumentLists.push_back(Args);
  }

  /// Add an outermost level that we are not substituting. We have no
  /// arguments at this level, and do not remove it from the depth of inner
  /// template parameters that we instantiate.
  void addOuterRetainedLevel() {
    ++NumRetainedOuterLevels;
  }
  void addOuterRetainedLevels(unsigned Num) {
    NumRetainedOuterLevels += Num;
  }

  /// Retrieve the innermost template argument list.
  const ArgList &getInnermost() const {
    return TemplateArgumentLists.front();
  }
};

/// The context in which partial ordering of function templates occurs.
enum TPOC {
  /// Partial ordering of function templates for a function call.
  TPOC_Call,

  /// Partial ordering of function templates for a call to a
  /// conversion function.
  TPOC_Conversion,

  /// Partial ordering of function templates in other contexts, e.g.,
  /// taking the address of a function template or matching a function
  /// template specialization to a function template.
  TPOC_Other
};

// This is lame but unavoidable in a world without forward
// declarations of enums.  The alternatives are to either pollute
// Sema.h (by including this file) or sacrifice type safety (by
// making Sema.h declare things as enums).
class TemplatePartialOrderingContext {
  TPOC Value;

public:
  TemplatePartialOrderingContext(TPOC Value) : Value(Value) {}

  operator TPOC() const { return Value; }
};

/// Captures a template argument whose value has been deduced
/// via c++ template argument deduction.
class DeducedTemplateArgument : public TemplateArgument {
  /// For a non-type template argument, whether the value was
  /// deduced from an array bound.
  bool DeducedFromArrayBound = false;

public:
  DeducedTemplateArgument() = default;

  DeducedTemplateArgument(const TemplateArgument &Arg,
                          bool DeducedFromArrayBound = false)
      : TemplateArgument(Arg), DeducedFromArrayBound(DeducedFromArrayBound) {}

  /// Construct an integral non-type template argument that
  /// has been deduced, possibly from an array bound.
  DeducedTemplateArgument(ASTContext &Ctx,
                          const llvm::APSInt &Value,
                          QualType ValueType,
                          bool DeducedFromArrayBound)
      : TemplateArgument(Ctx, Value, ValueType),
        DeducedFromArrayBound(DeducedFromArrayBound) {}

  /// For a non-type template argument, determine whether the
  /// template argument was deduced from an array bound.
  bool wasDeducedFromArrayBound() const { return DeducedFromArrayBound; }

  /// Specify whether the given non-type template argument
  /// was deduced from an array bound.
  void setDeducedFromArrayBound(bool Deduced) {
    DeducedFromArrayBound = Deduced;
  }
};

/// A stack-allocated class that identifies which local
/// variable declaration instantiations are present in this scope.
///
/// A new instance of this class type will be created whenever we
/// instantiate a new function declaration, which will have its own
/// set of parameter declarations.
class LocalInstantiationScope {
public:
  /// A set of declarations.
  using DeclArgumentPack = SmallVector<VarDecl *, 4>;

private:
  /// Reference to the semantic analysis that is performing
  /// this template instantiation.
  Sema &SemaRef;

  using LocalDeclsMap =
      llvm::SmallDenseMap<const Decl *,
                          llvm::PointerUnion<Decl *, DeclArgumentPack *>, 4>;

  /// A mapping from local declarations that occur
  /// within a template to their instantiations.
  ///
  /// This mapping is used during instantiation to keep track of,
  /// e.g., function parameter and variable declarations. For example,
  /// given:
  ///
  /// \code
  ///   template<typename T> T add(T x, T y) { return x + y; }
  /// \endcode
  ///
  /// when we instantiate add<int>, we will introduce a mapping from
  /// the ParmVarDecl for 'x' that occurs in the template to the
  /// instantiated ParmVarDecl for 'x'.
  ///
  /// For a parameter pack, the local instantiation scope may contain a
  /// set of instantiated parameters. This is stored as a DeclArgumentPack
  /// pointer.
  LocalDeclsMap LocalDecls;

  /// The set of argument packs we've allocated.
  SmallVector<DeclArgumentPack *, 1> ArgumentPacks;

  /// The outer scope, which contains local variable
  /// definitions from some other instantiation (that may not be
  /// relevant to this particular scope).
  LocalInstantiationScope *Outer;

  /// Whether we have already exited this scope.
  bool Exited = false;

  /// Whether to combine this scope with the outer scope, such that
  /// lookup will search our outer scope.
  bool CombineWithOuterScope;

  /// If non-NULL, the template parameter pack that has been
  /// partially substituted per C++0x [temp.arg.explicit]p9.
  NamedDecl *PartiallySubstitutedPack = nullptr;

  /// If \c PartiallySubstitutedPack is non-null, the set of
  /// explicitly-specified template arguments in that pack.
  const TemplateArgument *ArgsInPartiallySubstitutedPack;

  /// If \c PartiallySubstitutedPack, the number of
  /// explicitly-specified template arguments in
  /// ArgsInPartiallySubstitutedPack.
  unsigned NumArgsInPartiallySubstitutedPack;

public:
  LocalInstantiationScope(Sema &SemaRef, bool CombineWithOuterScope = false)
      : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope),
        CombineWithOuterScope(CombineWithOuterScope) {
    SemaRef.CurrentInstantiationScope = this;
  }

  LocalInstantiationScope(const LocalInstantiationScope &) = delete;
  LocalInstantiationScope &
  operator=(const LocalInstantiationScope &) = delete;

  ~LocalInstantiationScope() {
    Exit();
  }

  const Sema &getSema() const { return SemaRef; }

  /// Exit this local instantiation scope early.
  void Exit() {
    if (Exited)
      return;

    for (unsigned I = 0, N = ArgumentPacks.size(); I != N; ++I)
      delete ArgumentPacks[I];

    SemaRef.CurrentInstantiationScope = Outer;
    Exited = true;
  }

  /// Clone this scope, and all outer scopes, down to the given
  /// outermost scope.
  LocalInstantiationScope *cloneScopes(LocalInstantiationScope *Outermost) {
    if (this == Outermost) return this;

    // Save the current scope from SemaRef since the LocalInstantiationScope
    // will overwrite it on construction
    LocalInstantiationScope *oldScope = SemaRef.CurrentInstantiationScope;

    LocalInstantiationScope *newScope =
      new LocalInstantiationScope(SemaRef, CombineWithOuterScope);

    newScope->Outer = nullptr;
    if (Outer)
      newScope->Outer = Outer->cloneScopes(Outermost);

    newScope->PartiallySubstitutedPack = PartiallySubstitutedPack;
    newScope->ArgsInPartiallySubstitutedPack = ArgsInPartiallySubstitutedPack;
    newScope->NumArgsInPartiallySubstitutedPack =
      NumArgsInPartiallySubstitutedPack;

    for (LocalDeclsMap::iterator I = LocalDecls.begin(), E = LocalDecls.end();
         I != E; ++I) {
      const Decl *D = I->first;
      llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored =
        newScope->LocalDecls[D];
      if (I->second.is<Decl *>()) {
        Stored = I->second.get<Decl *>();
      } else {
        DeclArgumentPack *OldPack = I->second.get<DeclArgumentPack *>();
        DeclArgumentPack *NewPack = new DeclArgumentPack(*OldPack);
        Stored = NewPack;
        newScope->ArgumentPacks.push_back(NewPack);
      }
    }
    // Restore the saved scope to SemaRef
    SemaRef.CurrentInstantiationScope = oldScope;
    return newScope;
  }

  /// deletes the given scope, and all otuer scopes, down to the
  /// given outermost scope.
  static void deleteScopes(LocalInstantiationScope *Scope,
                           LocalInstantiationScope *Outermost) {
    while (Scope && Scope != Outermost) {
      LocalInstantiationScope *Out = Scope->Outer;
      delete Scope;
      Scope = Out;
    }
  }

  /// Find the instantiation of the declaration D within the current
  /// instantiation scope.
  ///
  /// \param D The declaration whose instantiation we are searching for.
  ///
  /// \returns A pointer to the declaration or argument pack of declarations
  /// to which the declaration \c D is instantiated, if found. Otherwise,
  /// returns NULL.
  llvm::PointerUnion<Decl *, DeclArgumentPack *> *
  findInstantiationOf(const Decl *D);

  void InstantiatedLocal(const Decl *D, Decl *Inst);
  void InstantiatedLocalPackArg(const Decl *D, VarDecl *Inst);
  void MakeInstantiatedLocalArgPack(const Decl *D);

  /// Note that the given parameter pack has been partially substituted
  /// via explicit specification of template arguments
  /// (C++0x [temp.arg.explicit]p9).
  ///
  /// \param Pack The parameter pack, which will always be a template
  /// parameter pack.
  ///
  /// \param ExplicitArgs The explicitly-specified template arguments provided
  /// for this parameter pack.
  ///
  /// \param NumExplicitArgs The number of explicitly-specified template
  /// arguments provided for this parameter pack.
  void SetPartiallySubstitutedPack(NamedDecl *Pack,
                                   const TemplateArgument *ExplicitArgs,
                                   unsigned NumExplicitArgs);

  /// Reset the partially-substituted pack when it is no longer of
  /// interest.
  void ResetPartiallySubstitutedPack() {
    assert(PartiallySubstitutedPack && "No partially-substituted pack")((void)0);
    PartiallySubstitutedPack = nullptr;
    ArgsInPartiallySubstitutedPack = nullptr;
    NumArgsInPartiallySubstitutedPack = 0;
  }

  /// Retrieve the partially-substitued template parameter pack.
  ///
  /// If there is no partially-substituted parameter pack, returns NULL.
  NamedDecl *
  getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs = nullptr,
                              unsigned *NumExplicitArgs = nullptr) const;

  /// Determine whether D is a pack expansion created in this scope.
  bool isLocalPackExpansion(const Decl *D);
};

class TemplateDeclInstantiator
  : public DeclVisitor<TemplateDeclInstantiator, Decl *>
{
  Sema &SemaRef;
  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex;
  DeclContext *Owner;
  const MultiLevelTemplateArgumentList &TemplateArgs;
  Sema::LateInstantiatedAttrVec* LateAttrs = nullptr;
  LocalInstantiationScope *StartingScope = nullptr;

  /// A list of out-of-line class template partial
  /// specializations that will need to be instantiated after the
  /// enclosing class's instantiation is complete.
  SmallVector<std::pair<ClassTemplateDecl *,
                              ClassTemplatePartialSpecializationDecl *>, 4>
    OutOfLinePartialSpecs;

  /// A list of out-of-line variable template partial
  /// specializations that will need to be instantiated after the
  /// enclosing variable's instantiation is complete.
  /// FIXME: Verify that this is needed.
  SmallVector<
      std::pair<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>, 4>
  OutOfLineVarPartialSpecs;

public:
  TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner,
                           const MultiLevelTemplateArgumentList &TemplateArgs)
      : SemaRef(SemaRef),
        SubstIndex(SemaRef, SemaRef.ArgumentPackSubstitutionIndex),
        Owner(Owner), TemplateArgs(TemplateArgs) {}

495// Define all the decl visitors using DeclNodes.inc
496#define DECL(DERIVED, BASE) \
  Decl *Visit ## DERIVED ## Decl(DERIVED ## Decl *D);
498#define ABSTRACT_DECL(DECL)

500// Decls which never appear inside a class or function.
501#define OBJCCONTAINER(DERIVED, BASE)
502#define FILESCOPEASM(DERIVED, BASE)
503#define IMPORT(DERIVED, BASE)
504#define EXPORT(DERIVED, BASE)
505#define LINKAGESPEC(DERIVED, BASE)
506#define OBJCCOMPATIBLEALIAS(DERIVED, BASE)
507#define OBJCMETHOD(DERIVED, BASE)
508#define OBJCTYPEPARAM(DERIVED, BASE)
509#define OBJCIVAR(DERIVED, BASE)
510#define OBJCPROPERTY(DERIVED, BASE)
511#define OBJCPROPERTYIMPL(DERIVED, BASE)
512#define EMPTY(DERIVED, BASE)
513#define LIFETIMEEXTENDEDTEMPORARY(DERIVED, BASE)

  // Decls which use special-case instantiation code.
516#define BLOCK(DERIVED, BASE)
517#define CAPTURED(DERIVED, BASE)
518#define IMPLICITPARAM(DERIVED, BASE)

520#include "clang/AST/DeclNodes.inc"

  enum class RewriteKind { None, RewriteSpaceshipAsEqualEqual };

  void adjustForRewrite(RewriteKind RK, FunctionDecl *Orig, QualType &T,
                        TypeSourceInfo *&TInfo,
                        DeclarationNameInfo &NameInfo);

  // A few supplemental visitor functions.
  Decl *VisitCXXMethodDecl(CXXMethodDecl *D,
                           TemplateParameterList *TemplateParams,
                           Optional<const ASTTemplateArgumentListInfo *>
                               ClassScopeSpecializationArgs = llvm::None,
                           RewriteKind RK = RewriteKind::None);
  Decl *VisitFunctionDecl(FunctionDecl *D,
                          TemplateParameterList *TemplateParams,
                          RewriteKind RK = RewriteKind::None);
  Decl *VisitDecl(Decl *D);
  Decl *VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate,
                     ArrayRef<BindingDecl *> *Bindings = nullptr);
  Decl *VisitBaseUsingDecls(BaseUsingDecl *D, BaseUsingDecl *Inst,
                            LookupResult *Lookup);

  // Enable late instantiation of attributes.  Late instantiated attributes
  // will be stored in LA.
  void enableLateAttributeInstantiation(Sema::LateInstantiatedAttrVec *LA) {
    LateAttrs = LA;
    StartingScope = SemaRef.CurrentInstantiationScope;
  }

  // Disable late instantiation of attributes.
  void disableLateAttributeInstantiation() {
    LateAttrs = nullptr;
    StartingScope = nullptr;
  }

  LocalInstantiationScope *getStartingScope() const { return StartingScope; }

  using delayed_partial_spec_iterator = SmallVectorImpl<std::pair<
    ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl *>>::iterator;

  using delayed_var_partial_spec_iterator = SmallVectorImpl<std::pair<
      VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>>::iterator;

  /// Return an iterator to the beginning of the set of
  /// "delayed" partial specializations, which must be passed to
  /// InstantiateClassTemplatePartialSpecialization once the class
  /// definition has been completed.
  delayed_partial_spec_iterator delayed_partial_spec_begin() {
    return OutOfLinePartialSpecs.begin();
  }

  delayed_var_partial_spec_iterator delayed_var_partial_spec_begin() {
    return OutOfLineVarPartialSpecs.begin();
  }

  /// Return an iterator to the end of the set of
  /// "delayed" partial specializations, which must be passed to
  /// InstantiateClassTemplatePartialSpecialization once the class
  /// definition has been completed.
  delayed_partial_spec_iterator delayed_partial_spec_end() {
    return OutOfLinePartialSpecs.end();
  }

  delayed_var_partial_spec_iterator delayed_var_partial_spec_end() {
    return OutOfLineVarPartialSpecs.end();
  }

  // Helper functions for instantiating methods.
  TypeSourceInfo *SubstFunctionType(FunctionDecl *D,
                           SmallVectorImpl<ParmVarDecl *> &Params);
  bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl);
  bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl);

  bool SubstDefaultedFunction(FunctionDecl *New, FunctionDecl *Tmpl);

  TemplateParameterList *
    SubstTemplateParams(TemplateParameterList *List);

  bool SubstQualifier(const DeclaratorDecl *OldDecl,
                      DeclaratorDecl *NewDecl);
  bool SubstQualifier(const TagDecl *OldDecl,
                      TagDecl *NewDecl);

  Decl *VisitVarTemplateSpecializationDecl(
      VarTemplateDecl *VarTemplate, VarDecl *FromVar,
      const TemplateArgumentListInfo &TemplateArgsInfo,
      ArrayRef<TemplateArgument> Converted,
      VarTemplateSpecializationDecl *PrevDecl = nullptr);

  Decl *InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias);
  ClassTemplatePartialSpecializationDecl *
  InstantiateClassTemplatePartialSpecialization(
                                            ClassTemplateDecl *ClassTemplate,
                         ClassTemplatePartialSpecializationDecl *PartialSpec);
  VarTemplatePartialSpecializationDecl *
  InstantiateVarTemplatePartialSpecialization(
      VarTemplateDecl *VarTemplate,
      VarTemplatePartialSpecializationDecl *PartialSpec);
  void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern);

private:
  template<typename T>
  Decl *instantiateUnresolvedUsingDecl(T *D,
                                       bool InstantiatingPackElement = false);
};

627} // namespace clang

629#endif // LLVM_CLANG_SEMA_TEMPLATE_H

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/AST/TemplateBase.h

→

1//===- TemplateBase.h - Core classes for C++ templates ----------*- 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 provides definitions which are common for all kinds of
10//  template representation.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_AST_TEMPLATEBASE_H
15#define LLVM_CLANG_AST_TEMPLATEBASE_H

17#include "clang/AST/DependenceFlags.h"
18#include "clang/AST/NestedNameSpecifier.h"
19#include "clang/AST/TemplateName.h"
20#include "clang/AST/Type.h"
21#include "clang/Basic/LLVM.h"
22#include "clang/Basic/SourceLocation.h"
23#include "llvm/ADT/APInt.h"
24#include "llvm/ADT/APSInt.h"
25#include "llvm/ADT/ArrayRef.h"
26#include "llvm/ADT/None.h"
27#include "llvm/ADT/Optional.h"
28#include "llvm/ADT/SmallVector.h"
29#include "llvm/Support/Compiler.h"
30#include "llvm/Support/TrailingObjects.h"
31#include <cassert>
32#include <cstddef>
33#include <cstdint>

35namespace llvm {

37class FoldingSetNodeID;

39// Provide PointerLikeTypeTraits for clang::Expr*, this default one requires a
40// full definition of Expr, but this file only sees a forward del because of
41// the dependency.
42template <> struct PointerLikeTypeTraits<clang::Expr *> {
static inline void *getAsVoidPointer(clang::Expr *P) { return P; }
static inline clang::Expr *getFromVoidPointer(void *P) {
  return static_cast<clang::Expr *>(P);
}
static constexpr int NumLowBitsAvailable = 2;
48};

50} // namespace llvm

52namespace clang {

54class ASTContext;
55class DiagnosticBuilder;
56class Expr;
57struct PrintingPolicy;
58class TypeSourceInfo;
59class ValueDecl;

61/// Represents a template argument.
62class TemplateArgument {
63public:
/// The kind of template argument we're storing.
enum ArgKind {
  /// Represents an empty template argument, e.g., one that has not
  /// been deduced.
  Null = 0,

  /// The template argument is a type.
  Type,

  /// The template argument is a declaration that was provided for a pointer,
  /// reference, or pointer to member non-type template parameter.
  Declaration,

  /// The template argument is a null pointer or null pointer to member that
  /// was provided for a non-type template parameter.
  NullPtr,

  /// The template argument is an integral value stored in an llvm::APSInt
  /// that was provided for an integral non-type template parameter.
  Integral,

  /// The template argument is a template name that was provided for a
  /// template template parameter.
  Template,

  /// The template argument is a pack expansion of a template name that was
  /// provided for a template template parameter.
  TemplateExpansion,

  /// The template argument is an expression, and we've not resolved it to one
  /// of the other forms yet, either because it's dependent or because we're
  /// representing a non-canonical template argument (for instance, in a
  /// TemplateSpecializationType).
  Expression,

  /// The template argument is actually a parameter pack. Arguments are stored
  /// in the Args struct.
  Pack
};

104private:
/// The kind of template argument we're storing.

struct DA {
  unsigned Kind;
  void *QT;
  ValueDecl *D;
};
struct I {
  unsigned Kind;
  // We store a decomposed APSInt with the data allocated by ASTContext if
  // BitWidth > 64. The memory may be shared between multiple
  // TemplateArgument instances.
  unsigned BitWidth : 31;
  unsigned IsUnsigned : 1;
  union {
    /// Used to store the <= 64 bits integer value.
    uint64_t VAL;

    /// Used to store the >64 bits integer value.
    const uint64_t *pVal;
  };
  void *Type;
};
struct A {
  unsigned Kind;
  unsigned NumArgs;
  const TemplateArgument *Args;
};
struct TA {
  unsigned Kind;
  unsigned NumExpansions;
  void *Name;
};
struct TV {
  unsigned Kind;
  uintptr_t V;
};
union {
  struct DA DeclArg;
  struct I Integer;
  struct A Args;
  struct TA TemplateArg;
  struct TV TypeOrValue;
};

150public:
/// Construct an empty, invalid template argument.
constexpr TemplateArgument() : TypeOrValue({Null, 0}) {}

/// Construct a template type argument.
TemplateArgument(QualType T, bool isNullPtr = false) {
  TypeOrValue.Kind = isNullPtr ? NullPtr : Type;
  TypeOrValue.V = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
}

/// Construct a template argument that refers to a
/// declaration, which is either an external declaration or a
/// template declaration.
TemplateArgument(ValueDecl *D, QualType QT) {
  assert(D && "Expected decl")((void)0);
  DeclArg.Kind = Declaration;
  DeclArg.QT = QT.getAsOpaquePtr();
  DeclArg.D = D;
}

/// Construct an integral constant template argument. The memory to
/// store the value is allocated with Ctx.
TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, QualType Type);

/// Construct an integral constant template argument with the same
/// value as Other but a different type.
TemplateArgument(const TemplateArgument &Other, QualType Type) {
  Integer = Other.Integer;
  Integer.Type = Type.getAsOpaquePtr();
}

/// Construct a template argument that is a template.
///
/// This form of template argument is generally used for template template
/// parameters. However, the template name could be a dependent template
/// name that ends up being instantiated to a function template whose address
/// is taken.
///
/// \param Name The template name.
TemplateArgument(TemplateName Name) {
  TemplateArg.Kind = Template;
  TemplateArg.Name = Name.getAsVoidPointer();
  TemplateArg.NumExpansions = 0;
}

/// Construct a template argument that is a template pack expansion.
///
/// This form of template argument is generally used for template template
/// parameters. However, the template name could be a dependent template
/// name that ends up being instantiated to a function template whose address
/// is taken.
///
/// \param Name The template name.
///
/// \param NumExpansions The number of expansions that will be generated by
/// instantiating
TemplateArgument(TemplateName Name, Optional<unsigned> NumExpansions) {
  TemplateArg.Kind = TemplateExpansion;
  TemplateArg.Name = Name.getAsVoidPointer();
  if (NumExpansions)
    TemplateArg.NumExpansions = *NumExpansions + 1;
  else
    TemplateArg.NumExpansions = 0;
}

/// Construct a template argument that is an expression.
///
/// This form of template argument only occurs in template argument
/// lists used for dependent types and for expression; it will not
/// occur in a non-dependent, canonical template argument list.
TemplateArgument(Expr *E) {
  TypeOrValue.Kind = Expression;
  TypeOrValue.V = reinterpret_cast<uintptr_t>(E);
}

/// Construct a template argument that is a template argument pack.
///
/// We assume that storage for the template arguments provided
/// outlives the TemplateArgument itself.
explicit TemplateArgument(ArrayRef<TemplateArgument> Args) {
  this->Args.Kind = Pack;
  this->Args.Args = Args.data();
  this->Args.NumArgs = Args.size();
}

TemplateArgument(TemplateName, bool) = delete;

static TemplateArgument getEmptyPack() { return TemplateArgument(None); }

/// Create a new template argument pack by copying the given set of
/// template arguments.
static TemplateArgument CreatePackCopy(ASTContext &Context,
                                       ArrayRef<TemplateArgument> Args);

/// Return the kind of stored template argument.
ArgKind getKind() const { return (ArgKind)TypeOrValue.Kind; }

/// Determine whether this template argument has no value.
bool isNull() const { return getKind() == Null; }
14
←
Assuming the condition is false→
15
←
Returning zero, which participates in a condition later→

TemplateArgumentDependence getDependence() const;

/// Whether this template argument is dependent on a template
/// parameter such that its result can change from one instantiation to
/// another.
bool isDependent() const;

/// Whether this template argument is dependent on a template
/// parameter.
bool isInstantiationDependent() const;

/// Whether this template argument contains an unexpanded
/// parameter pack.
bool containsUnexpandedParameterPack() const;

/// Determine whether this template argument is a pack expansion.
bool isPackExpansion() const;

/// Retrieve the type for a type template argument.
QualType getAsType() const {
  assert(getKind() == Type && "Unexpected kind")((void)0);
  return QualType::getFromOpaquePtr(reinterpret_cast<void*>(TypeOrValue.V));
}

/// Retrieve the declaration for a declaration non-type
/// template argument.
ValueDecl *getAsDecl() const {
  assert(getKind() == Declaration && "Unexpected kind")((void)0);
  return DeclArg.D;
}

QualType getParamTypeForDecl() const {
  assert(getKind() == Declaration && "Unexpected kind")((void)0);
  return QualType::getFromOpaquePtr(DeclArg.QT);
}

/// Retrieve the type for null non-type template argument.
QualType getNullPtrType() const {
  assert(getKind() == NullPtr && "Unexpected kind")((void)0);
  return QualType::getFromOpaquePtr(reinterpret_cast<void*>(TypeOrValue.V));
}

/// Retrieve the template name for a template name argument.
TemplateName getAsTemplate() const {
  assert(getKind() == Template && "Unexpected kind")((void)0);
  return TemplateName::getFromVoidPointer(TemplateArg.Name);
}

/// Retrieve the template argument as a template name; if the argument
/// is a pack expansion, return the pattern as a template name.
TemplateName getAsTemplateOrTemplatePattern() const {
  assert((getKind() == Template || getKind() == TemplateExpansion) &&((void)0)
         "Unexpected kind")((void)0);

  return TemplateName::getFromVoidPointer(TemplateArg.Name);
}

/// Retrieve the number of expansions that a template template argument
/// expansion will produce, if known.
Optional<unsigned> getNumTemplateExpansions() const;

/// Retrieve the template argument as an integral value.
// FIXME: Provide a way to read the integral data without copying the value.
llvm::APSInt getAsIntegral() const {
  assert(getKind() == Integral && "Unexpected kind")((void)0);

  using namespace llvm;

  if (Integer.BitWidth <= 64)
    return APSInt(APInt(Integer.BitWidth, Integer.VAL), Integer.IsUnsigned);

  unsigned NumWords = APInt::getNumWords(Integer.BitWidth);
  return APSInt(APInt(Integer.BitWidth, makeArrayRef(Integer.pVal, NumWords)),
                Integer.IsUnsigned);
}

/// Retrieve the type of the integral value.
QualType getIntegralType() const {
  assert(getKind() == Integral && "Unexpected kind")((void)0);
  return QualType::getFromOpaquePtr(Integer.Type);
}

void setIntegralType(QualType T) {
  assert(getKind() == Integral && "Unexpected kind")((void)0);
  Integer.Type = T.getAsOpaquePtr();
}

/// If this is a non-type template argument, get its type. Otherwise,
/// returns a null QualType.
QualType getNonTypeTemplateArgumentType() const;

/// Retrieve the template argument as an expression.
Expr *getAsExpr() const {
  assert(getKind() == Expression && "Unexpected kind")((void)0);
  return reinterpret_cast<Expr *>(TypeOrValue.V);
}

/// Iterator that traverses the elements of a template argument pack.
using pack_iterator = const TemplateArgument *;

/// Iterator referencing the first argument of a template argument
/// pack.
pack_iterator pack_begin() const {
  assert(getKind() == Pack)((void)0);
  return Args.Args;
}

/// Iterator referencing one past the last argument of a template
/// argument pack.
pack_iterator pack_end() const {
  assert(getKind() == Pack)((void)0);
  return Args.Args + Args.NumArgs;
}

/// Iterator range referencing all of the elements of a template
/// argument pack.
ArrayRef<TemplateArgument> pack_elements() const {
  return llvm::makeArrayRef(pack_begin(), pack_end());
}

/// The number of template arguments in the given template argument
/// pack.
unsigned pack_size() const {
  assert(getKind() == Pack)((void)0);
  return Args.NumArgs;
}

/// Return the array of arguments in this template argument pack.
ArrayRef<TemplateArgument> getPackAsArray() const {
  assert(getKind() == Pack)((void)0);
  return llvm::makeArrayRef(Args.Args, Args.NumArgs);
}

/// Determines whether two template arguments are superficially the
/// same.
bool structurallyEquals(const TemplateArgument &Other) const;

/// When the template argument is a pack expansion, returns
/// the pattern of the pack expansion.
TemplateArgument getPackExpansionPattern() const;

/// Print this template argument to the given output stream.
void print(const PrintingPolicy &Policy, raw_ostream &Out,
           bool IncludeType) const;

/// Debugging aid that dumps the template argument.
void dump(raw_ostream &Out) const;

/// Debugging aid that dumps the template argument to standard error.
void dump() const;

/// Used to insert TemplateArguments into FoldingSets.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const;
403};

405/// Location information for a TemplateArgument.
406struct TemplateArgumentLocInfo {
407private:
struct TemplateTemplateArgLocInfo {
  // FIXME: We'd like to just use the qualifier in the TemplateName,
  // but template arguments get canonicalized too quickly.
  NestedNameSpecifier *Qualifier;
  void *QualifierLocData;
  SourceLocation TemplateNameLoc;
  SourceLocation EllipsisLoc;
};

llvm::PointerUnion<TemplateTemplateArgLocInfo *, Expr *, TypeSourceInfo *>
    Pointer;

TemplateTemplateArgLocInfo *getTemplate() const {
  return Pointer.get<TemplateTemplateArgLocInfo *>();
}

424public:
TemplateArgumentLocInfo() {}
TemplateArgumentLocInfo(TypeSourceInfo *Declarator) { Pointer = Declarator; }

TemplateArgumentLocInfo(Expr *E) { Pointer = E; }
// Ctx is used for allocation -- this case is unusually large and also rare,
// so we store the payload out-of-line.
TemplateArgumentLocInfo(ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
                        SourceLocation TemplateNameLoc,
                        SourceLocation EllipsisLoc);

TypeSourceInfo *getAsTypeSourceInfo() const {
  return Pointer.get<TypeSourceInfo *>();
}

Expr *getAsExpr() const { return Pointer.get<Expr *>(); }

NestedNameSpecifierLoc getTemplateQualifierLoc() const {
  const auto *Template = getTemplate();
  return NestedNameSpecifierLoc(Template->Qualifier,
                                Template->QualifierLocData);
}

SourceLocation getTemplateNameLoc() const {
  return getTemplate()->TemplateNameLoc;
}

SourceLocation getTemplateEllipsisLoc() const {
  return getTemplate()->EllipsisLoc;
}
454};

456/// Location wrapper for a TemplateArgument.  TemplateArgument is to
457/// TemplateArgumentLoc as Type is to TypeLoc.
458class TemplateArgumentLoc {
TemplateArgument Argument;
TemplateArgumentLocInfo LocInfo;

462public:
TemplateArgumentLoc() {}

TemplateArgumentLoc(const TemplateArgument &Argument,
                    TemplateArgumentLocInfo Opaque)
    : Argument(Argument), LocInfo(Opaque) {}

TemplateArgumentLoc(const TemplateArgument &Argument, TypeSourceInfo *TInfo)
    : Argument(Argument), LocInfo(TInfo) {
  assert(Argument.getKind() == TemplateArgument::Type)((void)0);
}

TemplateArgumentLoc(const TemplateArgument &Argument, Expr *E)
    : Argument(Argument), LocInfo(E) {

  // Permit any kind of template argument that can be represented with an
  // expression.
  assert(Argument.getKind() == TemplateArgument::NullPtr ||((void)0)
         Argument.getKind() == TemplateArgument::Integral ||((void)0)
         Argument.getKind() == TemplateArgument::Declaration ||((void)0)
         Argument.getKind() == TemplateArgument::Expression)((void)0);
}

TemplateArgumentLoc(ASTContext &Ctx, const TemplateArgument &Argument,
                    NestedNameSpecifierLoc QualifierLoc,
                    SourceLocation TemplateNameLoc,
                    SourceLocation EllipsisLoc = SourceLocation())
    : Argument(Argument),
      LocInfo(Ctx, QualifierLoc, TemplateNameLoc, EllipsisLoc) {
  assert(Argument.getKind() == TemplateArgument::Template ||((void)0)
         Argument.getKind() == TemplateArgument::TemplateExpansion)((void)0);
}

/// - Fetches the primary location of the argument.
SourceLocation getLocation() const {
  if (Argument.getKind() == TemplateArgument::Template ||
      Argument.getKind() == TemplateArgument::TemplateExpansion)
    return getTemplateNameLoc();

  return getSourceRange().getBegin();
}

/// - Fetches the full source range of the argument.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__));

const TemplateArgument &getArgument() const {
  return Argument;
}

TemplateArgumentLocInfo getLocInfo() const {
  return LocInfo;
}

TypeSourceInfo *getTypeSourceInfo() const {
  if (Argument.getKind() != TemplateArgument::Type)
    return nullptr;
  return LocInfo.getAsTypeSourceInfo();
}

Expr *getSourceExpression() const {
  assert(Argument.getKind() == TemplateArgument::Expression)((void)0);
  return LocInfo.getAsExpr();
}

Expr *getSourceDeclExpression() const {
  assert(Argument.getKind() == TemplateArgument::Declaration)((void)0);
  return LocInfo.getAsExpr();
}

Expr *getSourceNullPtrExpression() const {
  assert(Argument.getKind() == TemplateArgument::NullPtr)((void)0);
  return LocInfo.getAsExpr();
}

Expr *getSourceIntegralExpression() const {
  assert(Argument.getKind() == TemplateArgument::Integral)((void)0);
  return LocInfo.getAsExpr();
}

NestedNameSpecifierLoc getTemplateQualifierLoc() const {
  if (Argument.getKind() != TemplateArgument::Template &&
      Argument.getKind() != TemplateArgument::TemplateExpansion)
    return NestedNameSpecifierLoc();
  return LocInfo.getTemplateQualifierLoc();
}

SourceLocation getTemplateNameLoc() const {
  if (Argument.getKind() != TemplateArgument::Template &&
      Argument.getKind() != TemplateArgument::TemplateExpansion)
    return SourceLocation();
  return LocInfo.getTemplateNameLoc();
}

SourceLocation getTemplateEllipsisLoc() const {
  if (Argument.getKind() != TemplateArgument::TemplateExpansion)
    return SourceLocation();
  return LocInfo.getTemplateEllipsisLoc();
}
560};

562/// A convenient class for passing around template argument
563/// information.  Designed to be passed by reference.
564class TemplateArgumentListInfo {
SmallVector<TemplateArgumentLoc, 8> Arguments;
SourceLocation LAngleLoc;
SourceLocation RAngleLoc;

569public:
TemplateArgumentListInfo() = default;

TemplateArgumentListInfo(SourceLocation LAngleLoc,
                         SourceLocation RAngleLoc)
    : LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc) {}

// This can leak if used in an AST node, use ASTTemplateArgumentListInfo
// instead.
void *operator new(size_t bytes, ASTContext &C) = delete;

SourceLocation getLAngleLoc() const { return LAngleLoc; }
SourceLocation getRAngleLoc() const { return RAngleLoc; }

void setLAngleLoc(SourceLocation Loc) { LAngleLoc = Loc; }
void setRAngleLoc(SourceLocation Loc) { RAngleLoc = Loc; }

unsigned size() const { return Arguments.size(); }

const TemplateArgumentLoc *getArgumentArray() const {
  return Arguments.data();
}

llvm::ArrayRef<TemplateArgumentLoc> arguments() const {
  return Arguments;
}

const TemplateArgumentLoc &operator[](unsigned I) const {
  return Arguments[I];
}

TemplateArgumentLoc &operator[](unsigned I) {
  return Arguments[I];
}

void addArgument(const TemplateArgumentLoc &Loc) {
  Arguments.push_back(Loc);
}
607};

609/// Represents an explicit template argument list in C++, e.g.,
610/// the "<int>" in "sort<int>".
611/// This is safe to be used inside an AST node, in contrast with
612/// TemplateArgumentListInfo.
613struct ASTTemplateArgumentListInfo final
  : private llvm::TrailingObjects<ASTTemplateArgumentListInfo,
                                  TemplateArgumentLoc> {
616private:
friend class ASTNodeImporter;
friend TrailingObjects;

ASTTemplateArgumentListInfo(const TemplateArgumentListInfo &List);

622public:
/// The source location of the left angle bracket ('<').
SourceLocation LAngleLoc;

/// The source location of the right angle bracket ('>').
SourceLocation RAngleLoc;

/// The number of template arguments in TemplateArgs.
unsigned NumTemplateArgs;

SourceLocation getLAngleLoc() const { return LAngleLoc; }
SourceLocation getRAngleLoc() const { return RAngleLoc; }

/// Retrieve the template arguments
const TemplateArgumentLoc *getTemplateArgs() const {
  return getTrailingObjects<TemplateArgumentLoc>();
}
unsigned getNumTemplateArgs() const { return NumTemplateArgs; }

llvm::ArrayRef<TemplateArgumentLoc> arguments() const {
  return llvm::makeArrayRef(getTemplateArgs(), getNumTemplateArgs());
}

const TemplateArgumentLoc &operator[](unsigned I) const {
  return getTemplateArgs()[I];
}

static const ASTTemplateArgumentListInfo *
Create(const ASTContext &C, const TemplateArgumentListInfo &List);
651};

653/// Represents an explicit template argument list in C++, e.g.,
654/// the "<int>" in "sort<int>".
655///
656/// It is intended to be used as a trailing object on AST nodes, and
657/// as such, doesn't contain the array of TemplateArgumentLoc itself,
658/// but expects the containing object to also provide storage for
659/// that.
660struct alignas(void *) ASTTemplateKWAndArgsInfo {
/// The source location of the left angle bracket ('<').
SourceLocation LAngleLoc;

/// The source location of the right angle bracket ('>').
SourceLocation RAngleLoc;

/// The source location of the template keyword; this is used
/// as part of the representation of qualified identifiers, such as
/// S<T>::template apply<T>.  Will be empty if this expression does
/// not have a template keyword.
SourceLocation TemplateKWLoc;

/// The number of template arguments in TemplateArgs.
unsigned NumTemplateArgs;

void initializeFrom(SourceLocation TemplateKWLoc,
                    const TemplateArgumentListInfo &List,
                    TemplateArgumentLoc *OutArgArray);
// FIXME: The parameter Deps is the result populated by this method, the
// caller doesn't need it since it is populated by computeDependence. remove
// it.
void initializeFrom(SourceLocation TemplateKWLoc,
                    const TemplateArgumentListInfo &List,
                    TemplateArgumentLoc *OutArgArray,
                    TemplateArgumentDependence &Deps);
void initializeFrom(SourceLocation TemplateKWLoc);

void copyInto(const TemplateArgumentLoc *ArgArray,
              TemplateArgumentListInfo &List) const;
690};

692const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                    const TemplateArgument &Arg);

695inline TemplateSpecializationType::iterator
  TemplateSpecializationType::end() const {
return getArgs() + getNumArgs();
698}

700inline DependentTemplateSpecializationType::iterator
  DependentTemplateSpecializationType::end() const {
return getArgs() + getNumArgs();
703}

705inline const TemplateArgument &
  TemplateSpecializationType::getArg(unsigned Idx) const {
assert(Idx < getNumArgs() && "Template argument out of range")((void)0);
return getArgs()[Idx];
709}

711inline const TemplateArgument &
  DependentTemplateSpecializationType::getArg(unsigned Idx) const {
assert(Idx < getNumArgs() && "Template argument out of range")((void)0);
return getArgs()[Idx];
715}

717inline const TemplateArgument &AutoType::getArg(unsigned Idx) const {
assert(Idx < getNumArgs() && "Template argument out of range")((void)0);
return getArgs()[Idx];
720}

722} // namespace clang

724#endif // LLVM_CLANG_AST_TEMPLATEBASE_H

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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// This file defines the PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16 
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23 
24namespace llvm {
25 
26template <typename T> struct PointerUnionTypeSelectorReturn {
27  using Return = T;
28};
29 
30/// Get a type based on whether two types are the same or not.
31///
32/// For:
33///
34/// \code
35///   using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
36/// \endcode
37///
38/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
39template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
40struct PointerUnionTypeSelector {
41  using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
42};
43 
44template <typename T, typename RET_EQ, typename RET_NE>
45struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
46  using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
47};
48 
49template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
50struct PointerUnionTypeSelectorReturn<
51    PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
52  using Return =
53      typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
54};
55 
56namespace pointer_union_detail {
57  /// Determine the number of bits required to store integers with values < n.
58  /// This is ceil(log2(n)).
59  constexpr int bitsRequired(unsigned n) {
60    return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
61  }
62 
63  template <typename... Ts> constexpr int lowBitsAvailable() {
64    return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
65  }
66 
67  /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
68  /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
69  /// list.
70  template <typename T, typename ...Us> struct TypeIndex;
71  template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
72    static constexpr int Index = 0;
73  };
74  template <typename T, typename U, typename... Us>
75  struct TypeIndex<T, U, Us...> {
76    static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
77  };
78  template <typename T> struct TypeIndex<T> {
79    static constexpr int Index = 0;
80  };
81 
82  /// Find the first type in a list of types.
83  template <typename T, typename...> struct GetFirstType {
84    using type = T;
85  };
86 
87  /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
88  /// for the template arguments.
89  template <typename ...PTs> class PointerUnionUIntTraits {
90  public:
91    static inline void *getAsVoidPointer(void *P) { return P; }
92    static inline void *getFromVoidPointer(void *P) { return P; }
93    static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
94  };
95 
96  template <typename Derived, typename ValTy, int I, typename ...Types>
97  class PointerUnionMembers;
98 
99  template <typename Derived, typename ValTy, int I>
100  class PointerUnionMembers<Derived, ValTy, I> {
101  protected:
102    ValTy Val;
103    PointerUnionMembers() = default;
104    PointerUnionMembers(ValTy Val) : Val(Val) {}
105 
106    friend struct PointerLikeTypeTraits<Derived>;
107  };
108 
109  template <typename Derived, typename ValTy, int I, typename Type,
110            typename ...Types>
111  class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
112      : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
113    using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
114  public:
115    using Base::Base;
116    PointerUnionMembers() = default;
117    PointerUnionMembers(Type V)
118        : Base(ValTy(const_cast<void *>(
119                         PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
120                     I)) {}
121 
122    using Base::operator=;
123    Derived &operator=(Type V) {
124      this->Val = ValTy(
125          const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
126          I);
127      return static_cast<Derived &>(*this);
128    };
129  };
130}
131 
132/// A discriminated union of two or more pointer types, with the discriminator
133/// in the low bit of the pointer.
134///
135/// This implementation is extremely efficient in space due to leveraging the
136/// low bits of the pointer, while exposing a natural and type-safe API.
137///
138/// Common use patterns would be something like this:
139///    PointerUnion<int*, float*> P;
140///    P = (int*)0;
141///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
142///    X = P.get<int*>();     // ok.
143///    Y = P.get<float*>();   // runtime assertion failure.
144///    Z = P.get<double*>();  // compile time failure.
145///    P = (float*)0;
146///    Y = P.get<float*>();   // ok.
147///    X = P.get<int*>();     // runtime assertion failure.
148template <typename... PTs>
149class PointerUnion
150    : public pointer_union_detail::PointerUnionMembers<
151          PointerUnion<PTs...>,
152          PointerIntPair<
153              void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
154              pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
155          0, PTs...> {
156  // The first type is special because we want to directly cast a pointer to a
157  // default-initialized union to a pointer to the first type. But we don't
158  // want PointerUnion to be a 'template <typename First, typename ...Rest>'
159  // because it's much more convenient to have a name for the whole pack. So
160  // split off the first type here.
161  using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
162  using Base = typename PointerUnion::PointerUnionMembers;
163 
164public:
165  PointerUnion() = default;
166 
167  PointerUnion(std::nullptr_t) : PointerUnion() {}
168  using Base::Base;
169 
170  /// Test if the pointer held in the union is null, regardless of
171  /// which type it is.
172  bool isNull() const { return !this->Val.getPointer(); }
173 
174  explicit operator bool() const { return !isNull(); }
175 
176  /// Test if the Union currently holds the type matching T.
177  template <typename T> bool is() const {
178    constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
179    static_assert(Index < sizeof...(PTs),
180                  "PointerUnion::is<T> given type not in the union");
181    return this->Val.getInt() == Index;
30
←
Assuming the condition is false→
31
←
Returning zero, which participates in a condition later→
182  }
183 
184  /// Returns the value of the specified pointer type.
185  ///
186  /// If the specified pointer type is incorrect, assert.
187  template <typename T> T get() const {
188    assert(is<T>() && "Invalid accessor called")((void)0);
189    return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
190  }
191 
192  /// Returns the current pointer if it is of the specified pointer type,
193  /// otherwise returns null.
194  template <typename T> T dyn_cast() const {
195    if (is<T>())
29
←
Calling 'PointerUnion::is'→
32
←
Returning from 'PointerUnion::is'→
33
←
Taking false branch→
196      return get<T>();
197    return T();
34
←
Returning null pointer, which participates in a condition later→
198  }
199 
200  /// If the union is set to the first pointer type get an address pointing to
201  /// it.
202  First const *getAddrOfPtr1() const {
203    return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
204  }
205 
206  /// If the union is set to the first pointer type get an address pointing to
207  /// it.
208  First *getAddrOfPtr1() {
209    assert(is<First>() && "Val is not the first pointer")((void)0);
210    assert(((void)0)
211        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((void)0)
212            this->Val.getPointer() &&((void)0)
213        "Can't get the address because PointerLikeTypeTraits changes the ptr")((void)0);
214    return const_cast<First *>(
215        reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
216  }
217 
218  /// Assignment from nullptr which just clears the union.
219  const PointerUnion &operator=(std::nullptr_t) {
220    this->Val.initWithPointer(nullptr);
221    return *this;
222  }
223 
224  /// Assignment from elements of the union.
225  using Base::operator=;
226 
227  void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
228  static inline PointerUnion getFromOpaqueValue(void *VP) {
229    PointerUnion V;
230    V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
231    return V;
232  }
233};
234 
235template <typename ...PTs>
236bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
237  return lhs.getOpaqueValue() == rhs.getOpaqueValue();
238}
239 
240template <typename ...PTs>
241bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
242  return lhs.getOpaqueValue() != rhs.getOpaqueValue();
243}
244 
245template <typename ...PTs>
246bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
247  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
248}
249 
250// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
251// # low bits available = min(PT1bits,PT2bits)-1.
252template <typename ...PTs>
253struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
254  static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
255    return P.getOpaqueValue();
256  }
257 
258  static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
259    return PointerUnion<PTs...>::getFromOpaqueValue(P);
260  }
261 
262  // The number of bits available are the min of the pointer types minus the
263  // bits needed for the discriminator.
264  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
265      PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
266};
267 
268// Teach DenseMap how to use PointerUnions as keys.
269template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
270  using Union = PointerUnion<PTs...>;
271  using FirstInfo =
272      DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
273 
274  static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
275 
276  static inline Union getTombstoneKey() {
277    return Union(FirstInfo::getTombstoneKey());
278  }
279 
280  static unsigned getHashValue(const Union &UnionVal) {
281    intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
282    return DenseMapInfo<intptr_t>::getHashValue(key);
283  }
284 
285  static bool isEqual(const Union &LHS, const Union &RHS) {
286    return LHS == RHS;
287  }
288};
289 
290} // end namespace llvm
291 
292#endif // LLVM_ADT_POINTERUNION_H