/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp

Bug Summary

File:	tools/clang/lib/Sema/SemaTemplateVariadic.cpp
Warning:	line 204, column 25 Potential leak of memory pointed to by field 'DiagStorage'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateVariadic.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp

→

1//===------- SemaTemplateVariadic.cpp - C++ Variadic Templates ------------===/
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===/
8//
9//  This file implements semantic analysis for C++0x variadic templates.
10//===----------------------------------------------------------------------===/

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

23using namespace clang;

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

29/// \brief Retrieve the depth and index of a parameter pack.
30static std::pair<unsigned, unsigned> 
31getDepthAndIndex(NamedDecl *ND) {
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
  return std::make_pair(TTP->getDepth(), TTP->getIndex());

if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
  return std::make_pair(NTTP->getDepth(), NTTP->getIndex());

TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
return std::make_pair(TTP->getDepth(), TTP->getIndex());
40}

42namespace {
/// \brief 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 *PVD = dyn_cast<ParmVarDecl>(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>(PVD->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.
  //------------------------------------------------------------------------

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

  /// \brief 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;
  }

  /// \brief 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;
  }
  
  /// \brief 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);
  }

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

  /// \brief 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;
  }

  /// \brief 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;
  }

  /// \brief 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;
  }

  /// \brief 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->isParameterPack())
      return true;

    return inherited::TraverseDecl(D);
  }

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

    return inherited::TraverseAttr(A);
  }

  /// \brief 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; }

  ///@}

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

    return inherited::TraverseUnresolvedUsingValueDecl(D);
  }

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

    return inherited::TraverseUnresolvedUsingTypenameDecl(D);
  }

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

    return inherited::TraverseTemplateArgument(Arg);
  }

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

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

    return inherited::TraverseCXXBaseSpecifier(Base);
  }

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

    return inherited::TraverseConstructorInitializer(Init);
  }

  /// \brief 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);
  }
};
285}

287/// \brief Determine whether it's possible for an unexpanded parameter pack to
288/// be valid in this location. This only happens when we're in a declaration
289/// that is nested within an expression that could be expanded, such as a
290/// lambda-expression within a function call.
291///
292/// This is conservatively correct, but may claim that some unexpanded packs are
293/// permitted when they are not.
294bool Sema::isUnexpandedParameterPackPermitted() {
for (auto *SI : FunctionScopes)
  if (isa<sema::LambdaScopeInfo>(SI))
    return true;
return false;
299}

301/// \brief Diagnose all of the unexpanded parameter packs in the given
302/// vector.
303bool
304Sema::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
// a parameter of 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;
for (unsigned N = FunctionScopes.size(); N; --N) {
  sema::FunctionScopeInfo *Func = FunctionScopes[N-1];
  // 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, and for pack expansions that expand both the stmt
  // expr and the enclosing lambda.
  if (std::any_of(
          Func->CompoundScopes.begin(), Func->CompoundScopes.end(),
          [](sema::CompoundScopeInfo &CSI) { return CSI.IsStmtExpr; }))
    break;

  if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Func)) {
    if (N == FunctionScopes.size()) {
      for (auto &Param : Unexpanded) {
        auto *PD = dyn_cast_or_null<ParmVarDecl>(
            Param.first.dyn_cast<NamedDecl *>());
        if (PD && PD->getDeclContext() == LSI->CallOperator)
          LambdaParamPackReferences.push_back(Param);
      }
    }

    // If we have references to a parameter pack of the innermost enclosing
    // lambda, only diagnose those ones. We don't know whether any other
    // unexpanded parameters referenced herein are actually unexpanded;
    // they might be expanded at an outer level.
    if (!LambdaParamPackReferences.empty()) {
      Unexpanded = LambdaParamPackReferences;
      break;
    }

    LSI->ContainsUnexpandedParameterPack = true;
    return false;
  }
}

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

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

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

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

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

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

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

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

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseNestedNameSpecifier(SS.getScopeRep());
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 423, __extension__ __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(SS.getRange().getBegin(),
                                        UPPC, Unexpanded);
426}

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

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

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

  break;
}

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseType(NameInfo.getName().getCXXNameType());
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 460, __extension__ __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
462}

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

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

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseTemplateName(Template);
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 474, __extension__ __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
476}

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

SmallVector<UnexpandedParameterPack, 2> Unexpanded;
CollectUnexpandedParameterPacksVisitor(Unexpanded)
  .TraverseTemplateArgumentLoc(Arg);
assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs"
) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 487, __extension__ __PRETTY_FUNCTION__));
return DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
489}

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

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

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

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

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

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


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

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

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

case ParsedTemplateArgument::NonType: {
  ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
  if (Result.isInvalid())
    return ParsedTemplateArgument();
  
  return ParsedTemplateArgument(Arg.getKind(), Result.get(), 
                                Arg.getLocation());
}
  
case ParsedTemplateArgument::Template:
  if (!Arg.getAsTemplate().get().containsUnexpandedParameterPack()) {
    SourceRange R(Arg.getLocation());
    if (Arg.getScopeSpec().isValid())
      R.setBegin(Arg.getScopeSpec().getBeginLoc());
    Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
      << R;
    return ParsedTemplateArgument();
  }
    
  return Arg.getTemplatePackExpansion(EllipsisLoc);
}
llvm_unreachable("Unhandled template argument kind?")::llvm::llvm_unreachable_internal("Unhandled template argument kind?"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 565);
566}

568TypeResult 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);
580}

582TypeSourceInfo *
583Sema::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);
598}

600QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange,
                                SourceLocation EllipsisLoc,
                                Optional<unsigned> NumExpansions) {
// 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)
    << PatternRange;
  return QualType();
}

return Context.getPackExpansionType(Pattern, NumExpansions);
614}

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

620ExprResult 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();
  return ExprError();
}

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

640bool 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;

for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
                                               end = Unexpanded.end();
                                                i != end; ++i) {
  // Compute the depth and index for this parameter pack.
  unsigned Depth = 0, Index = 0;
  IdentifierInfo *Name;
  bool IsFunctionParameterPack = false;
  
  if (const TemplateTypeParmType *TTP
      = i->first.dyn_cast<const TemplateTypeParmType *>()) {
    Depth = TTP->getDepth();
    Index = TTP->getIndex();
    Name = TTP->getIdentifier();
  } else {
    NamedDecl *ND = i->first.get<NamedDecl *>();
    if (isa<ParmVarDecl>(ND))
      IsFunctionParameterPack = true;
    else
      std::tie(Depth, Index) = getDepthAndIndex(ND);

    Name = ND->getIdentifier();
  }
  
  // Determine the size of this argument pack.
  unsigned NewPackSize;    
  if (IsFunctionParameterPack) {
    // Figure out whether we're instantiating to an argument pack or not.
    typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
    
    llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
      = CurrentInstantiationScope->findInstantiationOf(
                                      i->first.get<NamedDecl *>());
    if (Instantiation->is<DeclArgumentPack *>()) {
      // We could expand this function parameter pack.
      NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
    } else {
      // We can't expand this function parameter pack, so we can't expand
      // the pack expansion.
      ShouldExpand = false;
      continue;
    }
  } else {
    // If we don't have a template argument at this depth/index, then we 
    // cannot expand the pack expansion. Make a note of this, but we still 
    // want to check any parameter packs we *do* have arguments for.
    if (Depth >= TemplateArgs.getNumLevels() ||
        !TemplateArgs.hasTemplateArgument(Depth, Index)) {
      ShouldExpand = false;
      continue;
    }
    
    // Determine the size of the argument pack.
    NewPackSize = TemplateArgs(Depth, Index).pack_size();
  }
  
  // C++0x [temp.arg.explicit]p9:
  //   Template argument deduction can extend the sequence of template 
  //   arguments corresponding to a template parameter pack, even when the
  //   sequence contains explicitly specified template arguments.
  if (!IsFunctionParameterPack && CurrentInstantiationScope) {
    if (NamedDecl *PartialPack 
                  = CurrentInstantiationScope->getPartiallySubstitutedPack()){
      unsigned PartialDepth, PartialIndex;
      std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
      if (PartialDepth == Depth && PartialIndex == Index)
        RetainExpansion = true;
    }
  }
  
  if (!NumExpansions) {
    // The is the first pack we've seen for which we have an argument. 
    // Record it.
    NumExpansions = NewPackSize;
    FirstPack.first = Name;
    FirstPack.second = i->second;
    HaveFirstPack = true;
    continue;
  }
  
  if (NewPackSize != *NumExpansions) {
    // C++0x [temp.variadic]p5:
    //   All of the parameter packs expanded by a pack expansion shall have 
    //   the same number of arguments specified.
    if (HaveFirstPack)
      Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
        << FirstPack.first << Name << *NumExpansions << NewPackSize
        << SourceRange(FirstPack.second) << SourceRange(i->second);
    else
      Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
        << Name << *NumExpansions << NewPackSize
        << SourceRange(i->second);
    return true;
  }
}

return false;
746}

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

Optional<unsigned> Result;
for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
  // Compute the depth and index for this parameter pack.
  unsigned Depth;
  unsigned Index;
  
  if (const TemplateTypeParmType *TTP
        = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
    Depth = TTP->getDepth();
    Index = TTP->getIndex();
  } else {      
    NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
    if (isa<ParmVarDecl>(ND)) {
      // Function parameter pack.
      typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
      
      llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
        = CurrentInstantiationScope->findInstantiationOf(
                                      Unexpanded[I].first.get<NamedDecl *>());
      if (Instantiation->is<Decl*>())
        // The pattern refers to an unexpanded pack. We're not ready to expand
        // this pack yet.
        return None;

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

    std::tie(Depth, Index) = getDepthAndIndex(ND);
  }
  if (Depth >= TemplateArgs.getNumLevels() ||
      !TemplateArgs.hasTemplateArgument(Depth, Index))
    // The pattern refers to an unknown template argument. We're not ready to
    // expand this pack yet.
    return None;
  
  // Determine the size of the argument pack.
  unsigned Size = TemplateArgs(Depth, Index).pack_size();
  assert((!Result || *Result == Size) && "inconsistent pack sizes")(static_cast <bool> ((!Result || *Result == Size) &&
 "inconsistent pack sizes") ? void (0) : __assert_fail ("(!Result || *Result == Size) && \"inconsistent pack sizes\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 794, __extension__ __PRETTY_FUNCTION__));
  Result = Size;
}

return Result;
799}

801bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
const DeclSpec &DS = D.getDeclSpec();
switch (DS.getTypeSpecType()) {
case TST_typename:
case TST_typeofType:
case TST_underlyingType:
case TST_atomic: {
  QualType T = DS.getRepAsType().get();
  if (!T.isNull() && T->containsUnexpandedParameterPack())
    return true;
  break;
}
    
case TST_typeofExpr:
case TST_decltype:
  if (DS.getRepAsExpr() && 
      DS.getRepAsExpr()->containsUnexpandedParameterPack())
    return true;
  break;
    
case TST_unspecified:
case TST_void:
case TST_char:
case TST_wchar:
case TST_char16:
case TST_char32:
case TST_int:
case TST_int128:
case TST_half:
case TST_float:
case TST_double:
case TST_Float16:
case TST_float128:
case TST_bool:
case TST_decimal32:
case TST_decimal64:
case TST_decimal128:
case TST_enum:
case TST_union:
case TST_struct:
case TST_interface:
case TST_class:
case TST_auto:
case TST_auto_type:
case TST_decltype_auto:
846#define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
847#include "clang/Basic/OpenCLImageTypes.def"
case TST_unknown_anytype:
case TST_error:
  break;
}

for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
  const DeclaratorChunk &Chunk = D.getTypeObject(I);
  switch (Chunk.Kind) {
  case DeclaratorChunk::Pointer:
  case DeclaratorChunk::Reference:
  case DeclaratorChunk::Paren:
  case DeclaratorChunk::Pipe:
  case DeclaratorChunk::BlockPointer:
    // These declarator chunks cannot contain any parameter packs.
    break;
      
  case DeclaratorChunk::Array:
    if (Chunk.Arr.NumElts &&
        Chunk.Arr.NumElts->containsUnexpandedParameterPack())
      return true;
    break;
  case DeclaratorChunk::Function:
    for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
      ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
      QualType ParamTy = Param->getType();
      assert(!ParamTy.isNull() && "Couldn't parse type?")(static_cast <bool> (!ParamTy.isNull() && "Couldn't parse type?"
) ? void (0) : __assert_fail ("!ParamTy.isNull() && \"Couldn't parse type?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 873, __extension__ __PRETTY_FUNCTION__));
      if (ParamTy->containsUnexpandedParameterPack()) return true;
    }

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

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

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

return false;
904}

906namespace {

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

917}

919/// \brief Called when an expression computing the size of a parameter pack
920/// is parsed.
921///
922/// \code
923/// template<typename ...Types> struct count {
924///   static const unsigned value = sizeof...(Types);
925/// };
926/// \endcode
927///
928//
929/// \param OpLoc The location of the "sizeof" keyword.
930/// \param Name The name of the parameter pack whose size will be determined.
931/// \param NameLoc The source location of the name of the parameter pack.
932/// \param RParenLoc The location of the closing parentheses.
933ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
                                            SourceLocation OpLoc,
                                            IdentifierInfo &Name,
                                            SourceLocation NameLoc,
                                            SourceLocation RParenLoc) {
// C++0x [expr.sizeof]p5:
//   The identifier in a sizeof... expression shall name a parameter pack.
LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
LookupName(R, S);

NamedDecl *ParameterPack = nullptr;
switch (R.getResultKind()) {
1
Control jumps to 'case NotFoundInCurrentInstantiation:'  at line 950→
case LookupResult::Found:
  ParameterPack = R.getFoundDecl();
  break;
  
case LookupResult::NotFound:
case LookupResult::NotFoundInCurrentInstantiation:
  if (TypoCorrection Corrected =
2
←
Assuming the condition is true→
3
←
Taking true branch→
          CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
                      llvm::make_unique<ParameterPackValidatorCCC>(),
                      CTK_ErrorRecovery)) {
    diagnoseTypo(Corrected,
                 PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
4
←
Calling 'operator<<'→
17
←
Returned allocated memory→
                 PDiag(diag::note_parameter_pack_here));
18
←
Calling 'Sema::PDiag'→
    ParameterPack = Corrected.getCorrectionDecl();
  }

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

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

MarkAnyDeclReferenced(OpLoc, ParameterPack, true);

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

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

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

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

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

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

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

llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 1039);
1040}

1042Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
assert(Arg.containsUnexpandedParameterPack())(static_cast <bool> (Arg.containsUnexpandedParameterPack
()) ? void (0) : __assert_fail ("Arg.containsUnexpandedParameterPack()"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/Sema/SemaTemplateVariadic.cpp"
, 1043, __extension__ __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

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

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

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

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

BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc);
1157}

1159ExprResult Sema::BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
                                BinaryOperatorKind Operator,
                                SourceLocation EllipsisLoc, Expr *RHS,
                                SourceLocation RParenLoc) {
return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS,
                                 Operator, EllipsisLoc, RHS, RParenLoc);
1165}

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

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

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

←

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h

→

1//===- PartialDiagnostic.h - Diagnostic "closures" --------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10/// \file
11/// \brief Implements a partial diagnostic that can be emitted anwyhere
12/// in a DiagnosticBuilder stream.
13//
14//===----------------------------------------------------------------------===//

16#ifndef LLVM_CLANG_BASIC_PARTIALDIAGNOSTIC_H
17#define LLVM_CLANG_BASIC_PARTIALDIAGNOSTIC_H

19#include "clang/Basic/Diagnostic.h"
20#include "clang/Basic/LLVM.h"
21#include "clang/Basic/SourceLocation.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/StringRef.h"
24#include <cassert>
25#include <cstdint>
26#include <string>
27#include <type_traits>
28#include <utility>

30namespace clang {

32class DeclContext;
33class IdentifierInfo;

35class PartialDiagnostic {
36public:
enum {
    // The MaxArguments and MaxFixItHints member enum values from
    // DiagnosticsEngine are private but DiagnosticsEngine declares
    // PartialDiagnostic a friend.  These enum values are redeclared
    // here so that the nested Storage class below can access them.
    MaxArguments = DiagnosticsEngine::MaxArguments
};

struct Storage {
  enum {
      /// \brief The maximum number of arguments we can hold. We
      /// currently only support up to 10 arguments (%0-%9).
      ///
      /// A single diagnostic with more than that almost certainly has to
      /// be simplified anyway.
      MaxArguments = PartialDiagnostic::MaxArguments
  };

  /// \brief The number of entries in Arguments.
  unsigned char NumDiagArgs = 0;

  /// \brief Specifies for each argument whether it is in DiagArgumentsStr
  /// or in DiagArguments.
  unsigned char DiagArgumentsKind[MaxArguments];

  /// \brief The values for the various substitution positions.
  ///
  /// This is used when the argument is not an std::string. The specific value
  /// is mangled into an intptr_t and the interpretation depends on exactly
  /// what sort of argument kind it is.
  intptr_t DiagArgumentsVal[MaxArguments];

  /// \brief The values for the various substitution positions that have
  /// string arguments.
  std::string DiagArgumentsStr[MaxArguments];

  /// \brief The list of ranges added to this diagnostic.
  SmallVector<CharSourceRange, 8> DiagRanges;

  /// \brief If valid, provides a hint with some code to insert, remove, or
  /// modify at a particular position.
  SmallVector<FixItHint, 6>  FixItHints;

  Storage() = default;
};

/// \brief An allocator for Storage objects, which uses a small cache to
/// objects, used to reduce malloc()/free() traffic for partial diagnostics.
class StorageAllocator {
  static const unsigned NumCached = 16;
  Storage Cached[NumCached];
  Storage *FreeList[NumCached];
  unsigned NumFreeListEntries;

public:
  StorageAllocator();
  ~StorageAllocator();

  /// \brief Allocate new storage.
  Storage *Allocate() {
    if (NumFreeListEntries == 0)
11
←
Assuming the condition is true→
12
←
Taking true branch→
      return new Storage;
13
←
Memory is allocated→

    Storage *Result = FreeList[--NumFreeListEntries];
    Result->NumDiagArgs = 0;
    Result->DiagRanges.clear();
    Result->FixItHints.clear();
    return Result;
  }

  /// \brief Free the given storage object.
  void Deallocate(Storage *S) {
    if (S >= Cached && S <= Cached + NumCached) {
      FreeList[NumFreeListEntries++] = S;
      return;
    }

    delete S;
  }
};

118private:
// NOTE: Sema assumes that PartialDiagnostic is location-invariant
// in the sense that its bits can be safely memcpy'ed and destructed
// in the new location.

/// \brief The diagnostic ID.
mutable unsigned DiagID = 0;

/// \brief Storage for args and ranges.
mutable Storage *DiagStorage = nullptr;

/// \brief Allocator used to allocate storage for this diagnostic.
StorageAllocator *Allocator = nullptr;

/// \brief Retrieve storage for this particular diagnostic.
Storage *getStorage() const {
  if (DiagStorage)
8
←
Taking false branch→
    return DiagStorage;

  if (Allocator)
9
←
Taking true branch→
    DiagStorage = Allocator->Allocate();
10
←
Calling 'StorageAllocator::Allocate'→
14
←
Returned allocated memory→
  else {
    assert(Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0)))(static_cast <bool> (Allocator != reinterpret_cast<StorageAllocator
 *>(~uintptr_t(0))) ? void (0) : __assert_fail ("Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0))"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 140, __extension__ __PRETTY_FUNCTION__));
    DiagStorage = new Storage;
  }
  return DiagStorage;
}

void freeStorage() {
  if (!DiagStorage)
    return;

  // The hot path for PartialDiagnostic is when we just used it to wrap an ID
  // (typically so we have the flexibility of passing a more complex
  // diagnostic into the callee, but that does not commonly occur).
  //
  // Split this out into a slow function for silly compilers (*cough*) which
  // can't do decent partial inlining.
  freeStorageSlow();
}

void freeStorageSlow() {
  if (Allocator)
    Allocator->Deallocate(DiagStorage);
  else if (Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0)))
    delete DiagStorage;
  DiagStorage = nullptr;
}

void AddSourceRange(const CharSourceRange &R) const {
  if (!DiagStorage)
    DiagStorage = getStorage();

  DiagStorage->DiagRanges.push_back(R);
}

void AddFixItHint(const FixItHint &Hint) const {
  if (Hint.isNull())
    return;

  if (!DiagStorage)
    DiagStorage = getStorage();

  DiagStorage->FixItHints.push_back(Hint);
}

184public:
struct NullDiagnostic {};

/// \brief Create a null partial diagnostic, which cannot carry a payload,
/// and only exists to be swapped with a real partial diagnostic.
PartialDiagnostic(NullDiagnostic) {}

PartialDiagnostic(unsigned DiagID, StorageAllocator &Allocator)
    : DiagID(DiagID), Allocator(&Allocator) {}

PartialDiagnostic(const PartialDiagnostic &Other)
    : DiagID(Other.DiagID), Allocator(Other.Allocator) {
  if (Other.DiagStorage) {
    DiagStorage = getStorage();
    *DiagStorage = *Other.DiagStorage;
  }
}

PartialDiagnostic(PartialDiagnostic &&Other)
    : DiagID(Other.DiagID), DiagStorage(Other.DiagStorage),
      Allocator(Other.Allocator) {
20
←
Potential leak of memory pointed to by field 'DiagStorage'
  Other.DiagStorage = nullptr;
}

PartialDiagnostic(const PartialDiagnostic &Other, Storage *DiagStorage)
    : DiagID(Other.DiagID), DiagStorage(DiagStorage),
      Allocator(reinterpret_cast<StorageAllocator *>(~uintptr_t(0))) {
  if (Other.DiagStorage)
    *this->DiagStorage = *Other.DiagStorage;
}

PartialDiagnostic(const Diagnostic &Other, StorageAllocator &Allocator)
    : DiagID(Other.getID()), Allocator(&Allocator) {
  // Copy arguments.
  for (unsigned I = 0, N = Other.getNumArgs(); I != N; ++I) {
    if (Other.getArgKind(I) == DiagnosticsEngine::ak_std_string)
      AddString(Other.getArgStdStr(I));
    else
      AddTaggedVal(Other.getRawArg(I), Other.getArgKind(I));
  }

  // Copy source ranges.
  for (unsigned I = 0, N = Other.getNumRanges(); I != N; ++I)
    AddSourceRange(Other.getRange(I));

  // Copy fix-its.
  for (unsigned I = 0, N = Other.getNumFixItHints(); I != N; ++I)
    AddFixItHint(Other.getFixItHint(I));
}

PartialDiagnostic &operator=(const PartialDiagnostic &Other) {
  DiagID = Other.DiagID;
  if (Other.DiagStorage) {
    if (!DiagStorage)
      DiagStorage = getStorage();

    *DiagStorage = *Other.DiagStorage;
  } else {
    freeStorage();
  }

  return *this;
}

PartialDiagnostic &operator=(PartialDiagnostic &&Other) {
  freeStorage();

  DiagID = Other.DiagID;
  DiagStorage = Other.DiagStorage;
  Allocator = Other.Allocator;

  Other.DiagStorage = nullptr;
  return *this;
}

~PartialDiagnostic() {
  freeStorage();
}

void swap(PartialDiagnostic &PD) {
  std::swap(DiagID, PD.DiagID);
  std::swap(DiagStorage, PD.DiagStorage);
  std::swap(Allocator, PD.Allocator);
}

unsigned getDiagID() const { return DiagID; }

void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const {
  if (!DiagStorage)
6
←
Taking true branch→
    DiagStorage = getStorage();
7
←
Calling 'PartialDiagnostic::getStorage'→
15
←
Returned allocated memory→

  assert(DiagStorage->NumDiagArgs < Storage::MaxArguments &&(static_cast <bool> (DiagStorage->NumDiagArgs < Storage
::MaxArguments && "Too many arguments to diagnostic!"
) ? void (0) : __assert_fail ("DiagStorage->NumDiagArgs < Storage::MaxArguments && \"Too many arguments to diagnostic!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 276, __extension__ __PRETTY_FUNCTION__))
         "Too many arguments to diagnostic!")(static_cast <bool> (DiagStorage->NumDiagArgs < Storage
::MaxArguments && "Too many arguments to diagnostic!"
) ? void (0) : __assert_fail ("DiagStorage->NumDiagArgs < Storage::MaxArguments && \"Too many arguments to diagnostic!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 276, __extension__ __PRETTY_FUNCTION__));
  DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = Kind;
  DiagStorage->DiagArgumentsVal[DiagStorage->NumDiagArgs++] = V;
}

void AddString(StringRef V) const {
  if (!DiagStorage)
    DiagStorage = getStorage();

  assert(DiagStorage->NumDiagArgs < Storage::MaxArguments &&(static_cast <bool> (DiagStorage->NumDiagArgs < Storage
::MaxArguments && "Too many arguments to diagnostic!"
) ? void (0) : __assert_fail ("DiagStorage->NumDiagArgs < Storage::MaxArguments && \"Too many arguments to diagnostic!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 286, __extension__ __PRETTY_FUNCTION__))
         "Too many arguments to diagnostic!")(static_cast <bool> (DiagStorage->NumDiagArgs < Storage
::MaxArguments && "Too many arguments to diagnostic!"
) ? void (0) : __assert_fail ("DiagStorage->NumDiagArgs < Storage::MaxArguments && \"Too many arguments to diagnostic!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 286, __extension__ __PRETTY_FUNCTION__));
  DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs]
    = DiagnosticsEngine::ak_std_string;
  DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = V;
}

void Emit(const DiagnosticBuilder &DB) const {
  if (!DiagStorage)
    return;

  // Add all arguments.
  for (unsigned i = 0, e = DiagStorage->NumDiagArgs; i != e; ++i) {
    if ((DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]
          == DiagnosticsEngine::ak_std_string)
      DB.AddString(DiagStorage->DiagArgumentsStr[i]);
    else
      DB.AddTaggedVal(DiagStorage->DiagArgumentsVal[i],
          (DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]);
  }

  // Add all ranges.
  for (const CharSourceRange &Range : DiagStorage->DiagRanges)
    DB.AddSourceRange(Range);

  // Add all fix-its.
  for (const FixItHint &Fix : DiagStorage->FixItHints)
    DB.AddFixItHint(Fix);
}

void EmitToString(DiagnosticsEngine &Diags,
                  SmallVectorImpl<char> &Buf) const {
  // FIXME: It should be possible to render a diagnostic to a string without
  //        messing with the state of the diagnostics engine.
  DiagnosticBuilder DB(Diags.Report(getDiagID()));
  Emit(DB);
  DB.FlushCounts();
  Diagnostic(&Diags).FormatDiagnostic(Buf);
  DB.Clear();
  Diags.Clear();
}

/// \brief Clear out this partial diagnostic, giving it a new diagnostic ID
/// and removing all of its arguments, ranges, and fix-it hints.
void Reset(unsigned DiagID = 0) {
  this->DiagID = DiagID;
  freeStorage();
}

bool hasStorage() const { return DiagStorage != nullptr; }

/// Retrieve the string argument at the given index.
StringRef getStringArg(unsigned I) {
  assert(DiagStorage && "No diagnostic storage?")(static_cast <bool> (DiagStorage && "No diagnostic storage?"
) ? void (0) : __assert_fail ("DiagStorage && \"No diagnostic storage?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 338, __extension__ __PRETTY_FUNCTION__));
  assert(I < DiagStorage->NumDiagArgs && "Not enough diagnostic args")(static_cast <bool> (I < DiagStorage->NumDiagArgs
 && "Not enough diagnostic args") ? void (0) : __assert_fail
 ("I < DiagStorage->NumDiagArgs && \"Not enough diagnostic args\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 339, __extension__ __PRETTY_FUNCTION__));
  assert(DiagStorage->DiagArgumentsKind[I](static_cast <bool> (DiagStorage->DiagArgumentsKind[
I] == DiagnosticsEngine::ak_std_string && "Not a string arg"
) ? void (0) : __assert_fail ("DiagStorage->DiagArgumentsKind[I] == DiagnosticsEngine::ak_std_string && \"Not a string arg\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 341, __extension__ __PRETTY_FUNCTION__))
           == DiagnosticsEngine::ak_std_string && "Not a string arg")(static_cast <bool> (DiagStorage->DiagArgumentsKind[
I] == DiagnosticsEngine::ak_std_string && "Not a string arg"
) ? void (0) : __assert_fail ("DiagStorage->DiagArgumentsKind[I] == DiagnosticsEngine::ak_std_string && \"Not a string arg\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Basic/PartialDiagnostic.h"
, 341, __extension__ __PRETTY_FUNCTION__));
  return DiagStorage->DiagArgumentsStr[I];
}

friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                           unsigned I) {
  PD.AddTaggedVal(I, DiagnosticsEngine::ak_uint);
  return PD;
}

friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                           int I) {
  PD.AddTaggedVal(I, DiagnosticsEngine::ak_sint);
  return PD;
}

friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                                  const char *S) {
  PD.AddTaggedVal(reinterpret_cast<intptr_t>(S),
                  DiagnosticsEngine::ak_c_string);
  return PD;
}

friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                                  StringRef S) {

  PD.AddString(S);
  return PD;
}

friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                                  const IdentifierInfo *II) {
  PD.AddTaggedVal(reinterpret_cast<intptr_t>(II),
5
←
Calling 'PartialDiagnostic::AddTaggedVal'→
16
←
Returned allocated memory→
                  DiagnosticsEngine::ak_identifierinfo);
  return PD;
}

// Adds a DeclContext to the diagnostic. The enable_if template magic is here
// so that we only match those arguments that are (statically) DeclContexts;
// other arguments that derive from DeclContext (e.g., RecordDecls) will not
// match.
template<typename T>
friend inline
typename std::enable_if<std::is_same<T, DeclContext>::value,
                        const PartialDiagnostic &>::type
operator<<(const PartialDiagnostic &PD, T *DC) {
  PD.AddTaggedVal(reinterpret_cast<intptr_t>(DC),
                  DiagnosticsEngine::ak_declcontext);
  return PD;
}

friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                                  SourceRange R) {
  PD.AddSourceRange(CharSourceRange::getTokenRange(R));
  return PD;
}

friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                                  const CharSourceRange &R) {
  PD.AddSourceRange(R);
  return PD;
}

friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
                                           const FixItHint &Hint) {
  PD.AddFixItHint(Hint);
  return PD;
}
409};

411inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                         const PartialDiagnostic &PD) {
PD.Emit(DB);
return DB;
415}

417/// \brief A partial diagnostic along with the source location where this
418/// diagnostic occurs.
419using PartialDiagnosticAt = std::pair<SourceLocation, PartialDiagnostic>;

421} // namespace clang

423#endif // LLVM_CLANG_BASIC_PARTIALDIAGNOSTIC_H

←

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/SemaInternal.h

1//===--- SemaInternal.h - Internal Sema Interfaces --------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file provides common API and #includes for the internal
11// implementation of Sema.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CLANG_SEMA_SEMAINTERNAL_H
16#define LLVM_CLANG_SEMA_SEMAINTERNAL_H

18#include "clang/AST/ASTContext.h"
19#include "clang/Sema/Lookup.h"
20#include "clang/Sema/Sema.h"
21#include "clang/Sema/SemaDiagnostic.h"

23namespace clang {

25inline PartialDiagnostic Sema::PDiag(unsigned DiagID) {
return PartialDiagnostic(DiagID, Context.getDiagAllocator());
19
←
Calling move constructor for 'PartialDiagnostic'→
27}

29inline bool
30FTIHasSingleVoidParameter(const DeclaratorChunk::FunctionTypeInfo &FTI) {
return FTI.NumParams == 1 && !FTI.isVariadic &&
       FTI.Params[0].Ident == nullptr && FTI.Params[0].Param &&
       cast<ParmVarDecl>(FTI.Params[0].Param)->getType()->isVoidType();
34}

36inline bool
37FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI) {
// Assume FTI is well-formed.
return FTI.NumParams && !FTIHasSingleVoidParameter(FTI);
40}

42// This requires the variable to be non-dependent and the initializer
43// to not be value dependent.
44inline bool IsVariableAConstantExpression(VarDecl *Var, ASTContext &Context) {
const VarDecl *DefVD = nullptr;
return !isa<ParmVarDecl>(Var) &&
  Var->isUsableInConstantExpressions(Context) &&
  Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE(); 
49}

51// Helper function to check whether D's attributes match current CUDA mode.
52// Decls with mismatched attributes and related diagnostics may have to be
53// ignored during this CUDA compilation pass.
54inline bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D) {
if (!LangOpts.CUDA || !D)
  return true;
bool isDeviceSideDecl = D->hasAttr<CUDADeviceAttr>() ||
                        D->hasAttr<CUDASharedAttr>() ||
                        D->hasAttr<CUDAGlobalAttr>();
return isDeviceSideDecl == LangOpts.CUDAIsDevice;
61}

63// Directly mark a variable odr-used. Given a choice, prefer to use 
64// MarkVariableReferenced since it does additional checks and then 
65// calls MarkVarDeclODRUsed.
66// If the variable must be captured:
67//  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
68//  - else capture it in the DeclContext that maps to the 
69//    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.  
70inline void MarkVarDeclODRUsed(VarDecl *Var,
  SourceLocation Loc, Sema &SemaRef,
  const unsigned *const FunctionScopeIndexToStopAt) {
// Keep track of used but undefined variables.
// FIXME: We shouldn't suppress this warning for static data members.
if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly &&
    (!Var->isExternallyVisible() || Var->isInline() ||
     SemaRef.isExternalWithNoLinkageType(Var)) &&
    !(Var->isStaticDataMember() && Var->hasInit())) {
  SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
  if (old.isInvalid())
    old = Loc;
}
QualType CaptureType, DeclRefType;
SemaRef.tryCaptureVariable(Var, Loc, Sema::TryCapture_Implicit, 
  /*EllipsisLoc*/ SourceLocation(),
  /*BuildAndDiagnose*/ true, 
  CaptureType, DeclRefType, 
  FunctionScopeIndexToStopAt);

Var->markUsed(SemaRef.Context);
91}

93/// Return a DLL attribute from the declaration.
94inline InheritableAttr *getDLLAttr(Decl *D) {
assert(!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) &&(static_cast <bool> (!(D->hasAttr<DLLImportAttr>
() && D->hasAttr<DLLExportAttr>()) &&
 "A declaration cannot be both dllimport and dllexport.") ? void
 (0) : __assert_fail ("!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) && \"A declaration cannot be both dllimport and dllexport.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/SemaInternal.h"
, 96, __extension__ __PRETTY_FUNCTION__))
       "A declaration cannot be both dllimport and dllexport.")(static_cast <bool> (!(D->hasAttr<DLLImportAttr>
() && D->hasAttr<DLLExportAttr>()) &&
 "A declaration cannot be both dllimport and dllexport.") ? void
 (0) : __assert_fail ("!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) && \"A declaration cannot be both dllimport and dllexport.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/SemaInternal.h"
, 96, __extension__ __PRETTY_FUNCTION__));
if (auto *Import = D->getAttr<DLLImportAttr>())
  return Import;
if (auto *Export = D->getAttr<DLLExportAttr>())
  return Export;
return nullptr;
102}

104class TypoCorrectionConsumer : public VisibleDeclConsumer {
typedef SmallVector<TypoCorrection, 1> TypoResultList;
typedef llvm::StringMap<TypoResultList> TypoResultsMap;
typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;

109public:
TypoCorrectionConsumer(Sema &SemaRef,
                       const DeclarationNameInfo &TypoName,
                       Sema::LookupNameKind LookupKind,
                       Scope *S, CXXScopeSpec *SS,
                       std::unique_ptr<CorrectionCandidateCallback> CCC,
                       DeclContext *MemberContext,
                       bool EnteringContext)
    : Typo(TypoName.getName().getAsIdentifierInfo()), CurrentTCIndex(0),
      SavedTCIndex(0), SemaRef(SemaRef), S(S),
      SS(SS ? llvm::make_unique<CXXScopeSpec>(*SS) : nullptr),
      CorrectionValidator(std::move(CCC)), MemberContext(MemberContext),
      Result(SemaRef, TypoName, LookupKind),
      Namespaces(SemaRef.Context, SemaRef.CurContext, SS),
      EnteringContext(EnteringContext), SearchNamespaces(false) {
  Result.suppressDiagnostics();
  // Arrange for ValidatedCorrections[0] to always be an empty correction.
  ValidatedCorrections.push_back(TypoCorrection());
}

bool includeHiddenDecls() const override { return true; }

// Methods for adding potential corrections to the consumer.
void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
               bool InBaseClass) override;
void FoundName(StringRef Name);
void addKeywordResult(StringRef Keyword);
void addCorrection(TypoCorrection Correction);

bool empty() const {
  return CorrectionResults.empty() && ValidatedCorrections.size() == 1;
}

/// \brief Return the list of TypoCorrections for the given identifier from
/// the set of corrections that have the closest edit distance, if any.
TypoResultList &operator[](StringRef Name) {
  return CorrectionResults.begin()->second[Name];
}

/// \brief Return the edit distance of the corrections that have the
/// closest/best edit distance from the original typop.
unsigned getBestEditDistance(bool Normalized) {
  if (CorrectionResults.empty())
    return (std::numeric_limits<unsigned>::max)();

  unsigned BestED = CorrectionResults.begin()->first;
  return Normalized ? TypoCorrection::NormalizeEditDistance(BestED) : BestED;
}

/// \brief Set-up method to add to the consumer the set of namespaces to use
/// in performing corrections to nested name specifiers. This method also
/// implicitly adds all of the known classes in the current AST context to the
/// to the consumer for correcting nested name specifiers.
void
addNamespaces(const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces);

/// \brief Return the next typo correction that passes all internal filters
/// and is deemed valid by the consumer's CorrectionCandidateCallback,
/// starting with the corrections that have the closest edit distance. An
/// empty TypoCorrection is returned once no more viable corrections remain
/// in the consumer.
const TypoCorrection &getNextCorrection();

/// \brief Get the last correction returned by getNextCorrection().
const TypoCorrection &getCurrentCorrection() {
  return CurrentTCIndex < ValidatedCorrections.size()
             ? ValidatedCorrections[CurrentTCIndex]
             : ValidatedCorrections[0];  // The empty correction.
}

/// \brief Return the next typo correction like getNextCorrection, but keep
/// the internal state pointed to the current correction (i.e. the next time
/// getNextCorrection is called, it will return the same correction returned
/// by peekNextcorrection).
const TypoCorrection &peekNextCorrection() {
  auto Current = CurrentTCIndex;
  const TypoCorrection &TC = getNextCorrection();
  CurrentTCIndex = Current;
  return TC;
}

/// \brief Reset the consumer's position in the stream of viable corrections
/// (i.e. getNextCorrection() will return each of the previously returned
/// corrections in order before returning any new corrections).
void resetCorrectionStream() {
  CurrentTCIndex = 0;
}

/// \brief Return whether the end of the stream of corrections has been
/// reached.
bool finished() {
  return CorrectionResults.empty() &&
         CurrentTCIndex >= ValidatedCorrections.size();
}

/// \brief Save the current position in the correction stream (overwriting any
/// previously saved position).
void saveCurrentPosition() {
  SavedTCIndex = CurrentTCIndex;
}

/// \brief Restore the saved position in the correction stream.
void restoreSavedPosition() {
  CurrentTCIndex = SavedTCIndex;
}

ASTContext &getContext() const { return SemaRef.Context; }
const LookupResult &getLookupResult() const { return Result; }

bool isAddressOfOperand() const { return CorrectionValidator->IsAddressOfOperand; }
const CXXScopeSpec *getSS() const { return SS.get(); }
Scope *getScope() const { return S; }
CorrectionCandidateCallback *getCorrectionValidator() const {
  return CorrectionValidator.get();
}

225private:
class NamespaceSpecifierSet {
  struct SpecifierInfo {
    DeclContext* DeclCtx;
    NestedNameSpecifier* NameSpecifier;
    unsigned EditDistance;
  };

  typedef SmallVector<DeclContext*, 4> DeclContextList;
  typedef SmallVector<SpecifierInfo, 16> SpecifierInfoList;

  ASTContext &Context;
  DeclContextList CurContextChain;
  std::string CurNameSpecifier;
  SmallVector<const IdentifierInfo*, 4> CurContextIdentifiers;
  SmallVector<const IdentifierInfo*, 4> CurNameSpecifierIdentifiers;

  std::map<unsigned, SpecifierInfoList> DistanceMap;

  /// \brief Helper for building the list of DeclContexts between the current
  /// context and the top of the translation unit
  static DeclContextList buildContextChain(DeclContext *Start);

  unsigned buildNestedNameSpecifier(DeclContextList &DeclChain,
                                    NestedNameSpecifier *&NNS);

 public:
  NamespaceSpecifierSet(ASTContext &Context, DeclContext *CurContext,
                        CXXScopeSpec *CurScopeSpec);

  /// \brief Add the DeclContext (a namespace or record) to the set, computing
  /// the corresponding NestedNameSpecifier and its distance in the process.
  void addNameSpecifier(DeclContext *Ctx);

  /// \brief Provides flat iteration over specifiers, sorted by distance.
  class iterator
      : public llvm::iterator_facade_base<iterator, std::forward_iterator_tag,
                                          SpecifierInfo> {
    /// Always points to the last element in the distance map.
    const std::map<unsigned, SpecifierInfoList>::iterator OuterBack;
    /// Iterator on the distance map.
    std::map<unsigned, SpecifierInfoList>::iterator Outer;
    /// Iterator on an element in the distance map.
    SpecifierInfoList::iterator Inner;

  public:
    iterator(NamespaceSpecifierSet &Set, bool IsAtEnd)
        : OuterBack(std::prev(Set.DistanceMap.end())),
          Outer(Set.DistanceMap.begin()),
          Inner(!IsAtEnd ? Outer->second.begin() : OuterBack->second.end()) {
      assert(!Set.DistanceMap.empty())(static_cast <bool> (!Set.DistanceMap.empty()) ? void (
0) : __assert_fail ("!Set.DistanceMap.empty()", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include/clang/Sema/SemaInternal.h"
, 275, __extension__ __PRETTY_FUNCTION__));
    }

    iterator &operator++() {
      ++Inner;
      if (Inner == Outer->second.end() && Outer != OuterBack) {
        ++Outer;
        Inner = Outer->second.begin();
      }
      return *this;
    }

    SpecifierInfo &operator*() { return *Inner; }
    bool operator==(const iterator &RHS) const { return Inner == RHS.Inner; }
  };

  iterator begin() { return iterator(*this, /*IsAtEnd=*/false); }
  iterator end() { return iterator(*this, /*IsAtEnd=*/true); }
};

void addName(StringRef Name, NamedDecl *ND,
             NestedNameSpecifier *NNS = nullptr, bool isKeyword = false);

/// \brief Find any visible decls for the given typo correction candidate.
/// If none are found, it to the set of candidates for which qualified lookups
/// will be performed to find possible nested name specifier changes.
bool resolveCorrection(TypoCorrection &Candidate);

/// \brief Perform qualified lookups on the queued set of typo correction
/// candidates and add the nested name specifier changes to each candidate if
/// a lookup succeeds (at which point the candidate will be returned to the
/// main pool of potential corrections).
void performQualifiedLookups();

/// \brief The name written that is a typo in the source.
IdentifierInfo *Typo;

/// \brief The results found that have the smallest edit distance
/// found (so far) with the typo name.
///
/// The pointer value being set to the current DeclContext indicates
/// whether there is a keyword with this name.
TypoEditDistanceMap CorrectionResults;

SmallVector<TypoCorrection, 4> ValidatedCorrections;
size_t CurrentTCIndex;
size_t SavedTCIndex;

Sema &SemaRef;
Scope *S;
std::unique_ptr<CXXScopeSpec> SS;
std::unique_ptr<CorrectionCandidateCallback> CorrectionValidator;
DeclContext *MemberContext;
LookupResult Result;
NamespaceSpecifierSet Namespaces;
SmallVector<TypoCorrection, 2> QualifiedResults;
bool EnteringContext;
bool SearchNamespaces;
333};

335inline Sema::TypoExprState::TypoExprState() {}

337inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) noexcept {
*this = std::move(other);
339}

341inline Sema::TypoExprState &Sema::TypoExprState::
342operator=(Sema::TypoExprState &&other) noexcept {
Consumer = std::move(other.Consumer);
DiagHandler = std::move(other.DiagHandler);
RecoveryHandler = std::move(other.RecoveryHandler);
return *this;
347}

349} // end namespace clang

351#endif