From 99a226dde4004378ea3ebd92327dd7970451cb47 Mon Sep 17 00:00:00 2001 From: Argyrios Kyrtzidis Date: Mon, 28 Jun 2010 09:32:03 +0000 Subject: [PATCH] Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999 --- clang/include/clang/AST/ExprCXX.h | 21 +++++++++++++++++ clang/include/clang/Frontend/PCHBitCodes.h | 1 + clang/lib/Frontend/PCHReaderStmt.cpp | 26 ++++++++++++++++++++++ clang/lib/Frontend/PCHWriterStmt.cpp | 23 +++++++++++++++++++ 4 files changed, 71 insertions(+) diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h index 4305adbddca5..4514f96f083e 100644 --- a/clang/include/clang/AST/ExprCXX.h +++ b/clang/include/clang/AST/ExprCXX.h @@ -1223,6 +1223,10 @@ public: ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc), DestroyedType(DestroyedType) { } + explicit CXXPseudoDestructorExpr(EmptyShell Shell) + : Expr(CXXPseudoDestructorExprClass, Shell), + Base(0), IsArrow(false), Qualifier(0), ScopeType(0) { } + void setBase(Expr *E) { Base = E; } Expr *getBase() const { return cast(Base); } @@ -1235,11 +1239,13 @@ public: /// the nested-name-specifier that precedes the member name. Otherwise, /// returns an empty source range. SourceRange getQualifierRange() const { return QualifierRange; } + void setQualifierRange(SourceRange R) { QualifierRange = R; } /// \brief If the member name was qualified, retrieves the /// nested-name-specifier that precedes the member name. Otherwise, returns /// NULL. NestedNameSpecifier *getQualifier() const { return Qualifier; } + void setQualifier(NestedNameSpecifier *NNS) { Qualifier = NNS; } /// \brief Determine whether this pseudo-destructor expression was written /// using an '->' (otherwise, it used a '.'). @@ -1248,6 +1254,7 @@ public: /// \brief Retrieve the location of the '.' or '->' operator. SourceLocation getOperatorLoc() const { return OperatorLoc; } + void setOperatorLoc(SourceLocation L) { OperatorLoc = L; } /// \brief Retrieve the scope type in a qualified pseudo-destructor /// expression. @@ -1259,13 +1266,16 @@ public: /// nested-name-specifier. It is stored as the "scope type" of the pseudo- /// destructor expression. TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; } + void setScopeTypeInfo(TypeSourceInfo *Info) { ScopeType = Info; } /// \brief Retrieve the location of the '::' in a qualified pseudo-destructor /// expression. SourceLocation getColonColonLoc() const { return ColonColonLoc; } + void setColonColonLoc(SourceLocation L) { ColonColonLoc = L; } /// \brief Retrieve the location of the '~'. SourceLocation getTildeLoc() const { return TildeLoc; } + void setTildeLoc(SourceLocation L) { TildeLoc = L; } /// \brief Retrieve the source location information for the type /// being destroyed. @@ -1293,6 +1303,17 @@ public: return DestroyedType.getLocation(); } + /// \brief Set the name of destroyed type for a dependent pseudo-destructor + /// expression. + void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) { + DestroyedType = PseudoDestructorTypeStorage(II, Loc); + } + + /// \brief Set the destroyed type. + void setDestroyedType(TypeSourceInfo *Info) { + DestroyedType = PseudoDestructorTypeStorage(Info); + } + virtual SourceRange getSourceRange() const; static bool classof(const Stmt *T) { diff --git a/clang/include/clang/Frontend/PCHBitCodes.h b/clang/include/clang/Frontend/PCHBitCodes.h index 31864183d3fc..1635d4c83aa4 100644 --- a/clang/include/clang/Frontend/PCHBitCodes.h +++ b/clang/include/clang/Frontend/PCHBitCodes.h @@ -768,6 +768,7 @@ namespace clang { EXPR_CXX_ZERO_INIT_VALUE, // CXXZeroInitValueExpr EXPR_CXX_NEW, // CXXNewExpr EXPR_CXX_DELETE, // CXXDeleteExpr + EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr EXPR_CXX_EXPR_WITH_TEMPORARIES, // CXXExprWithTemporaries diff --git a/clang/lib/Frontend/PCHReaderStmt.cpp b/clang/lib/Frontend/PCHReaderStmt.cpp index 5f9ee3b25f8e..5f27a7da9a31 100644 --- a/clang/lib/Frontend/PCHReaderStmt.cpp +++ b/clang/lib/Frontend/PCHReaderStmt.cpp @@ -143,6 +143,7 @@ namespace { unsigned VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E); unsigned VisitCXXNewExpr(CXXNewExpr *E); unsigned VisitCXXDeleteExpr(CXXDeleteExpr *E); + unsigned VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); unsigned VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E); @@ -1146,6 +1147,28 @@ unsigned PCHStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) { return 1; } +unsigned +PCHStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { + VisitExpr(E); + + E->setBase(cast_or_null(StmtStack.back())); + E->setArrow(Record[Idx++]); + E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx)); + E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx)); + E->setQualifierRange(Reader.ReadSourceRange(Record, Idx)); + E->setScopeTypeInfo(Reader.GetTypeSourceInfo(Record, Idx)); + E->setColonColonLoc(Reader.ReadSourceLocation(Record, Idx)); + E->setTildeLoc(Reader.ReadSourceLocation(Record, Idx)); + + IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx); + if (II) + E->setDestroyedType(II, Reader.ReadSourceLocation(Record, Idx)); + else + E->setDestroyedType(Reader.GetTypeSourceInfo(Record, Idx)); + + return 1; +} + unsigned PCHStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { VisitExpr(E); unsigned NumTemps = Record[Idx++]; @@ -1646,6 +1669,9 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::EXPR_CXX_DELETE: S = new (Context) CXXDeleteExpr(Empty); break; + case pch::EXPR_CXX_PSEUDO_DESTRUCTOR: + S = new (Context) CXXPseudoDestructorExpr(Empty); + break; case pch::EXPR_CXX_EXPR_WITH_TEMPORARIES: S = new (Context) CXXExprWithTemporaries(Empty); diff --git a/clang/lib/Frontend/PCHWriterStmt.cpp b/clang/lib/Frontend/PCHWriterStmt.cpp index d3e1e1aab74e..fdc54072a912 100644 --- a/clang/lib/Frontend/PCHWriterStmt.cpp +++ b/clang/lib/Frontend/PCHWriterStmt.cpp @@ -134,6 +134,7 @@ namespace { void VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E); void VisitCXXNewExpr(CXXNewExpr *E); void VisitCXXDeleteExpr(CXXDeleteExpr *E); + void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E); void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); @@ -1062,6 +1063,28 @@ void PCHStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { Code = pch::EXPR_CXX_DELETE; } +void PCHStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { + VisitExpr(E); + + Writer.AddStmt(E->getBase()); + Record.push_back(E->isArrow()); + Writer.AddSourceLocation(E->getOperatorLoc(), Record); + Writer.AddNestedNameSpecifier(E->getQualifier(), Record); + Writer.AddSourceRange(E->getQualifierRange(), Record); + Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record); + Writer.AddSourceLocation(E->getColonColonLoc(), Record); + Writer.AddSourceLocation(E->getTildeLoc(), Record); + + // PseudoDestructorTypeStorage. + Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record); + if (E->getDestroyedTypeIdentifier()) + Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record); + else + Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record); + + Code = pch::EXPR_CXX_PSEUDO_DESTRUCTOR; +} + void PCHStmtWriter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { VisitExpr(E); Record.push_back(E->getNumTemporaries());