Prepare PCH reader and writer for (de-)serialization of statements. No

functionality change.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@69319 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 209 insertions, 200 deletions

diff --git a/include/clang/Frontend/PCHBitCodes.h b/include/clang/Frontend/PCHBitCodes.h
index c8b654c667..a218a5fcf6 100644
--- a/include/clang/Frontend/PCHBitCodes.h
+++ b/include/clang/Frontend/PCHBitCodes.h
@@ -372,9 +372,9 @@ namespace clang {
     enum StmtCode {
       /// \brief A marker record that indicates that we are at the end
       /// of an expression.
-      EXPR_STOP,
+      STMT_STOP,
       /// \brief A NULL expression.
-      EXPR_NULL,
+      STMT_NULL_PTR,
       /// \brief A PredefinedExpr record.
       EXPR_PREDEFINED,
       /// \brief A DeclRefExpr record.
diff --git a/include/clang/Frontend/PCHReader.h b/include/clang/Frontend/PCHReader.h
index 4cc4c24cc5..995a1d563f 100644
--- a/include/clang/Frontend/PCHReader.h
+++ b/include/clang/Frontend/PCHReader.h
@@ -235,6 +235,9 @@ public:
   /// \brief Reads an expression from the current stream position.
   Expr *ReadExpr();
 
+  /// \brief Reads a statement from the current stream position.
+  Stmt *ReadStmt();
+
   /// \brief Retrieve the AST context that this PCH reader
   /// supplements.
   ASTContext &getContext() { return Context; }
diff --git a/include/clang/Frontend/PCHWriter.h b/include/clang/Frontend/PCHWriter.h
index 0f9031f1c1..4af64e6ee1 100644
--- a/include/clang/Frontend/PCHWriter.h
+++ b/include/clang/Frontend/PCHWriter.h
@@ -48,7 +48,7 @@ public:
 
 private:
   /// \brief The bitstream writer used to emit this precompiled header.
-  llvm::BitstreamWriter &S;
+  llvm::BitstreamWriter &Stream;
 
   /// \brief Map that provides the ID numbers of each declaration within
   /// the output stream.
@@ -104,9 +104,9 @@ private:
   /// record.
   llvm::SmallVector<uint64_t, 16> ExternalDefinitions;
 
-  /// \brief Expressions that we've encountered while serializing a
+  /// \brief Statements that we've encountered while serializing a
   /// declaration or type.
-  llvm::SmallVector<Expr *, 8> ExprsToEmit;
+  llvm::SmallVector<Stmt *, 8> StmtsToEmit;
 
   void WriteTargetTriple(const TargetInfo &Target);
   void WriteLanguageOptions(const LangOptions &LangOpts);
@@ -125,7 +125,7 @@ private:
 public:
   /// \brief Create a new precompiled header writer that outputs to
   /// the given bitstream.
-  PCHWriter(llvm::BitstreamWriter &S);
+  PCHWriter(llvm::BitstreamWriter &Stream);
   
   /// \brief Write a precompiled header for the given AST context.
   void WritePCH(ASTContext &Context, const Preprocessor &PP);
@@ -154,22 +154,22 @@ public:
   /// \brief Emit a declaration name.
   void AddDeclarationName(DeclarationName Name, RecordData &Record);
 
-  /// \brief Add the given expression to the queue of expressions to
+  /// \brief Add the given statement or expression to the queue of statements to
   /// emit.
   ///
   /// This routine should be used when emitting types and declarations
   /// that have expressions as part of their formulation. Once the
-  /// type or declaration has been written, call FlushExprs() to write
-  /// the corresponding expressions just after the type or
+  /// type or declaration has been written, call FlushStmts() to write
+  /// the corresponding statements just after the type or
   /// declaration.
-  void AddExpr(Expr *E) { ExprsToEmit.push_back(E); }
+  void AddStmt(Stmt *S) { StmtsToEmit.push_back(S); }
 
   /// \brief Write the given subexpression to the bitstream.
-  void WriteSubExpr(Expr *E);
+  void WriteSubStmt(Stmt *S);
 
-  /// \brief Flush all of the expressions that have been added to the
-  /// queue via AddExpr().
-  void FlushExprs();
+  /// \brief Flush all of the statements and expressions that have
+  /// been added to the queue via AddStmt().
+  void FlushStmts();
 };
 
 } // end namespace clang
diff --git a/lib/Frontend/PCHReader.cpp b/lib/Frontend/PCHReader.cpp
index 0bc059ed66..ceba88049a 100644
--- a/lib/Frontend/PCHReader.cpp
+++ b/lib/Frontend/PCHReader.cpp
@@ -220,12 +220,12 @@ namespace {
     PCHReader &Reader;
     const PCHReader::RecordData &Record;
     unsigned &Idx;
-    llvm::SmallVectorImpl<Expr *> &ExprStack;
+    llvm::SmallVectorImpl<Stmt *> &StmtStack;
 
   public:
     PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record,
-                  unsigned &Idx, llvm::SmallVectorImpl<Expr *> &ExprStack)
-      : Reader(Reader), Record(Record), Idx(Idx), ExprStack(ExprStack) { }
+                  unsigned &Idx, llvm::SmallVectorImpl<Stmt *> &StmtStack)
+      : Reader(Reader), Record(Record), Idx(Idx), StmtStack(StmtStack) { }
 
     /// \brief The number of record fields required for the Expr class
     /// itself.
@@ -310,7 +310,7 @@ unsigned PCHStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
 
 unsigned PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
   VisitExpr(E);
-  E->setSubExpr(ExprStack.back());
+  E->setSubExpr(cast<Expr>(StmtStack.back()));
   return 1;
 }
 
@@ -346,13 +346,13 @@ unsigned PCHStmtReader::VisitParenExpr(ParenExpr *E) {
   VisitExpr(E);
   E->setLParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setRParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
-  E->setSubExpr(ExprStack.back());
+  E->setSubExpr(cast<Expr>(StmtStack.back()));
   return 1;
 }
 
 unsigned PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
-  E->setSubExpr(ExprStack.back());
+  E->setSubExpr(cast<Expr>(StmtStack.back()));
   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
   E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return 1;
@@ -362,7 +362,7 @@ unsigned PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
   VisitExpr(E);
   E->setSizeof(Record[Idx++]);
   if (Record[Idx] == 0) {
-    E->setArgument(ExprStack.back());
+    E->setArgument(cast<Expr>(StmtStack.back()));
     ++Idx;
   } else {
     E->setArgument(Reader.GetType(Record[Idx++]));
@@ -374,8 +374,8 @@ unsigned PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
 
 unsigned PCHStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
-  E->setLHS(ExprStack[ExprStack.size() - 2]);
-  E->setRHS(ExprStack[ExprStack.size() - 2]);
+  E->setLHS(cast<Expr>(StmtStack[StmtStack.size() - 2]));
+  E->setRHS(cast<Expr>(StmtStack[StmtStack.size() - 2]));
   E->setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return 2;
 }
@@ -384,15 +384,15 @@ unsigned PCHStmtReader::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   E->setNumArgs(Reader.getContext(), Record[Idx++]);
   E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
-  E->setCallee(ExprStack[ExprStack.size() - E->getNumArgs() - 1]);
+  E->setCallee(cast<Expr>(StmtStack[StmtStack.size() - E->getNumArgs() - 1]));
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
-    E->setArg(I, ExprStack[ExprStack.size() - N + I]);
+    E->setArg(I, cast<Expr>(StmtStack[StmtStack.size() - N + I]));
   return E->getNumArgs() + 1;
 }
 
 unsigned PCHStmtReader::VisitMemberExpr(MemberExpr *E) {
   VisitExpr(E);
-  E->setBase(ExprStack.back());
+  E->setBase(cast<Expr>(StmtStack.back()));
   E->setMemberDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
   E->setMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setArrow(Record[Idx++]);
@@ -401,14 +401,14 @@ unsigned PCHStmtReader::VisitMemberExpr(MemberExpr *E) {
 
 unsigned PCHStmtReader::VisitCastExpr(CastExpr *E) {
   VisitExpr(E);
-  E->setSubExpr(ExprStack.back());
+  E->setSubExpr(cast<Expr>(StmtStack.back()));
   return 1;
 }
 
 unsigned PCHStmtReader::VisitBinaryOperator(BinaryOperator *E) {
   VisitExpr(E);
-  E->setLHS(ExprStack.end()[-2]);
-  E->setRHS(ExprStack.end()[-1]);
+  E->setLHS(cast<Expr>(StmtStack.end()[-2]));
+  E->setRHS(cast<Expr>(StmtStack.end()[-1]));
   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
   E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return 2;
@@ -423,9 +423,9 @@ unsigned PCHStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 
 unsigned PCHStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
-  E->setCond(ExprStack[ExprStack.size() - 3]);
-  E->setLHS(ExprStack[ExprStack.size() - 2]);
-  E->setRHS(ExprStack[ExprStack.size() - 1]);
+  E->setCond(cast<Expr>(StmtStack[StmtStack.size() - 3]));
+  E->setLHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
+  E->setRHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 1]));
   return 3;
 }
 
@@ -451,14 +451,14 @@ unsigned PCHStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
 unsigned PCHStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
-  E->setInitializer(ExprStack.back());
+  E->setInitializer(cast<Expr>(StmtStack.back()));
   E->setFileScope(Record[Idx++]);
   return 1;
 }
 
 unsigned PCHStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   VisitExpr(E);
-  E->setBase(ExprStack.back());
+  E->setBase(cast<Expr>(StmtStack.back()));
   E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
   E->setAccessorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return 1;
@@ -469,8 +469,9 @@ unsigned PCHStmtReader::VisitInitListExpr(InitListExpr *E) {
   unsigned NumInits = Record[Idx++];
   E->reserveInits(NumInits);
   for (unsigned I = 0; I != NumInits; ++I)
-    E->updateInit(I, ExprStack[ExprStack.size() - NumInits - 1 + I]);
-  E->setSyntacticForm(cast_or_null<InitListExpr>(ExprStack.back()));
+    E->updateInit(I, 
+                  cast<Expr>(StmtStack[StmtStack.size() - NumInits - 1 + I]));
+  E->setSyntacticForm(cast_or_null<InitListExpr>(StmtStack.back()));
   E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setInitializedFieldInUnion(
@@ -486,7 +487,7 @@ unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
   unsigned NumSubExprs = Record[Idx++];
   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
   for (unsigned I = 0; I != NumSubExprs; ++I)
-    E->setSubExpr(I, ExprStack[ExprStack.size() - NumSubExprs + I]);
+    E->setSubExpr(I, cast<Expr>(StmtStack[StmtStack.size() - NumSubExprs + I]));
   E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setGNUSyntax(Record[Idx++]);
 
@@ -551,7 +552,7 @@ unsigned PCHStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 
 unsigned PCHStmtReader::VisitVAArgExpr(VAArgExpr *E) {
   VisitExpr(E);
-  E->setSubExpr(ExprStack.back());
+  E->setSubExpr(cast<Expr>(StmtStack.back()));
   E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return 1;
@@ -568,9 +569,9 @@ unsigned PCHStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
 
 unsigned PCHStmtReader::VisitChooseExpr(ChooseExpr *E) {
   VisitExpr(E);
-  E->setCond(ExprStack[ExprStack.size() - 3]);
-  E->setLHS(ExprStack[ExprStack.size() - 2]);
-  E->setRHS(ExprStack[ExprStack.size() - 1]);
+  E->setCond(cast<Expr>(StmtStack[StmtStack.size() - 3]));
+  E->setLHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 2]));
+  E->setRHS(cast_or_null<Expr>(StmtStack[StmtStack.size() - 1]));
   E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return 3;
@@ -585,7 +586,7 @@ unsigned PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
 unsigned PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   unsigned NumExprs = Record[Idx++];
-  E->setExprs(&ExprStack[ExprStack.size() - NumExprs], NumExprs);
+  E->setExprs((Expr **)&StmtStack[StmtStack.size() - NumExprs], NumExprs);
   E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
   return NumExprs;
@@ -1982,18 +1983,18 @@ Attr *PCHReader::ReadAttributes() {
   return PrevAttr;
 }
 
-Expr *PCHReader::ReadExpr() {
+Stmt *PCHReader::ReadStmt() {
   // Within the bitstream, expressions are stored in Reverse Polish
   // Notation, with each of the subexpressions preceding the
   // expression they are stored in. To evaluate expressions, we
   // continue reading expressions and placing them on the stack, with
   // expressions having operands removing those operands from the
-  // stack. Evaluation terminates when we see a EXPR_STOP record, and
+  // stack. Evaluation terminates when we see a STMT_STOP record, and
   // the single remaining expression on the stack is our result.
   RecordData Record;
   unsigned Idx;
-  llvm::SmallVector<Expr *, 16> ExprStack;
-  PCHStmtReader Reader(*this, Record, Idx, ExprStack);
+  llvm::SmallVector<Stmt *, 16> StmtStack;
+  PCHStmtReader Reader(*this, Record, Idx, StmtStack);
   Stmt::EmptyShell Empty;
 
   while (true) {
@@ -2021,159 +2022,163 @@ Expr *PCHReader::ReadExpr() {
       continue;
     }
 
-    Expr *E = 0;
+    Stmt *S = 0;
     Idx = 0;
     Record.clear();
     bool Finished = false;
     switch ((pch::StmtCode)Stream.ReadRecord(Code, Record)) {
-    case pch::EXPR_STOP:
+    case pch::STMT_STOP:
       Finished = true;
       break;
 
-    case pch::EXPR_NULL: 
-      E = 0; 
+    case pch::STMT_NULL_PTR: 
+      S = 0; 
       break;
 
     case pch::EXPR_PREDEFINED:
       // FIXME: untested (until we can serialize function bodies).
-      E = new (Context) PredefinedExpr(Empty);
+      S = new (Context) PredefinedExpr(Empty);
       break;
       
     case pch::EXPR_DECL_REF: 
-      E = new (Context) DeclRefExpr(Empty); 
+      S = new (Context) DeclRefExpr(Empty); 
       break;
       
     case pch::EXPR_INTEGER_LITERAL: 
-      E = new (Context) IntegerLiteral(Empty);
+      S = new (Context) IntegerLiteral(Empty);
       break;
       
     case pch::EXPR_FLOATING_LITERAL:
-      E = new (Context) FloatingLiteral(Empty);
+      S = new (Context) FloatingLiteral(Empty);
       break;
       
     case pch::EXPR_IMAGINARY_LITERAL:
-      E = new (Context) ImaginaryLiteral(Empty);
+      S = new (Context) ImaginaryLiteral(Empty);
       break;
 
     case pch::EXPR_STRING_LITERAL:
-      E = StringLiteral::CreateEmpty(Context, 
+      S = StringLiteral::CreateEmpty(Context, 
                                      Record[PCHStmtReader::NumExprFields + 1]);
       break;
 
     case pch::EXPR_CHARACTER_LITERAL:
-      E = new (Context) CharacterLiteral(Empty);
+      S = new (Context) CharacterLiteral(Empty);
       break;
 
     case pch::EXPR_PAREN:
-      E = new (Context) ParenExpr(Empty);
+      S = new (Context) ParenExpr(Empty);
       break;
 
     case pch::EXPR_UNARY_OPERATOR:
-      E = new (Context) UnaryOperator(Empty);
+      S = new (Context) UnaryOperator(Empty);
       break;
 
     case pch::EXPR_SIZEOF_ALIGN_OF:
-      E = new (Context) SizeOfAlignOfExpr(Empty);
+      S = new (Context) SizeOfAlignOfExpr(Empty);
       break;
 
     case pch::EXPR_ARRAY_SUBSCRIPT:
-      E = new (Context) ArraySubscriptExpr(Empty);
+      S = new (Context) ArraySubscriptExpr(Empty);
       break;
 
     case pch::EXPR_CALL:
-      E = new (Context) CallExpr(Context, Empty);
+      S = new (Context) CallExpr(Context, Empty);
       break;
 
     case pch::EXPR_MEMBER:
-      E = new (Context) MemberExpr(Empty);
+      S = new (Context) MemberExpr(Empty);
       break;
 
     case pch::EXPR_BINARY_OPERATOR:
-      E = new (Context) BinaryOperator(Empty);
+      S = new (Context) BinaryOperator(Empty);
       break;
 
     case pch::EXPR_COMPOUND_ASSIGN_OPERATOR:
-      E = new (Context) CompoundAssignOperator(Empty);
+      S = new (Context) CompoundAssignOperator(Empty);
       break;
 
     case pch::EXPR_CONDITIONAL_OPERATOR:
-      E = new (Context) ConditionalOperator(Empty);
+      S = new (Context) ConditionalOperator(Empty);
       break;
 
     case pch::EXPR_IMPLICIT_CAST:
-      E = new (Context) ImplicitCastExpr(Empty);
+      S = new (Context) ImplicitCastExpr(Empty);
       break;
 
     case pch::EXPR_CSTYLE_CAST:
-      E = new (Context) CStyleCastExpr(Empty);
+      S = new (Context) CStyleCastExpr(Empty);
       break;
 
     case pch::EXPR_COMPOUND_LITERAL:
-      E = new (Context) CompoundLiteralExpr(Empty);
+      S = new (Context) CompoundLiteralExpr(Empty);
       break;
 
     case pch::EXPR_EXT_VECTOR_ELEMENT:
-      E = new (Context) ExtVectorElementExpr(Empty);
+      S = new (Context) ExtVectorElementExpr(Empty);
       break;
 
     case pch::EXPR_INIT_LIST:
-      E = new (Context) InitListExpr(Empty);
+      S = new (Context) InitListExpr(Empty);
       break;
 
     case pch::EXPR_DESIGNATED_INIT:
-      E = DesignatedInitExpr::CreateEmpty(Context, 
+      S = DesignatedInitExpr::CreateEmpty(Context, 
                                      Record[PCHStmtReader::NumExprFields] - 1);
      
       break;
 
     case pch::EXPR_IMPLICIT_VALUE_INIT:
-      E = new (Context) ImplicitValueInitExpr(Empty);
+      S = new (Context) ImplicitValueInitExpr(Empty);
       break;
 
     case pch::EXPR_VA_ARG:
       // FIXME: untested; we need function bodies first
-      E = new (Context) VAArgExpr(Empty);
+      S = new (Context) VAArgExpr(Empty);
       break;
 
     case pch::EXPR_TYPES_COMPATIBLE:
-      E = new (Context) TypesCompatibleExpr(Empty);
+      S = new (Context) TypesCompatibleExpr(Empty);
       break;
 
     case pch::EXPR_CHOOSE:
-      E = new (Context) ChooseExpr(Empty);
+      S = new (Context) ChooseExpr(Empty);
       break;
 
     case pch::EXPR_GNU_NULL:
-      E = new (Context) GNUNullExpr(Empty);
+      S = new (Context) GNUNullExpr(Empty);
       break;
 
     case pch::EXPR_SHUFFLE_VECTOR:
-      E = new (Context) ShuffleVectorExpr(Empty);
+      S = new (Context) ShuffleVectorExpr(Empty);
       break;
       
     case pch::EXPR_BLOCK_DECL_REF:
       // FIXME: untested until we have statement and block support
-      E = new (Context) BlockDeclRefExpr(Empty);
+      S = new (Context) BlockDeclRefExpr(Empty);
       break;
     }
 
-    // We hit an EXPR_STOP, so we're done with this expression.
+    // We hit a STMT_STOP, so we're done with this expression.
     if (Finished)
       break;
 
-    if (E) {
-      unsigned NumSubExprs = Reader.Visit(E);
-      while (NumSubExprs > 0) {
-        ExprStack.pop_back();
-        --NumSubExprs;
+    if (S) {
+      unsigned NumSubStmts = Reader.Visit(S);
+      while (NumSubStmts > 0) {
+        StmtStack.pop_back();
+        --NumSubStmts;
       }
     }
 
     assert(Idx == Record.size() && "Invalid deserialization of expression");
-    ExprStack.push_back(E);
+    StmtStack.push_back(S);
   }
-  assert(ExprStack.size() == 1 && "Extra expressions on stack!");
-  return ExprStack.back();
+  assert(StmtStack.size() == 1 && "Extra expressions on stack!");
+  return StmtStack.back();
+}
+
+Expr *PCHReader::ReadExpr() {
+  return dyn_cast_or_null<Expr>(ReadStmt());
 }
 
 DiagnosticBuilder PCHReader::Diag(unsigned DiagID) {
diff --git a/lib/Frontend/PCHWriter.cpp b/lib/Frontend/PCHWriter.cpp
index 8adabafae1..056aeec2d7 100644
--- a/lib/Frontend/PCHWriter.cpp
+++ b/lib/Frontend/PCHWriter.cpp
@@ -126,7 +126,7 @@ void PCHTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
 
 void PCHTypeWriter::VisitVariableArrayType(const VariableArrayType *T) {
   VisitArrayType(T);
-  Writer.AddExpr(T->getSizeExpr());
+  Writer.AddStmt(T->getSizeExpr());
   Code = pch::TYPE_VARIABLE_ARRAY;
 }
 
@@ -166,7 +166,7 @@ void PCHTypeWriter::VisitTypedefType(const TypedefType *T) {
 }
 
 void PCHTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) {
-  Writer.AddExpr(T->getUnderlyingExpr());
+  Writer.AddStmt(T->getUnderlyingExpr());
   Code = pch::TYPE_TYPEOF_EXPR;
 }
 
@@ -331,7 +331,7 @@ void PCHDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   VisitValueDecl(D);
   Record.push_back(D->getInitExpr()? 1 : 0);
   if (D->getInitExpr())
-    Writer.AddExpr(D->getInitExpr());
+    Writer.AddStmt(D->getInitExpr());
   Writer.AddAPSInt(D->getInitVal(), Record);
   Code = pch::DECL_ENUM_CONSTANT;
 }
@@ -360,7 +360,7 @@ void PCHDeclWriter::VisitFieldDecl(FieldDecl *D) {
   Record.push_back(D->isMutable());
   Record.push_back(D->getBitWidth()? 1 : 0);
   if (D->getBitWidth())
-    Writer.AddExpr(D->getBitWidth());
+    Writer.AddStmt(D->getBitWidth());
   Code = pch::DECL_FIELD;
 }
 
@@ -374,7 +374,7 @@ void PCHDeclWriter::VisitVarDecl(VarDecl *D) {
   Writer.AddSourceLocation(D->getTypeSpecStartLoc(), Record);
   Record.push_back(D->getInit()? 1 : 0);
   if (D->getInit())
-    Writer.AddExpr(D->getInit());
+    Writer.AddStmt(D->getInit());
   Code = pch::DECL_VAR;
 }
 
@@ -395,7 +395,7 @@ void PCHDeclWriter::VisitOriginalParmVarDecl(OriginalParmVarDecl *D) {
 
 void PCHDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
   VisitDecl(D);
-  Writer.AddExpr(D->getAsmString());
+  Writer.AddStmt(D->getAsmString());
   Code = pch::DECL_FILE_SCOPE_ASM;
 }
 
@@ -515,7 +515,7 @@ void PCHStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
 
 void PCHStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getSubExpr());
+  Writer.WriteSubStmt(E->getSubExpr());
   Code = pch::EXPR_IMAGINARY_LITERAL;
 }
 
@@ -547,13 +547,13 @@ void PCHStmtWriter::VisitParenExpr(ParenExpr *E) {
   VisitExpr(E);
   Writer.AddSourceLocation(E->getLParen(), Record);
   Writer.AddSourceLocation(E->getRParen(), Record);
-  Writer.WriteSubExpr(E->getSubExpr());
+  Writer.WriteSubStmt(E->getSubExpr());
   Code = pch::EXPR_PAREN;
 }
 
 void PCHStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getSubExpr());
+  Writer.WriteSubStmt(E->getSubExpr());
   Record.push_back(E->getOpcode()); // FIXME: stable encoding
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Code = pch::EXPR_UNARY_OPERATOR;
@@ -566,7 +566,7 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
     Writer.AddTypeRef(E->getArgumentType(), Record);
   else {
     Record.push_back(0);
-    Writer.WriteSubExpr(E->getArgumentExpr());
+    Writer.WriteSubStmt(E->getArgumentExpr());
   }
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
@@ -575,8 +575,8 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
 
 void PCHStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getLHS());
-  Writer.WriteSubExpr(E->getRHS());
+  Writer.WriteSubStmt(E->getLHS());
+  Writer.WriteSubStmt(E->getRHS());
   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
   Code = pch::EXPR_ARRAY_SUBSCRIPT;
 }
@@ -585,16 +585,16 @@ void PCHStmtWriter::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
-  Writer.WriteSubExpr(E->getCallee());
+  Writer.WriteSubStmt(E->getCallee());
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
-    Writer.WriteSubExpr(*Arg);
+    Writer.WriteSubStmt(*Arg);
   Code = pch::EXPR_CALL;
 }
 
 void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getBase());
+  Writer.WriteSubStmt(E->getBase());
   Writer.AddDeclRef(E->getMemberDecl(), Record);
   Writer.AddSourceLocation(E->getMemberLoc(), Record);
   Record.push_back(E->isArrow());
@@ -603,13 +603,13 @@ void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) {
 
 void PCHStmtWriter::VisitCastExpr(CastExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getSubExpr());
+  Writer.WriteSubStmt(E->getSubExpr());
 }
 
 void PCHStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getLHS());
-  Writer.WriteSubExpr(E->getRHS());
+  Writer.WriteSubStmt(E->getLHS());
+  Writer.WriteSubStmt(E->getRHS());
   Record.push_back(E->getOpcode()); // FIXME: stable encoding
   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
   Code = pch::EXPR_BINARY_OPERATOR;
@@ -624,9 +624,9 @@ void PCHStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 
 void PCHStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getCond());
-  Writer.WriteSubExpr(E->getLHS());
-  Writer.WriteSubExpr(E->getRHS());
+  Writer.WriteSubStmt(E->getCond());
+  Writer.WriteSubStmt(E->getLHS());
+  Writer.WriteSubStmt(E->getRHS());
   Code = pch::EXPR_CONDITIONAL_OPERATOR;
 }
 
@@ -651,14 +651,14 @@ void PCHStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
 void PCHStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   Writer.AddSourceLocation(E->getLParenLoc(), Record);
-  Writer.WriteSubExpr(E->getInitializer());
+  Writer.WriteSubStmt(E->getInitializer());
   Record.push_back(E->isFileScope());
   Code = pch::EXPR_COMPOUND_LITERAL;
 }
 
 void PCHStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getBase());
+  Writer.WriteSubStmt(E->getBase());
   Writer.AddIdentifierRef(&E->getAccessor(), Record);
   Writer.AddSourceLocation(E->getAccessorLoc(), Record);
   Code = pch::EXPR_EXT_VECTOR_ELEMENT;
@@ -668,8 +668,8 @@ void PCHStmtWriter::VisitInitListExpr(InitListExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumInits());
   for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
-    Writer.WriteSubExpr(E->getInit(I));
-  Writer.WriteSubExpr(E->getSyntacticForm());
+    Writer.WriteSubStmt(E->getInit(I));
+  Writer.WriteSubStmt(E->getSyntacticForm());
   Writer.AddSourceLocation(E->getLBraceLoc(), Record);
   Writer.AddSourceLocation(E->getRBraceLoc(), Record);
   Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
@@ -681,7 +681,7 @@ void PCHStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumSubExprs());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
-    Writer.WriteSubExpr(E->getSubExpr(I));
+    Writer.WriteSubStmt(E->getSubExpr(I));
   Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
   Record.push_back(E->usesGNUSyntax());
   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
@@ -721,7 +721,7 @@ void PCHStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 
 void PCHStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getSubExpr());
+  Writer.WriteSubStmt(E->getSubExpr());
   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_VA_ARG;
@@ -738,9 +738,9 @@ void PCHStmtWriter::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
 
 void PCHStmtWriter::VisitChooseExpr(ChooseExpr *E) {
   VisitExpr(E);
-  Writer.WriteSubExpr(E->getCond());
-  Writer.WriteSubExpr(E->getLHS());
-  Writer.WriteSubExpr(E->getRHS());
+  Writer.WriteSubStmt(E->getCond());
+  Writer.WriteSubStmt(E->getLHS());
+  Writer.WriteSubStmt(E->getRHS());
   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_CHOOSE;
@@ -756,7 +756,7 @@ void PCHStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumSubExprs());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
-    Writer.WriteSubExpr(E->getExpr(I));
+    Writer.WriteSubStmt(E->getExpr(I));
   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
   Writer.AddSourceLocation(E->getRParenLoc(), Record);
   Code = pch::EXPR_SHUFFLE_VECTOR;
@@ -780,12 +780,12 @@ void PCHWriter::WriteTargetTriple(const TargetInfo &Target) {
   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(pch::TARGET_TRIPLE));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Triple name
-  unsigned TripleAbbrev = S.EmitAbbrev(Abbrev);
+  unsigned TripleAbbrev = Stream.EmitAbbrev(Abbrev);
 
   RecordData Record;
   Record.push_back(pch::TARGET_TRIPLE);
   const char *Triple = Target.getTargetTriple();
-  S.EmitRecordWithBlob(TripleAbbrev, Record, Triple, strlen(Triple));
+  Stream.EmitRecordWithBlob(TripleAbbrev, Record, Triple, strlen(Triple));
 }
 
 /// \brief Write the LangOptions structure.
@@ -847,7 +847,7 @@ void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
   Record.push_back(LangOpts.getGCMode());
   Record.push_back(LangOpts.getVisibilityMode());
   Record.push_back(LangOpts.InstantiationDepth);
-  S.EmitRecord(pch::LANGUAGE_OPTIONS, Record);
+  Stream.EmitRecord(pch::LANGUAGE_OPTIONS, Record);
 }
 
 //===----------------------------------------------------------------------===//
@@ -856,7 +856,7 @@ void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
 
 /// \brief Create an abbreviation for the SLocEntry that refers to a
 /// file.
-static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &S) {
+static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) {
   using namespace llvm;
   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_FILE_ENTRY));
@@ -865,12 +865,12 @@ static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &S) {
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name
-  return S.EmitAbbrev(Abbrev);
+  return Stream.EmitAbbrev(Abbrev);
 }
 
 /// \brief Create an abbreviation for the SLocEntry that refers to a
 /// buffer.
-static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &S) {
+static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) {
   using namespace llvm;
   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_BUFFER_ENTRY));
@@ -879,22 +879,22 @@ static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &S) {
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob
-  return S.EmitAbbrev(Abbrev);
+  return Stream.EmitAbbrev(Abbrev);
 }
 
 /// \brief Create an abbreviation for the SLocEntry that refers to a
 /// buffer's blob.
-static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &S) {
+static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) {
   using namespace llvm;
   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_BUFFER_BLOB));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob
-  return S.EmitAbbrev(Abbrev);
+  return Stream.EmitAbbrev(Abbrev);
 }
 
 /// \brief Create an abbreviation for the SLocEntry that refers to an
 /// buffer.
-static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &S) {
+static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &Stream) {
   using namespace llvm;
   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_INSTANTIATION_ENTRY));
@@ -903,7 +903,7 @@ static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &S) {
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length
-  return S.EmitAbbrev(Abbrev);
+  return Stream.EmitAbbrev(Abbrev);
 }
 
 /// \brief Writes the block containing the serialized form of the
@@ -916,7 +916,7 @@ static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &S) {
 /// the files in the AST.
 void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) {
   // Enter the source manager block.
-  S.EnterSubblock(pch::SOURCE_MANAGER_BLOCK_ID, 3);
+  Stream.EnterSubblock(pch::SOURCE_MANAGER_BLOCK_ID, 3);
 
   // Abbreviations for the various kinds of source-location entries.
   int SLocFileAbbrv = -1;
@@ -954,16 +954,16 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) {
         // The source location entry is a file. The blob associated
         // with this entry is the file name.
         if (SLocFileAbbrv == -1)
-          SLocFileAbbrv = CreateSLocFileAbbrev(S);
-        S.EmitRecordWithBlob(SLocFileAbbrv, Record,
+          SLocFileAbbrv = CreateSLocFileAbbrev(Stream);
+        Stream.EmitRecordWithBlob(SLocFileAbbrv, Record,
                              Content->Entry->getName(),
                              strlen(Content->Entry->getName()));
       } else {
         // The source location entry is a buffer. The blob associated
         // with this entry contains the contents of the buffer.
         if (SLocBufferAbbrv == -1) {
-          SLocBufferAbbrv = CreateSLocBufferAbbrev(S);
-          SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(S);
+          SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream);
+          SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream);
         }
 
         // We add one to the size so that we capture the trailing NULL
@@ -971,10 +971,10 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) {
         // the reader side).
         const llvm::MemoryBuffer *Buffer = Content->getBuffer();
         const char *Name = Buffer->getBufferIdentifier();
-        S.EmitRecordWithBlob(SLocBufferAbbrv, Record, Name, strlen(Name) + 1);
+        Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, Name, strlen(Name) + 1);
         Record.clear();
         Record.push_back(pch::SM_SLOC_BUFFER_BLOB);
-        S.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
+        Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record,
                              Buffer->getBufferStart(),
                              Buffer->getBufferSize() + 1);
       }
@@ -993,8 +993,8 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) {
       Record.push_back(NextOffset - SLoc->getOffset() - 1);
 
       if (SLocInstantiationAbbrv == -1)
-        SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(S);
-      S.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record);
+        SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(Stream);
+      Stream.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record);
     }
 
     Record.clear();
@@ -1032,11 +1032,11 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) {
         Record.push_back((unsigned)LE->FileKind);
         Record.push_back(LE->IncludeOffset);
       }
-      S.EmitRecord(pch::SM_LINE_TABLE, Record);
+      Stream.EmitRecord(pch::SM_LINE_TABLE, Record);
     }
   }
 
-  S.ExitBlock();
+  Stream.ExitBlock();
 }
 
 /// \brief Writes the block containing the serialized form of the
@@ -1044,7 +1044,7 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) {
 ///
 void PCHWriter::WritePreprocessor(const Preprocessor &PP) {
   // Enter the preprocessor block.
-  S.EnterSubblock(pch::PREPROCESSOR_BLOCK_ID, 3);
+  Stream.EnterSubblock(pch::PREPROCESSOR_BLOCK_ID, 3);
   
   // If the PCH file contains __DATE__ or __TIME__ emit a warning about this.
   // FIXME: use diagnostics subsystem for localization etc.
@@ -1056,7 +1056,7 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) {
   // If the preprocessor __COUNTER__ value has been bumped, remember it.
   if (PP.getCounterValue() != 0) {
     Record.push_back(PP.getCounterValue());
-    S.EmitRecord(pch::PP_COUNTER_VALUE, Record);
+    Stream.Em