From d507ee11ead38846eec05eae085c6935abcead47 Mon Sep 17 00:00:00 2001 From: Bruno Ricci Date: Tue, 29 Jan 2019 12:57:11 +0000 Subject: [PATCH] Re-commit "[AST] Introduce GenericSelectionExpr::Association" This time with a fix to make gcc 4.8 happy. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@352486 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/Expr.h | 144 +++++++++++++++++++++--- include/clang/AST/RecursiveASTVisitor.h | 8 +- include/clang/AST/StmtDataCollectors.td | 4 +- lib/AST/ASTDumper.cpp | 10 +- lib/AST/StmtPrinter.cpp | 6 +- lib/AST/StmtProfile.cpp | 7 +- lib/Sema/SemaExprObjC.cpp | 16 +-- lib/Sema/SemaPseudoObject.cpp | 22 ++-- lib/Sema/TreeTransform.h | 11 +- 9 files changed, 173 insertions(+), 55 deletions(-) diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h index f770cf327c..133f28ae3f 100644 --- a/include/clang/AST/Expr.h +++ b/include/clang/AST/Expr.h @@ -28,6 +28,8 @@ #include "clang/Basic/TypeTraits.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APSInt.h" +#include "llvm/ADT/iterator.h" +#include "llvm/ADT/iterator_range.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/AtomicOrdering.h" @@ -5052,6 +5054,86 @@ class GenericSelectionExpr final return getNumAssocs(); } + template class AssociationIteratorTy; + /// Bundle together an association expression and its TypeSourceInfo. + /// The Const template parameter is for the const and non-const versions + /// of AssociationTy. + template class AssociationTy { + friend class GenericSelectionExpr; + template friend class AssociationIteratorTy; + using ExprPtrTy = + typename std::conditional::type; + using TSIPtrTy = typename std::conditional::type; + ExprPtrTy E; + TSIPtrTy TSI; + bool Selected; + AssociationTy(ExprPtrTy E, TSIPtrTy TSI, bool Selected) + : E(E), TSI(TSI), Selected(Selected) {} + + public: + ExprPtrTy getAssociationExpr() const { return E; } + TSIPtrTy getTypeSourceInfo() const { return TSI; } + QualType getType() const { return TSI ? TSI->getType() : QualType(); } + bool isSelected() const { return Selected; } + AssociationTy *operator->() { return this; } + const AssociationTy *operator->() const { return this; } + }; // class AssociationTy + + /// Iterator over const and non-const Association objects. The Association + /// objects are created on the fly when the iterator is dereferenced. + /// This abstract over how exactly the association expressions and the + /// corresponding TypeSourceInfo * are stored. + template + class AssociationIteratorTy + : public llvm::iterator_facade_base< + AssociationIteratorTy, std::input_iterator_tag, + AssociationTy, std::ptrdiff_t, AssociationTy, + AssociationTy> { + friend class GenericSelectionExpr; + // FIXME: This iterator could conceptually be a random access iterator, and + // it would be nice if we could strengthen the iterator category someday. + // However this iterator does not satisfy two requirements of forward + // iterators: + // a) reference = T& or reference = const T& + // b) If It1 and It2 are both dereferenceable, then It1 == It2 if and only + // if *It1 and *It2 are bound to the same objects. + // An alternative design approach was discussed during review; + // store an Association object inside the iterator, and return a reference + // to it when dereferenced. This idea was discarded beacuse of nasty + // lifetime issues: + // AssociationIterator It = ...; + // const Association &Assoc = *It++; // Oops, Assoc is dangling. + using BaseTy = typename AssociationIteratorTy::iterator_facade_base; + using StmtPtrPtrTy = + typename std::conditional::type; + using TSIPtrPtrTy = + typename std::conditional::type; + StmtPtrPtrTy E; // = nullptr; FIXME: Once support for gcc 4.8 is dropped. + TSIPtrPtrTy TSI; // Kept in sync with E. + unsigned Offset = 0, SelectedOffset = 0; + AssociationIteratorTy(StmtPtrPtrTy E, TSIPtrPtrTy TSI, unsigned Offset, + unsigned SelectedOffset) + : E(E), TSI(TSI), Offset(Offset), SelectedOffset(SelectedOffset) {} + + public: + AssociationIteratorTy() : E(nullptr), TSI(nullptr) {} + typename BaseTy::reference operator*() const { + return AssociationTy(cast(*E), *TSI, + Offset == SelectedOffset); + } + typename BaseTy::pointer operator->() const { return **this; } + using BaseTy::operator++; + AssociationIteratorTy &operator++() { + ++E; + ++TSI; + ++Offset; + return *this; + } + bool operator==(AssociationIteratorTy Other) const { return E == Other.E; } + }; // class AssociationIterator + /// Build a non-result-dependent generic selection expression. GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, @@ -5092,6 +5174,14 @@ public: static GenericSelectionExpr *CreateEmpty(const ASTContext &Context, unsigned NumAssocs); + using Association = AssociationTy; + using ConstAssociation = AssociationTy; + using AssociationIterator = AssociationIteratorTy; + using ConstAssociationIterator = AssociationIteratorTy; + using association_range = llvm::iterator_range; + using const_association_range = + llvm::iterator_range; + /// The number of association expressions. unsigned getNumAssocs() const { return NumAssocs; } @@ -5135,23 +5225,43 @@ public: return {getTrailingObjects(), NumAssocs}; } - Expr *getAssocExpr(unsigned i) { - return cast(getTrailingObjects()[AssocExprStartIndex + i]); - } - const Expr *getAssocExpr(unsigned i) const { - return cast(getTrailingObjects()[AssocExprStartIndex + i]); - } - - TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) { - return getTrailingObjects()[i]; - } - const TypeSourceInfo *getAssocTypeSourceInfo(unsigned i) const { - return getTrailingObjects()[i]; - } - - QualType getAssocType(unsigned i) const { - const TypeSourceInfo *TSI = getAssocTypeSourceInfo(i); - return TSI ? TSI->getType() : QualType(); + /// Return the Ith association expression with its TypeSourceInfo, + /// bundled together in GenericSelectionExpr::(Const)Association. + Association getAssociation(unsigned I) { + assert(I < getNumAssocs() && + "Out-of-range index in GenericSelectionExpr::getAssociation!"); + return Association( + cast(getTrailingObjects()[AssocExprStartIndex + I]), + getTrailingObjects()[I], + !isResultDependent() && (getResultIndex() == I)); + } + ConstAssociation getAssociation(unsigned I) const { + assert(I < getNumAssocs() && + "Out-of-range index in GenericSelectionExpr::getAssociation!"); + return ConstAssociation( + cast(getTrailingObjects()[AssocExprStartIndex + I]), + getTrailingObjects()[I], + !isResultDependent() && (getResultIndex() == I)); + } + + association_range associations() { + AssociationIterator Begin(getTrailingObjects() + + AssocExprStartIndex, + getTrailingObjects(), + /*Offset=*/0, ResultIndex); + AssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs, + /*Offset=*/NumAssocs, ResultIndex); + return llvm::make_range(Begin, End); + } + + const_association_range associations() const { + ConstAssociationIterator Begin(getTrailingObjects() + + AssocExprStartIndex, + getTrailingObjects(), + /*Offset=*/0, ResultIndex); + ConstAssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs, + /*Offset=*/NumAssocs, ResultIndex); + return llvm::make_range(Begin, End); } SourceLocation getGenericLoc() const { diff --git a/include/clang/AST/RecursiveASTVisitor.h b/include/clang/AST/RecursiveASTVisitor.h index 96f788774a..51050e80af 100644 --- a/include/clang/AST/RecursiveASTVisitor.h +++ b/include/clang/AST/RecursiveASTVisitor.h @@ -2301,10 +2301,10 @@ bool RecursiveASTVisitor::TraverseInitListExpr( // generic associations). DEF_TRAVERSE_STMT(GenericSelectionExpr, { TRY_TO(TraverseStmt(S->getControllingExpr())); - for (unsigned i = 0; i != S->getNumAssocs(); ++i) { - if (TypeSourceInfo *TS = S->getAssocTypeSourceInfo(i)) - TRY_TO(TraverseTypeLoc(TS->getTypeLoc())); - TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getAssocExpr(i)); + for (const GenericSelectionExpr::Association &Assoc : S->associations()) { + if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo()) + TRY_TO(TraverseTypeLoc(TSI->getTypeLoc())); + TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(Assoc.getAssociationExpr()); } ShouldVisitChildren = false; }) diff --git a/include/clang/AST/StmtDataCollectors.td b/include/clang/AST/StmtDataCollectors.td index 90ca080273..a46d2714eb 100644 --- a/include/clang/AST/StmtDataCollectors.td +++ b/include/clang/AST/StmtDataCollectors.td @@ -189,8 +189,8 @@ class CXXFoldExpr { } class GenericSelectionExpr { code Code = [{ - for (unsigned i = 0; i < S->getNumAssocs(); ++i) { - addData(S->getAssocType(i)); + for (const GenericSelectionExpr::ConstAssociation &Assoc : S->associations()) { + addData(Assoc.getType()); } }]; } diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp index b91dab5aa3..5c99dab356 100644 --- a/lib/AST/ASTDumper.cpp +++ b/lib/AST/ASTDumper.cpp @@ -1462,21 +1462,21 @@ void ASTDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) { dumpStmt(E->getControllingExpr()); dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove - for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) { + for (const auto &Assoc : E->associations()) { dumpChild([=] { - if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) { + if (const TypeSourceInfo *TSI = Assoc.getTypeSourceInfo()) { OS << "case "; NodeDumper.dumpType(TSI->getType()); } else { OS << "default"; } - if (!E->isResultDependent() && E->getResultIndex() == I) + if (Assoc.isSelected()) OS << " selected"; - if (const TypeSourceInfo *TSI = E->getAssocTypeSourceInfo(I)) + if (const TypeSourceInfo *TSI = Assoc.getTypeSourceInfo()) dumpTypeAsChild(TSI->getType()); - dumpStmt(E->getAssocExpr(I)); + dumpStmt(Assoc.getAssociationExpr()); }); } } diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp index 221d134d33..acf19aaaf4 100644 --- a/lib/AST/StmtPrinter.cpp +++ b/lib/AST/StmtPrinter.cpp @@ -1261,15 +1261,15 @@ void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){ void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) { OS << "_Generic("; PrintExpr(Node->getControllingExpr()); - for (unsigned i = 0; i != Node->getNumAssocs(); ++i) { + for (const GenericSelectionExpr::Association &Assoc : Node->associations()) { OS << ", "; - QualType T = Node->getAssocType(i); + QualType T = Assoc.getType(); if (T.isNull()) OS << "default"; else T.print(OS, Policy); OS << ": "; - PrintExpr(Node->getAssocExpr(i)); + PrintExpr(Assoc.getAssociationExpr()); } OS << ")"; } diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp index 805056f1f7..e302b05882 100644 --- a/lib/AST/StmtProfile.cpp +++ b/lib/AST/StmtProfile.cpp @@ -1260,13 +1260,14 @@ void StmtProfiler::VisitBlockExpr(const BlockExpr *S) { void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) { VisitExpr(S); - for (unsigned i = 0; i != S->getNumAssocs(); ++i) { - QualType T = S->getAssocType(i); + for (const GenericSelectionExpr::ConstAssociation &Assoc : + S->associations()) { + QualType T = Assoc.getType(); if (T.isNull()) ID.AddPointer(nullptr); else VisitType(T); - VisitExpr(S->getAssocExpr(i)); + VisitExpr(Assoc.getAssociationExpr()); } } diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp index 4ca3b851c1..fdb59874cc 100644 --- a/lib/Sema/SemaExprObjC.cpp +++ b/lib/Sema/SemaExprObjC.cpp @@ -4332,14 +4332,16 @@ Expr *Sema::stripARCUnbridgedCast(Expr *e) { assert(!gse->isResultDependent()); unsigned n = gse->getNumAssocs(); - SmallVector subExprs(n); - SmallVector subTypes(n); - for (unsigned i = 0; i != n; ++i) { - subTypes[i] = gse->getAssocTypeSourceInfo(i); - Expr *sub = gse->getAssocExpr(i); - if (i == gse->getResultIndex()) + SmallVector subExprs; + SmallVector subTypes; + subExprs.reserve(n); + subTypes.reserve(n); + for (const GenericSelectionExpr::Association &assoc : gse->associations()) { + subTypes.push_back(assoc.getTypeSourceInfo()); + Expr *sub = assoc.getAssociationExpr(); + if (assoc.isSelected()) sub = stripARCUnbridgedCast(sub); - subExprs[i] = sub; + subExprs.push_back(sub); } return GenericSelectionExpr::Create( diff --git a/lib/Sema/SemaPseudoObject.cpp b/lib/Sema/SemaPseudoObject.cpp index 37dd7b1e8d..28a4d62b03 100644 --- a/lib/Sema/SemaPseudoObject.cpp +++ b/lib/Sema/SemaPseudoObject.cpp @@ -140,19 +140,23 @@ namespace { unsigned resultIndex = gse->getResultIndex(); unsigned numAssocs = gse->getNumAssocs(); - SmallVector assocs(numAssocs); - SmallVector assocTypes(numAssocs); - - for (unsigned i = 0; i != numAssocs; ++i) { - Expr *assoc = gse->getAssocExpr(i); - if (i == resultIndex) assoc = rebuild(assoc); - assocs[i] = assoc; - assocTypes[i] = gse->getAssocTypeSourceInfo(i); + SmallVector assocExprs; + SmallVector assocTypes; + assocExprs.reserve(numAssocs); + assocTypes.reserve(numAssocs); + + for (const GenericSelectionExpr::Association &assoc : + gse->associations()) { + Expr *assocExpr = assoc.getAssociationExpr(); + if (assoc.isSelected()) + assocExpr = rebuild(assocExpr); + assocExprs.push_back(assocExpr); + assocTypes.push_back(assoc.getTypeSourceInfo()); } return GenericSelectionExpr::Create( S.Context, gse->getGenericLoc(), gse->getControllingExpr(), - assocTypes, assocs, gse->getDefaultLoc(), gse->getRParenLoc(), + assocTypes, assocExprs, gse->getDefaultLoc(), gse->getRParenLoc(), gse->containsUnexpandedParameterPack(), resultIndex); } diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index 1631ce83aa..e411a2ad47 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -9073,10 +9073,10 @@ TreeTransform::TransformGenericSelectionExpr(GenericSelectionExpr *E) { SmallVector AssocExprs; SmallVector AssocTypes; - for (unsigned i = 0; i != E->getNumAssocs(); ++i) { - TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i); - if (TS) { - TypeSourceInfo *AssocType = getDerived().TransformType(TS); + for (const GenericSelectionExpr::Association &Assoc : E->associations()) { + TypeSourceInfo *TSI = Assoc.getTypeSourceInfo(); + if (TSI) { + TypeSourceInfo *AssocType = getDerived().TransformType(TSI); if (!AssocType) return ExprError(); AssocTypes.push_back(AssocType); @@ -9084,7 +9084,8 @@ TreeTransform::TransformGenericSelectionExpr(GenericSelectionExpr *E) { AssocTypes.push_back(nullptr); } - ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); + ExprResult AssocExpr = + getDerived().TransformExpr(Assoc.getAssociationExpr()); if (AssocExpr.isInvalid()) return ExprError(); AssocExprs.push_back(AssocExpr.get()); -- 2.40.0