Rename PCHWriter to ASTWriter

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

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 4a9f10a8707e34d124cea2cbd01bc8338723d718..8313e773f58c9ec5bc1298dccfbccef6cc981625 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1040,7 +1040,7 @@ public:
   static bool classof(const Type *) { return true; }
 
   friend class PCHReader;
-  friend class PCHWriter;
+  friend class ASTWriter;
 };
 
 template <> inline const TypedefType *Type::getAs() const {

diff --git a/include/clang/Serialization/PCHWriter.h b/include/clang/Serialization/PCHWriter.h
index cf81cb98231747457ca82d8a4e0544fc372df186..3ecde5691814ea93b75250a198dcf54e7f27fbc2 100644 (file)
--- a/include/clang/Serialization/PCHWriter.h
+++ b/include/clang/Serialization/PCHWriter.h
@@ -1,4 +1,4 @@
-//===--- PCHWriter.h - Precompiled Headers Writer ---------------*- C++ -*-===//
+//===--- PCHWriter.h - AST File Writer --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines the PCHWriter class, which writes a precompiled
+//  This file defines the ASTWriter class, which writes a precompiled
 //  header containing a serialized representation of a translation
 //  unit.
 //
@@ -69,14 +69,13 @@ struct UnsafeQualTypeDenseMapInfo {
   }
 };
 
-/// \brief Writes a precompiled header containing the contents of a
-/// translation unit.
+/// \brief Writes an AST file containing the contents of a translation unit.
 ///
-/// The PCHWriter class produces a bitstream containing the serialized
+/// The ASTWriter class produces a bitstream containing the serialized
 /// representation of a given abstract syntax tree and its supporting
 /// data structures. This bitstream can be de-serialized via an
 /// instance of the PCHReader class.
-class PCHWriter : public PCHDeserializationListener {
+class ASTWriter : public PCHDeserializationListener {
 public:
   typedef llvm::SmallVector<uint64_t, 64> RecordData;
 
@@ -239,7 +238,7 @@ private:
   /// declaration or type.
   llvm::SmallVector<Stmt *, 16> StmtsToEmit;
 
-  /// \brief Statements collection to use for PCHWriter::AddStmt().
+  /// \brief Statements collection to use for ASTWriter::AddStmt().
   /// It will point to StmtsToEmit unless it is overriden. 
   llvm::SmallVector<Stmt *, 16> *CollectedStmts;
 
@@ -289,15 +288,15 @@ private:
   void WriteDeclsBlockAbbrevs();
   void WriteDecl(ASTContext &Context, Decl *D);
 
-  void WritePCHCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
+  void WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
                     const char* isysroot);
-  void WritePCHChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
+  void WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
                      const char* isysroot);
   
 public:
   /// \brief Create a new precompiled header writer that outputs to
   /// the given bitstream.
-  PCHWriter(llvm::BitstreamWriter &Stream);
+  ASTWriter(llvm::BitstreamWriter &Stream);
 
   /// \brief Write a precompiled header for the given semantic analysis.
   ///
@@ -312,7 +311,7 @@ public:
   ///
   /// \param PPRec Record of the preprocessing actions that occurred while
   /// preprocessing this file, e.g., macro instantiations
-  void WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls,
+  void WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls,
                 const char* isysroot);
 
   /// \brief Emit a source location.
@@ -479,11 +478,11 @@ class PCHGenerator : public SemaConsumer {
   MemorizeStatCalls *StatCalls; // owned by the FileManager
   std::vector<unsigned char> Buffer;
   llvm::BitstreamWriter Stream;
-  PCHWriter Writer;
+  ASTWriter Writer;
 
 protected:
-  PCHWriter &getWriter() { return Writer; }
-  const PCHWriter &getWriter() const { return Writer; }
+  ASTWriter &getWriter() { return Writer; }
+  const ASTWriter &getWriter() const { return Writer; }
 
 public:
   PCHGenerator(const Preprocessor &PP, bool Chaining,

diff --git a/lib/Frontend/ASTUnit.cpp b/lib/Frontend/ASTUnit.cpp
index f68940446099385f03e7089ac56955d63754fab3..9d4419d76ebfdfb6946a9b97a863c53242309642 100644 (file)
--- a/lib/Frontend/ASTUnit.cpp
+++ b/lib/Frontend/ASTUnit.cpp
@@ -1789,8 +1789,8 @@ bool ASTUnit::Save(llvm::StringRef File) {
   
   std::vector<unsigned char> Buffer;
   llvm::BitstreamWriter Stream(Buffer);
-  PCHWriter Writer(Stream);
-  Writer.WritePCH(getSema(), 0, 0);
+  ASTWriter Writer(Stream);
+  Writer.WriteAST(getSema(), 0, 0);
   
   // Write the generated bitstream to "Out".
   if (!Buffer.empty())

diff --git a/lib/Serialization/GeneratePCH.cpp b/lib/Serialization/GeneratePCH.cpp
index 55eaa9c084047f15d6f8c66a93798f0e0dd92386..7f51fb5d56a6761cee995e28ee9aa877d0d1dd52 100644 (file)
--- a/lib/Serialization/GeneratePCH.cpp
+++ b/lib/Serialization/GeneratePCH.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the CreatePCHGenerate function, which creates an
-//  ASTConsume that generates a PCH file.
+//  ASTConsumeR that generates a PCH file.
 //
 //===----------------------------------------------------------------------===//
 
@@ -47,7 +47,7 @@ void PCHGenerator::HandleTranslationUnit(ASTContext &Ctx) {
 
   // Emit the PCH file
   assert(SemaPtr && "No Sema?");
-  Writer.WritePCH(*SemaPtr, StatCalls, isysroot);
+  Writer.WriteAST(*SemaPtr, StatCalls, isysroot);
 
   // Write the generated bitstream to "Out".
   Out->write((char *)&Buffer.front(), Buffer.size());

diff --git a/lib/Serialization/PCHWriter.cpp b/lib/Serialization/PCHWriter.cpp
index f78a8ba23bdf6c1a85e05f58124e0dc657e747c8..e20fa3b2999dad1d814d3be357c5874d3a97d0d4 100644 (file)
--- a/lib/Serialization/PCHWriter.cpp
+++ b/lib/Serialization/PCHWriter.cpp
@@ -1,4 +1,4 @@
-//===--- PCHWriter.cpp - Precompiled Headers Writer -----------------------===//
+//===--- PCHWriter.cpp - AST File Writer ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines the PCHWriter class, which writes a precompiled header.
+//  This file defines the ASTWriter class, which writes AST files.
 //
 //===----------------------------------------------------------------------===//
 
@@ -55,14 +55,14 @@ const T *data(const std::vector<T, Allocator> &v) {
 
 namespace {
   class PCHTypeWriter {
-    PCHWriter &Writer;
-    PCHWriter::RecordData &Record;
+    ASTWriter &Writer;
+    ASTWriter::RecordData &Record;
 
   public:
     /// \brief Type code that corresponds to the record generated.
     pch::TypeCode Code;
 
-    PCHTypeWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
+    PCHTypeWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
       : Writer(Writer), Record(Record), Code(pch::TYPE_EXT_QUAL) { }
 
     void VisitArrayType(const ArrayType *T);
@@ -327,11 +327,11 @@ PCHTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
 namespace {
 
 class TypeLocWriter : public TypeLocVisitor<TypeLocWriter> {
-  PCHWriter &Writer;
-  PCHWriter::RecordData &Record;
+  ASTWriter &Writer;
+  ASTWriter::RecordData &Record;
 
 public:
-  TypeLocWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
+  TypeLocWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
     : Writer(Writer), Record(Record) { }
 
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
@@ -497,12 +497,12 @@ void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
 }
 
 //===----------------------------------------------------------------------===//
-// PCHWriter Implementation
+// ASTWriter Implementation
 //===----------------------------------------------------------------------===//
 
 static void EmitBlockID(unsigned ID, const char *Name,
                         llvm::BitstreamWriter &Stream,
-                        PCHWriter::RecordData &Record) {
+                        ASTWriter::RecordData &Record) {
   Record.clear();
   Record.push_back(ID);
   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
@@ -517,7 +517,7 @@ static void EmitBlockID(unsigned ID, const char *Name,
 
 static void EmitRecordID(unsigned ID, const char *Name,
                          llvm::BitstreamWriter &Stream,
-                         PCHWriter::RecordData &Record) {
+                         ASTWriter::RecordData &Record) {
   Record.clear();
   Record.push_back(ID);
   while (*Name)
@@ -526,7 +526,7 @@ static void EmitRecordID(unsigned ID, const char *Name,
 }
 
 static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
-                          PCHWriter::RecordData &Record) {
+                          ASTWriter::RecordData &Record) {
 #define RECORD(X) EmitRecordID(pch::X, #X, Stream, Record)
   RECORD(STMT_STOP);
   RECORD(STMT_NULL_PTR);
@@ -606,7 +606,7 @@ static void AddStmtsExprs(llvm::BitstreamWriter &Stream,
 #undef RECORD
 }
 
-void PCHWriter::WriteBlockInfoBlock() {
+void ASTWriter::WriteBlockInfoBlock() {
   RecordData Record;
   Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3);
 
@@ -752,7 +752,7 @@ adjustFilenameForRelocatablePCH(const char *Filename, const char *isysroot) {
 }
 
 /// \brief Write the PCH metadata (e.g., i686-apple-darwin9).
-void PCHWriter::WriteMetadata(ASTContext &Context, const char *isysroot) {
+void ASTWriter::WriteMetadata(ASTContext &Context, const char *isysroot) {
   using namespace llvm;
 
   // Metadata
@@ -812,7 +812,7 @@ void PCHWriter::WriteMetadata(ASTContext &Context, const char *isysroot) {
 }
 
 /// \brief Write the LangOptions structure.
-void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
+void ASTWriter::WriteLanguageOptions(const LangOptions &LangOpts) {
   RecordData Record;
   Record.push_back(LangOpts.Trigraphs);
   Record.push_back(LangOpts.BCPLComment);  // BCPL-style '//' comments.
@@ -942,7 +942,7 @@ public:
 } // end anonymous namespace
 
 /// \brief Write the stat() system call cache to the PCH file.
-void PCHWriter::WriteStatCache(MemorizeStatCalls &StatCalls) {
+void ASTWriter::WriteStatCache(MemorizeStatCalls &StatCalls) {
   // Build the on-disk hash table containing information about every
   // stat() call.
   OnDiskChainedHashTableGenerator<PCHStatCacheTrait> Generator;
@@ -1053,7 +1053,7 @@ static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &Stream) {
 /// entries for files that we actually need. In the common case (no
 /// errors), we probably won't have to create file entries for any of
 /// the files in the AST.
-void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
+void ASTWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
                                         const Preprocessor &PP,
                                         const char *isysroot) {
   RecordData Record;
@@ -1241,7 +1241,7 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr,
 /// \brief Writes the block containing the serialized form of the
 /// preprocessor.
 ///
-void PCHWriter::WritePreprocessor(const Preprocessor &PP) {
+void ASTWriter::WritePreprocessor(const Preprocessor &PP) {
   RecordData Record;
 
   // If the preprocessor __COUNTER__ value has been bumped, remember it.
@@ -1394,7 +1394,7 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) {
 //===----------------------------------------------------------------------===//
 
 /// \brief Write the representation of a type to the PCH stream.
-void PCHWriter::WriteType(QualType T) {
+void ASTWriter::WriteType(QualType T) {
   pch::TypeID &ID = TypeIDs[T];
   if (ID == 0) // we haven't seen this type before.
     ID = NextTypeID++;
@@ -1445,7 +1445,7 @@ void PCHWriter::WriteType(QualType T) {
 ///
 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
 /// bistream, or 0 if no block was written.
-uint64_t PCHWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
+uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
                                                  DeclContext *DC) {
   if (DC->decls_empty())
     return 0;
@@ -1469,7 +1469,7 @@ uint64_t PCHWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
 ///
 /// \returns the offset of the DECL_CONTEXT_VISIBLE block within the
 /// bistream, or 0 if no block was written.
-uint64_t PCHWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
+uint64_t ASTWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
                                                  DeclContext *DC) {
   if (DC->getPrimaryContext() != DC)
     return 0;
@@ -1517,7 +1517,7 @@ uint64_t PCHWriter::WriteDeclContextVisibleBlock(ASTContext &Context,
   return Offset;
 }
 
-void PCHWriter::WriteTypeDeclOffsets() {
+void ASTWriter::WriteTypeDeclOffsets() {
   using namespace llvm;
   RecordData Record;
 
@@ -1555,7 +1555,7 @@ void PCHWriter::WriteTypeDeclOffsets() {
 namespace {
 // Trait used for the on-disk hash table used in the method pool.
 class PCHMethodPoolTrait {
-  PCHWriter &Writer;
+  ASTWriter &Writer;
 
 public:
   typedef Selector key_type;
@@ -1567,7 +1567,7 @@ public:
   };
   typedef const data_type& data_type_ref;
 
-  explicit PCHMethodPoolTrait(PCHWriter &Writer) : Writer(Writer) { }
+  explicit PCHMethodPoolTrait(ASTWriter &Writer) : Writer(Writer) { }
 
   static unsigned ComputeHash(Selector Sel) {
     unsigned N = Sel.getNumArgs();
@@ -1648,7 +1648,7 @@ public:
 /// The method pool contains both instance and factory methods, stored
 /// in an on-disk hash table indexed by the selector. The hash table also
 /// contains an empty entry for every other selector known to Sema.
-void PCHWriter::WriteSelectors(Sema &SemaRef) {
+void ASTWriter::WriteSelectors(Sema &SemaRef) {
   using namespace llvm;
 
   // Do we have to do anything at all?
@@ -1744,7 +1744,7 @@ void PCHWriter::WriteSelectors(Sema &SemaRef) {
 }
 
 /// \brief Write the selectors referenced in @selector expression into PCH file.
-void PCHWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
+void ASTWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
   using namespace llvm;
   if (SemaRef.ReferencedSelectors.empty())
     return;
@@ -1771,7 +1771,7 @@ void PCHWriter::WriteReferencedSelectorsPool(Sema &SemaRef) {
 
 namespace {
 class PCHIdentifierTableTrait {
-  PCHWriter &Writer;
+  ASTWriter &Writer;
   Preprocessor &PP;
 
   /// \brief Determines whether this is an "interesting" identifier
@@ -1792,7 +1792,7 @@ public:
   typedef pch::IdentID data_type;
   typedef data_type data_type_ref;
 
-  PCHIdentifierTableTrait(PCHWriter &Writer, Preprocessor &PP)
+  PCHIdentifierTableTrait(ASTWriter &Writer, Preprocessor &PP)
     : Writer(Writer), PP(PP) { }
 
   static unsigned ComputeHash(const IdentifierInfo* II) {
@@ -1875,7 +1875,7 @@ public:
 /// The identifier table consists of a blob containing string data
 /// (the actual identifiers themselves) and a separate "offsets" index
 /// that maps identifier IDs to locations within the blob.
-void PCHWriter::WriteIdentifierTable(Preprocessor &PP) {
+void ASTWriter::WriteIdentifierTable(Preprocessor &PP) {
   using namespace llvm;
 
   // Create and write out the blob that contains the identifier
@@ -1949,7 +1949,7 @@ void PCHWriter::WriteIdentifierTable(Preprocessor &PP) {
 //===----------------------------------------------------------------------===//
 
 /// \brief Write a record containing the given attributes.
-void PCHWriter::WriteAttributeRecord(const AttrVec &Attrs) {
+void ASTWriter::WriteAttributeRecord(const AttrVec &Attrs) {
   RecordData Record;
   for (AttrVec::const_iterator i = Attrs.begin(), e = Attrs.end(); i != e; ++i){
     const Attr * A = *i;
@@ -1964,14 +1964,14 @@ void PCHWriter::WriteAttributeRecord(const AttrVec &Attrs) {
   Stream.EmitRecord(pch::DECL_ATTR, Record);
 }
 
-void PCHWriter::AddString(const std::string &Str, RecordData &Record) {
+void ASTWriter::AddString(const std::string &Str, RecordData &Record) {
   Record.push_back(Str.size());
   Record.insert(Record.end(), Str.begin(), Str.end());
 }
 
 /// \brief Note that the identifier II occurs at the given offset
 /// within the identifier table.
-void PCHWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
+void ASTWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
   pch::IdentID ID = IdentifierIDs[II];
   // Only store offsets new to this PCH file. Other identifier names are looked
   // up earlier in the chain and thus don't need an offset.
@@ -1981,7 +1981,7 @@ void PCHWriter::SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset) {
 
 /// \brief Note that the selector Sel occurs at the given offset
 /// within the method pool/selector table.
-void PCHWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
+void ASTWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
   unsigned ID = SelectorIDs[Sel];
   assert(ID && "Unknown selector");
   // Don't record offsets for selectors that are also available in a different
@@ -1991,7 +1991,7 @@ void PCHWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) {
   SelectorOffsets[ID - FirstSelectorID] = Offset;
 }
 
-PCHWriter::PCHWriter(llvm::BitstreamWriter &Stream)
+ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream)
   : Stream(Stream), Chain(0), FirstDeclID(1), NextDeclID(FirstDeclID),
     FirstTypeID(pch::NUM_PREDEF_TYPE_IDS), NextTypeID(FirstTypeID),
     FirstIdentID(1), NextIdentID(FirstIdentID), FirstSelectorID(1),
@@ -2000,7 +2000,7 @@ PCHWriter::PCHWriter(llvm::BitstreamWriter &Stream)
     NumVisibleDeclContexts(0) {
 }
 
-void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls,
+void ASTWriter::WriteAST(Sema &SemaRef, MemorizeStatCalls *StatCalls,
                          const char *isysroot) {
   // Emit the file header.
   Stream.Emit((unsigned)'C', 8);
@@ -2011,12 +2011,12 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls,
   WriteBlockInfoBlock();
 
   if (Chain)
-    WritePCHChain(SemaRef, StatCalls, isysroot);
+    WriteASTChain(SemaRef, StatCalls, isysroot);
   else
-    WritePCHCore(SemaRef, StatCalls, isysroot);
+    WriteASTCore(SemaRef, StatCalls, isysroot);
 }
 
-void PCHWriter::WritePCHCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
+void ASTWriter::WriteASTCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
                              const char *isysroot) {
   using namespace llvm;
 
@@ -2221,7 +2221,7 @@ void PCHWriter::WritePCHCore(Sema &SemaRef, MemorizeStatCalls *StatCalls,
   Stream.ExitBlock();
 }
 
-void PCHWriter::WritePCHChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
+void ASTWriter::WriteASTChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
                               const char *isysroot) {
   using namespace llvm;
 
@@ -2446,7 +2446,7 @@ void PCHWriter::WritePCHChain(Sema &SemaRef, MemorizeStatCalls *StatCalls,
   Stream.ExitBlock();
 }
 
-void PCHWriter::WriteDeclUpdateBlock() {
+void ASTWriter::WriteDeclUpdateBlock() {
   if (ReplacedDecls.empty())
     return;
 
@@ -2459,16 +2459,16 @@ void PCHWriter::WriteDeclUpdateBlock() {
   Stream.EmitRecord(pch::DECL_REPLACEMENTS, Record);
 }
 
-void PCHWriter::AddSourceLocation(SourceLocation Loc, RecordData &Record) {
+void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordData &Record) {
   Record.push_back(Loc.getRawEncoding());
 }
 
-void PCHWriter::AddSourceRange(SourceRange Range, RecordData &Record) {
+void ASTWriter::AddSourceRange(SourceRange Range, RecordData &Record) {
   AddSourceLocation(Range.getBegin(), Record);
   AddSourceLocation(Range.getEnd(), Record);
 }
 
-void PCHWriter::AddAPInt(const llvm::APInt &Value, RecordData &Record) {
+void ASTWriter::AddAPInt(const llvm::APInt &Value, RecordData &Record) {
   Record.push_back(Value.getBitWidth());
   unsigned N = Value.getNumWords();
   const uint64_t* Words = Value.getRawData();
@@ -2476,20 +2476,20 @@ void PCHWriter::AddAPInt(const llvm::APInt &Value, RecordData &Record) {
     Record.push_back(Words[I]);
 }
 
-void PCHWriter::AddAPSInt(const llvm::APSInt &Value, RecordData &Record) {
+void ASTWriter::AddAPSInt(const llvm::APSInt &Value, RecordData &Record) {
   Record.push_back(Value.isUnsigned());
   AddAPInt(Value, Record);
 }
 
-void PCHWriter::AddAPFloat(const llvm::APFloat &Value, RecordData &Record) {
+void ASTWriter::AddAPFloat(const llvm::APFloat &Value, RecordData &Record) {
   AddAPInt(Value.bitcastToAPInt(), Record);
 }
 
-void PCHWriter::AddIdentifierRef(const IdentifierInfo *II, RecordData &Record) {
+void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordData &Record) {
   Record.push_back(getIdentifierRef(II));
 }
 
-pch::IdentID PCHWriter::getIdentifierRef(const IdentifierInfo *II) {
+pch::IdentID ASTWriter::getIdentifierRef(const IdentifierInfo *II) {
   if (II == 0)
     return 0;
 
@@ -2499,7 +2499,7 @@ pch::IdentID PCHWriter::getIdentifierRef(const IdentifierInfo *II) {
   return ID;
 }
 
-pch::IdentID PCHWriter::getMacroDefinitionID(MacroDefinition *MD) {
+pch::IdentID ASTWriter::getMacroDefinitionID(MacroDefinition *MD) {
   if (MD == 0)
     return 0;
   
@@ -2509,11 +2509,11 @@ pch::IdentID PCHWriter::getMacroDefinitionID(MacroDefinition *MD) {
   return ID;
 }
 
-void PCHWriter::AddSelectorRef(const Selector SelRef, RecordData &Record) {
+void ASTWriter::AddSelectorRef(const Selector SelRef, RecordData &Record) {
   Record.push_back(getSelectorRef(SelRef));
 }
 
-pch::SelectorID PCHWriter::getSelectorRef(Selector Sel) {
+pch::SelectorID ASTWriter::getSelectorRef(Selector Sel) {
   if (Sel.getAsOpaquePtr() == 0) {
     return 0;
   }
@@ -2530,11 +2530,11 @@ pch::SelectorID PCHWriter::getSelectorRef(Selector Sel) {
   return SID;
 }
 
-void PCHWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordData &Record) {
+void ASTWriter::AddCXXTemporary(const CXXTemporary *Temp, RecordData &Record) {
   AddDeclRef(Temp->getDestructor(), Record);
 }
 
-void PCHWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
+void ASTWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
                                            const TemplateArgumentLocInfo &Arg,
                                            RecordData &Record) {
   switch (Kind) {
@@ -2556,7 +2556,7 @@ void PCHWriter::AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
   }
 }
 
-void PCHWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
+void ASTWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
                                        RecordData &Record) {
   AddTemplateArgument(Arg.getArgument(), Record);
 
@@ -2571,7 +2571,7 @@ void PCHWriter::AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg,
                              Record);
 }
 
-void PCHWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordData &Record) {
+void ASTWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordData &Record) {
   if (TInfo == 0) {
     AddTypeRef(QualType(), Record);
     return;
@@ -2583,7 +2583,7 @@ void PCHWriter::AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordData &Record) {
     TLW.Visit(TL);
 }
 
-void PCHWriter::AddTypeRef(QualType T, RecordData &Record) {
+void ASTWriter::AddTypeRef(QualType T, RecordData &Record) {
   if (T.isNull()) {
     Record.push_back(pch::PREDEF_TYPE_NULL_ID);
     return;
@@ -2661,11 +2661,11 @@ void PCHWriter::AddTypeRef(QualType T, RecordData &Record) {
   Record.push_back((ID << Qualifiers::FastWidth) | FastQuals);
 }
 
-void PCHWriter::AddDeclRef(const Decl *D, RecordData &Record) {
+void ASTWriter::AddDeclRef(const Decl *D, RecordData &Record) {
   Record.push_back(GetDeclRef(D));
 }
 
-pch::DeclID PCHWriter::GetDeclRef(const Decl *D) {
+pch::DeclID ASTWriter::GetDeclRef(const Decl *D) {
   if (D == 0) {
     return 0;
   }
@@ -2687,7 +2687,7 @@ pch::DeclID PCHWriter::GetDeclRef(const Decl *D) {
   return ID;
 }
 
-pch::DeclID PCHWriter::getDeclID(const Decl *D) {
+pch::DeclID ASTWriter::getDeclID(const Decl *D) {
   if (D == 0)
     return 0;
 
@@ -2695,7 +2695,7 @@ pch::DeclID PCHWriter::getDeclID(const Decl *D) {
   return DeclIDs[D];
 }
 
-void PCHWriter::AddDeclarationName(DeclarationName Name, RecordData &Record) {
+void ASTWriter::AddDeclarationName(DeclarationName Name, RecordData &Record) {
   // FIXME: Emit a stable enum for NameKind.  0 = Identifier etc.
   Record.push_back(Name.getNameKind());
   switch (Name.getNameKind()) {
@@ -2729,7 +2729,7 @@ void PCHWriter::AddDeclarationName(DeclarationName Name, RecordData &Record) {
   }
 }
 
-void PCHWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
+void ASTWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
                                        RecordData &Record) {
   // Nested name specifiers usually aren't too long. I think that 8 would
   // typically accomodate the vast majority.
@@ -2768,7 +2768,7 @@ void PCHWriter::AddNestedNameSpecifier(NestedNameSpecifier *NNS,
   }
 }
 
-void PCHWriter::AddTemplateName(TemplateName Name, RecordData &Record) {
+void ASTWriter::AddTemplateName(TemplateName Name, RecordData &Record) {
   TemplateName::NameKind Kind = Name.getKind(); 
   Record.push_back(Kind);
   switch (Kind) {
@@ -2806,7 +2806,7 @@ void PCHWriter::AddTemplateName(TemplateName Name, RecordData &Record) {
   }
 }
 
-void PCHWriter::AddTemplateArgument(const TemplateArgument &Arg, 
+void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, 
                                     RecordData &Record) {
   Record.push_back(Arg.getKind());
   switch (Arg.getKind()) {
@@ -2838,7 +2838,7 @@ void PCHWriter::AddTemplateArgument(const TemplateArgument &Arg,
 }
 
 void
-PCHWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
+ASTWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
                                     RecordData &Record) {
   assert(TemplateParams && "No TemplateParams!");
   AddSourceLocation(TemplateParams->getTemplateLoc(), Record);
@@ -2853,7 +2853,7 @@ PCHWriter::AddTemplateParameterList(const TemplateParameterList *TemplateParams,
 
 /// \brief Emit a template argument list.
 void
-PCHWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
+ASTWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
                                    RecordData &Record) {
   assert(TemplateArgs && "No TemplateArgs!");
   Record.push_back(TemplateArgs->flat_size());
@@ -2863,7 +2863,7 @@ PCHWriter::AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs,
 
 
 void
-PCHWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordData &Record) {
+ASTWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordData &Record) {
   Record.push_back(Set.size());
   for (UnresolvedSetImpl::const_iterator
          I = Set.begin(), E = Set.end(); I != E; ++I) {
@@ -2872,7 +2872,7 @@ PCHWriter::AddUnresolvedSet(const UnresolvedSetImpl &Set, RecordData &Record) {
   }
 }
 
-void PCHWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
+void ASTWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
                                     RecordData &Record) {
   Record.push_back(Base.isVirtual());
   Record.push_back(Base.isBaseOfClass());
@@ -2881,7 +2881,7 @@ void PCHWriter::AddCXXBaseSpecifier(const CXXBaseSpecifier &Base,
   AddSourceRange(Base.getSourceRange(), Record);
 }
 
-void PCHWriter::AddCXXBaseOrMemberInitializers(
+void ASTWriter::AddCXXBaseOrMemberInitializers(
                         const CXXBaseOrMemberInitializer * const *BaseOrMembers,
                         unsigned NumBaseOrMembers, RecordData &Record) {
   Record.push_back(NumBaseOrMembers);
@@ -2911,7 +2911,7 @@ void PCHWriter::AddCXXBaseOrMemberInitializers(
   }
 }
 
-void PCHWriter::SetReader(PCHReader *Reader) {
+void ASTWriter::SetReader(PCHReader *Reader) {
   assert(Reader && "Cannot remove chain");
   assert(FirstDeclID == NextDeclID &&
          FirstTypeID == NextTypeID &&
@@ -2921,18 +2921,18 @@ void PCHWriter::SetReader(PCHReader *Reader) {
   Chain = Reader;
 }
 
-void PCHWriter::IdentifierRead(pch::IdentID ID, IdentifierInfo *II) {
+void ASTWriter::IdentifierRead(pch::IdentID ID, IdentifierInfo *II) {
   IdentifierIDs[II] = ID;
 }
 
-void PCHWriter::TypeRead(pch::TypeID ID, QualType T) {
+void ASTWriter::TypeRead(pch::TypeID ID, QualType T) {
   TypeIDs[T] = ID;
 }
 
-void PCHWriter::DeclRead(pch::DeclID ID, const Decl *D) {
+void ASTWriter::DeclRead(pch::DeclID ID, const Decl *D) {
   DeclIDs[D] = ID;
 }
 
-void PCHWriter::SelectorRead(pch::SelectorID ID, Selector S) {
+void ASTWriter::SelectorRead(pch::SelectorID ID, Selector S) {
   SelectorIDs[S] = ID;
 }

diff --git a/lib/Serialization/PCHWriterDecl.cpp b/lib/Serialization/PCHWriterDecl.cpp
index a9ec5276e84bc8ee2ea22f9a4288473729fa3e28..ec0c0f95fd320215be7b7164dd078676df46c6b3 100644 (file)
--- a/lib/Serialization/PCHWriterDecl.cpp
+++ b/lib/Serialization/PCHWriterDecl.cpp
@@ -28,16 +28,16 @@ using namespace clang;
 namespace clang {
   class PCHDeclWriter : public DeclVisitor<PCHDeclWriter, void> {
 
-    PCHWriter &Writer;
+    ASTWriter &Writer;
     ASTContext &Context;
-    PCHWriter::RecordData &Record;
+    ASTWriter::RecordData &Record;
 
   public:
     pch::DeclCode Code;
     unsigned AbbrevToUse;
 
-    PCHDeclWriter(PCHWriter &Writer, ASTContext &Context,
-                  PCHWriter::RecordData &Record)
+    PCHDeclWriter(ASTWriter &Writer, ASTContext &Context,
+                  ASTWriter::RecordData &Record)
       : Writer(Writer), Context(Context), Record(Record) {
     }
     
@@ -1038,10 +1038,10 @@ void PCHDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
 }
 
 //===----------------------------------------------------------------------===//
-// PCHWriter Implementation
+// ASTWriter Implementation
 //===----------------------------------------------------------------------===//
 
-void PCHWriter::WriteDeclsBlockAbbrevs() {
+void ASTWriter::WriteDeclsBlockAbbrevs() {
   using namespace llvm;
   // Abbreviation for DECL_PARM_VAR.
   BitCodeAbbrev *Abv = new BitCodeAbbrev();
@@ -1108,7 +1108,7 @@ static bool isRequiredDecl(const Decl *D, ASTContext &Context) {
   return Context.DeclMustBeEmitted(D);
 }
 
-void PCHWriter::WriteDecl(ASTContext &Context, Decl *D) {
+void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
   RecordData Record;
   PCHDeclWriter W(*this, Context, Record);
 

diff --git a/lib/Serialization/PCHWriterStmt.cpp b/lib/Serialization/PCHWriterStmt.cpp
index 182a2726034451dd830936975ca813a9333b6a6b..dfc3c20bc1b6f79c038768fdfa5e1fb7e44a0eff 100644 (file)
--- a/lib/Serialization/PCHWriterStmt.cpp
+++ b/lib/Serialization/PCHWriterStmt.cpp
@@ -24,13 +24,13 @@ using namespace clang;
 
 namespace clang {
   class PCHStmtWriter : public StmtVisitor<PCHStmtWriter, void> {
-    PCHWriter &Writer;
-    PCHWriter::RecordData &Record;
+    ASTWriter &Writer;
+    ASTWriter::RecordData &Record;
 
   public:
     pch::StmtCode Code;
 
-    PCHStmtWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
+    PCHStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
       : Writer(Writer), Record(Record) { }
     
     void
@@ -1279,10 +1279,10 @@ void PCHStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
 }
 
 //===----------------------------------------------------------------------===//
-// PCHWriter Implementation
+// ASTWriter Implementation
 //===----------------------------------------------------------------------===//
 
-unsigned PCHWriter::RecordSwitchCaseID(SwitchCase *S) {
+unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
          "SwitchCase recorded twice");
   unsigned NextID = SwitchCaseIDs.size();
@@ -1290,7 +1290,7 @@ unsigned PCHWriter::RecordSwitchCaseID(SwitchCase *S) {
   return NextID;
 }
 
-unsigned PCHWriter::getSwitchCaseID(SwitchCase *S) {
+unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
          "SwitchCase hasn't been seen yet");
   return SwitchCaseIDs[S];
@@ -1298,7 +1298,7 @@ unsigned PCHWriter::getSwitchCaseID(SwitchCase *S) {
 
 /// \brief Retrieve the ID for the given label statement, which may
 /// or may not have been emitted yet.
-unsigned PCHWriter::GetLabelID(LabelStmt *S) {
+unsigned ASTWriter::GetLabelID(LabelStmt *S) {
   std::map<LabelStmt *, unsigned>::iterator Pos = LabelIDs.find(S);
   if (Pos != LabelIDs.end())
     return Pos->second;
@@ -1310,7 +1310,7 @@ unsigned PCHWriter::GetLabelID(LabelStmt *S) {
 
 /// \brief Write the given substatement or subexpression to the
 /// bitstream.
-void PCHWriter::WriteSubStmt(Stmt *S) {
+void ASTWriter::WriteSubStmt(Stmt *S) {
   RecordData Record;
   PCHStmtWriter Writer(*this, Record);
   ++NumStatements;
@@ -1320,7 +1320,7 @@ void PCHWriter::WriteSubStmt(Stmt *S) {
     return;
   }
 
-  // Redirect PCHWriter::AddStmt to collect sub stmts.
+  // Redirect ASTWriter::AddStmt to collect sub stmts.
   llvm::SmallVector<Stmt *, 16> SubStmts;
   CollectedStmts = &SubStmts;
 
@@ -1336,7 +1336,7 @@ void PCHWriter::WriteSubStmt(Stmt *S) {
   }
 #endif
 
-  // Revert PCHWriter::AddStmt.
+  // Revert ASTWriter::AddStmt.
   CollectedStmts = &StmtsToEmit;
 
   // Write the sub stmts in reverse order, last to first. When reading them back
@@ -1351,7 +1351,7 @@ void PCHWriter::WriteSubStmt(Stmt *S) {
 
 /// \brief Flush all of the statements that have been added to the
 /// queue via AddStmt().
-void PCHWriter::FlushStmts() {
+void ASTWriter::FlushStmts() {
   RecordData Record;
 
   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {