From 67fd1251aad51bb80d050b7fa5e506fef0ec8e02 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Fri, 14 Jan 2011 21:20:45 +0000 Subject: [PATCH] Teach PackExpansionExpr to keep track of the number of pack expansions it will expand to, if known. Propagate this information throughout Sema. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@123470 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/ExprCXX.h | 22 +++++++++++++- include/clang/Sema/Sema.h | 12 +++++++- lib/AST/DeclTemplate.cpp | 3 +- lib/AST/TemplateBase.cpp | 2 +- lib/Sema/SemaTemplateDeduction.cpp | 3 -- lib/Sema/SemaTemplateVariadic.cpp | 11 +++---- lib/Sema/TreeTransform.h | 23 +++++++++------ lib/Serialization/ASTReaderStmt.cpp | 1 + lib/Serialization/ASTWriterStmt.cpp | 1 + .../multi-level-substitution.cpp | 29 +++++++++++++++++++ 10 files changed, 86 insertions(+), 21 deletions(-) diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h index 1ad87a45df..abc8c77a38 100644 --- a/include/clang/AST/ExprCXX.h +++ b/include/clang/AST/ExprCXX.h @@ -2612,16 +2612,27 @@ public: /// or more function arguments to the function object \c f. class PackExpansionExpr : public Expr { SourceLocation EllipsisLoc; + + /// \brief The number of expansions that will be produced by this pack + /// expansion expression, if known. + /// + /// When zero, the number of expansions is not known. Otherwise, this value + /// is the number of expansions + 1. + unsigned NumExpansions; + Stmt *Pattern; friend class ASTStmtReader; + friend class ASTStmtWriter; public: - PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc) + PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, + llvm::Optional NumExpansions) : Expr(PackExpansionExprClass, T, Pattern->getValueKind(), Pattern->getObjectKind(), /*TypeDependent=*/true, /*ValueDependent=*/true, /*ContainsUnexpandedParameterPack=*/false), EllipsisLoc(EllipsisLoc), + NumExpansions(NumExpansions? *NumExpansions + 1 : 0), Pattern(Pattern) { } PackExpansionExpr(EmptyShell Empty) : Expr(PackExpansionExprClass, Empty) { } @@ -2636,6 +2647,15 @@ public: /// expansion. SourceLocation getEllipsisLoc() const { return EllipsisLoc; } + /// \brief Determine the number of expansions that will be produced when + /// this pack expansion is instantiated, if already known. + llvm::Optional getNumExpansions() const { + if (NumExpansions) + return NumExpansions - 1; + + return llvm::Optional(); + } + virtual SourceRange getSourceRange() const; static bool classof(const Stmt *T) { diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index ee286ddf1d..d00a371c22 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -3348,7 +3348,17 @@ public: /// /// \param EllipsisLoc The location of the ellipsis. ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc); - + + /// \brief Invoked when parsing an expression followed by an ellipsis, which + /// creates a pack expansion. + /// + /// \param Pattern The expression preceding the ellipsis, which will become + /// the pattern of the pack expansion. + /// + /// \param EllipsisLoc The location of the ellipsis. + ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, + llvm::Optional NumExpansions); + /// \brief Determine whether we could expand a pack expansion with the /// given set of parameter packs into separate arguments by repeatedly /// transforming the pattern. diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp index bd91facd08..e7902e996a 100644 --- a/lib/AST/DeclTemplate.cpp +++ b/lib/AST/DeclTemplate.cpp @@ -332,7 +332,8 @@ ClassTemplateDecl::getInjectedClassNameSpecialization() { if (NTTP->isParameterPack()) E = new (Context) PackExpansionExpr(Context.DependentTy, E, - NTTP->getLocation()); + NTTP->getLocation(), + llvm::Optional()); Arg = TemplateArgument(E); } else { TemplateTemplateParmDecl *TTP = cast(*Param); diff --git a/lib/AST/TemplateBase.cpp b/lib/AST/TemplateBase.cpp index f7c4ac832f..26c0c08971 100644 --- a/lib/AST/TemplateBase.cpp +++ b/lib/AST/TemplateBase.cpp @@ -384,7 +384,7 @@ TemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis, = cast(Argument.getAsExpr()); Expr *Pattern = Expansion->getPattern(); Ellipsis = Expansion->getEllipsisLoc(); - // FIXME: Variadic templates num expansions + NumExpansions = Expansion->getNumExpansions(); return TemplateArgumentLoc(Pattern, Pattern); } diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp index c03a778a65..fddd14e28b 100644 --- a/lib/Sema/SemaTemplateDeduction.cpp +++ b/lib/Sema/SemaTemplateDeduction.cpp @@ -1463,9 +1463,6 @@ DeduceTemplateArguments(Sema &S, unsigned ArgIdx = 0, ParamIdx = 0; for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); ++ParamIdx) { - // FIXME: Variadic templates. - // What do we do if the argument is a pack expansion? - if (!Params[ParamIdx].isPackExpansion()) { // The simple case: deduce template arguments by matching Pi and Ai. diff --git a/lib/Sema/SemaTemplateVariadic.cpp b/lib/Sema/SemaTemplateVariadic.cpp index 899b58e558..38a777efb1 100644 --- a/lib/Sema/SemaTemplateVariadic.cpp +++ b/lib/Sema/SemaTemplateVariadic.cpp @@ -415,6 +415,11 @@ QualType Sema::CheckPackExpansion(QualType Pattern, } ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { + return CheckPackExpansion(Pattern, EllipsisLoc, llvm::Optional()); +} + +ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, + llvm::Optional NumExpansions) { if (!Pattern) return ExprError(); @@ -430,7 +435,7 @@ ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { // Create the pack expansion expression and source-location information. return Owned(new (Context) PackExpansionExpr(Context.DependentTy, Pattern, - EllipsisLoc)); + EllipsisLoc, NumExpansions)); } /// \brief Retrieve the depth and index of a parameter pack. @@ -459,10 +464,6 @@ bool Sema::CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, std::pair FirstPack; bool HaveFirstPack = false; - // FIXME: Variadic templates. Even if we don't expand, we'd still like to - // return the number of expansions back to the caller, perhaps as an - // llvm::Optional, so that it can be embedded in the pack expansion. This - // is important for the multi-level substitution case. for (unsigned I = 0; I != NumUnexpanded; ++I) { // Compute the depth and index for this parameter pack. unsigned Depth; diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index f2496c2f1a..d973f82401 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -2176,8 +2176,8 @@ public: switch (Pattern.getArgument().getKind()) { case TemplateArgument::Expression: { ExprResult Result - = getSema().ActOnPackExpansion(Pattern.getSourceExpression(), - EllipsisLoc); + = getSema().CheckPackExpansion(Pattern.getSourceExpression(), + EllipsisLoc, NumExpansions); if (Result.isInvalid()) return TemplateArgumentLoc(); @@ -2217,8 +2217,9 @@ public: /// By default, performs semantic analysis to build a new pack expansion /// for an expression. Subclasses may override this routine to provide /// different behavior. - ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { - return getSema().ActOnPackExpansion(Pattern, EllipsisLoc); + ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, + llvm::Optional NumExpansions) { + return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); } private: @@ -2308,7 +2309,9 @@ bool TreeTransform::TransformExprs(Expr **Inputs, // be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional NumExpansions; + llvm::Optional OrigNumExpansions + = Expansion->getNumExpansions(); + llvm::Optional NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded.data(), @@ -2326,9 +2329,9 @@ bool TreeTransform::TransformExprs(Expr **Inputs, if (OutPattern.isInvalid()) return true; - // FIXME: Variadic templates NumExpansions ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), - Expansion->getEllipsisLoc()); + Expansion->getEllipsisLoc(), + NumExpansions); if (Out.isInvalid()) return true; @@ -2347,7 +2350,8 @@ bool TreeTransform::TransformExprs(Expr **Inputs, return true; if (Out.get()->containsUnexpandedParameterPack()) { - Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc()); + Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(), + OrigNumExpansions); if (Out.isInvalid()) return true; } @@ -6818,7 +6822,8 @@ TreeTransform::TransformPackExpansionExpr(PackExpansionExpr *E) { if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) return SemaRef.Owned(E); - return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc()); + return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), + E->getNumExpansions()); } template diff --git a/lib/Serialization/ASTReaderStmt.cpp b/lib/Serialization/ASTReaderStmt.cpp index b0a1e4e475..022b619412 100644 --- a/lib/Serialization/ASTReaderStmt.cpp +++ b/lib/Serialization/ASTReaderStmt.cpp @@ -1294,6 +1294,7 @@ void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) { VisitExpr(E); E->EllipsisLoc = ReadSourceLocation(Record, Idx); + E->NumExpansions = Record[Idx++]; E->Pattern = Reader.ReadSubExpr(); } diff --git a/lib/Serialization/ASTWriterStmt.cpp b/lib/Serialization/ASTWriterStmt.cpp index c41cc1a751..205f4dc2a9 100644 --- a/lib/Serialization/ASTWriterStmt.cpp +++ b/lib/Serialization/ASTWriterStmt.cpp @@ -1301,6 +1301,7 @@ void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getEllipsisLoc(), Record); + Record.push_back(E->NumExpansions); Writer.AddStmt(E->getPattern()); Code = serialization::EXPR_PACK_EXPANSION; } diff --git a/test/CXX/temp/temp.decls/temp.variadic/multi-level-substitution.cpp b/test/CXX/temp/temp.decls/temp.variadic/multi-level-substitution.cpp index a01ffc338f..a061104d65 100644 --- a/test/CXX/temp/temp.decls/temp.variadic/multi-level-substitution.cpp +++ b/test/CXX/temp/temp.decls/temp.variadic/multi-level-substitution.cpp @@ -37,4 +37,33 @@ namespace PacksAtDifferentLevels { pair, pair> >::value == 1? 1 : -1]; + + template struct unsigned_tuple { }; + template + struct X1 { + template struct Inner { + static const unsigned value = 0; + }; + + template + struct Inner...>, + unsigned_tuple> { + static const unsigned value = 1; + }; + }; + + int check2[X1::Inner, + pair, + pair>, + unsigned_tuple + >::value == 1? 1 : -1]; + int check3[X1::Inner, + pair, + pair>, + unsigned_tuple + >::value == 0? 1 : -1]; } -- 2.40.0