Rename several methods on ASTRecordReader to follow LLVM style (lowerCamelCase).

[dlj]

Summary

This follows up to r290217, and makes functions on ASTRecordReader consistent
and valid style.

include/clang/Serialization/ASTReader.h

public:
   }
 
   /// \brief Retrieve the submodule that corresponds to a global submodule ID.
   Module *getSubmodule(serialization::SubmoduleID GlobalID) {
     return Reader->getSubmodule(GlobalID);
   }
 
   /// \brief Read the record that describes the lexical contents of a DC.
-  bool ReadLexicalDeclContextStorage(uint64_t Offset, DeclContext *DC) {
+  bool readLexicalDeclContextStorage(uint64_t Offset, DeclContext *DC) {
     return Reader->ReadLexicalDeclContextStorage(*F, F->DeclsCursor, Offset,
                                                  DC);
   }
 
   /// \brief Read the record that describes the visible contents of a DC.
-  bool ReadVisibleDeclContextStorage(uint64_t Offset,
+  bool readVisibleDeclContextStorage(uint64_t Offset,
                                      serialization::DeclID ID) {
     return Reader->ReadVisibleDeclContextStorage(*F, F->DeclsCursor, Offset,
                                                  ID);
   }
 
   void readExceptionSpec(SmallVectorImpl<QualType> &ExceptionStorage,
                          FunctionProtoType::ExceptionSpecInfo &ESI) {
     return Reader->readExceptionSpec(*F, ExceptionStorage, ESI, Record, Idx);
   }
 
   /// \brief Get the global offset corresponding to a local offset.
   uint64_t getGlobalBitOffset(uint32_t LocalOffset) {
     return Reader->getGlobalBitOffset(*F, LocalOffset);
   }
 
   /// \brief Reads a statement.
-  Stmt *ReadStmt() { return Reader->ReadStmt(*F); }
+  Stmt *readStmt() { return Reader->ReadStmt(*F); }
 
   /// \brief Reads an expression.
-  Expr *ReadExpr() { return Reader->ReadExpr(*F); }
+  Expr *readExpr() { return Reader->ReadExpr(*F); }
 
   /// \brief Reads a sub-statement operand during statement reading.
-  Stmt *ReadSubStmt() { return Reader->ReadSubStmt(); }
+  Stmt *readSubStmt() { return Reader->ReadSubStmt(); }
 
   /// \brief Reads a sub-expression operand during statement reading.
-  Expr *ReadSubExpr() { return Reader->ReadSubExpr(); }
+  Expr *readSubExpr() { return Reader->ReadSubExpr(); }
 
   /// \brief Reads a TemplateArgumentLocInfo appropriate for the
   /// given TemplateArgument kind, advancing Idx.
   TemplateArgumentLocInfo
-  GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
+  getTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
     return Reader->GetTemplateArgumentLocInfo(*F, Kind, Record, Idx);
   }
 
   /// \brief Reads a TemplateArgumentLoc, advancing Idx.
   TemplateArgumentLoc
-  ReadTemplateArgumentLoc() {
+  readTemplateArgumentLoc() {
     return Reader->ReadTemplateArgumentLoc(*F, Record, Idx);
   }
 
   const ASTTemplateArgumentListInfo*
-  ReadASTTemplateArgumentListInfo() {
+  readASTTemplateArgumentListInfo() {
     return Reader->ReadASTTemplateArgumentListInfo(*F, Record, Idx);
   }
 
   /// \brief Reads a declarator info from the given record, advancing Idx.
-  TypeSourceInfo *GetTypeSourceInfo() {
+  TypeSourceInfo *getTypeSourceInfo() {
     return Reader->GetTypeSourceInfo(*F, Record, Idx);
   }
 
   /// \brief Map a local type ID within a given AST file to a global type ID.
   serialization::TypeID getGlobalTypeID(unsigned LocalID) const {
     return Reader->getGlobalTypeID(*F, LocalID);
   }
 
   /// \brief Read a type from the current position in the record.
   QualType readType() {
     return Reader->readType(*F, Record, Idx);
   }
 
   /// \brief Reads a declaration ID from the given position in this record.
   ///
   /// \returns The declaration ID read from the record, adjusted to a global ID.
-  serialization::DeclID ReadDeclID() {
+  serialization::DeclID readDeclID() {
     return Reader->ReadDeclID(*F, Record, Idx);
   }
 
   /// \brief Reads a declaration from the given position in a record in the
   /// given module, advancing Idx.
-  Decl *ReadDecl() {
+  Decl *readDecl() {
     return Reader->ReadDecl(*F, Record, Idx);
   }
 
   /// \brief Reads a declaration from the given position in the record,
   /// advancing Idx.
   ///
   /// \returns The declaration read from this location, casted to the given
   /// result type.
   template<typename T>
-  T *ReadDeclAs() {
+  T *readDeclAs() {
     return Reader->ReadDeclAs<T>(*F, Record, Idx);
   }
 
-  IdentifierInfo *GetIdentifierInfo() {
+  IdentifierInfo *getIdentifierInfo() {
     return Reader->GetIdentifierInfo(*F, Record, Idx);
   }
 
   /// \brief Read a selector from the Record, advancing Idx.
-  Selector ReadSelector() {
+  Selector readSelector() {
     return Reader->ReadSelector(*F, Record, Idx);
   }
 
   /// \brief Read a declaration name, advancing Idx.
-  DeclarationName ReadDeclarationName() {
+  DeclarationName readDeclarationName() {
     return Reader->ReadDeclarationName(*F, Record, Idx);
   }
-  void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name) {
+  void readDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name) {
     return Reader->ReadDeclarationNameLoc(*F, DNLoc, Name, Record, Idx);
   }
-  void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
+  void readDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
     return Reader->ReadDeclarationNameInfo(*F, NameInfo, Record, Idx);
   }
 
-  void ReadQualifierInfo(QualifierInfo &Info) {
+  void readQualifierInfo(QualifierInfo &Info) {
     return Reader->ReadQualifierInfo(*F, Info, Record, Idx);
   }
 
-  NestedNameSpecifier *ReadNestedNameSpecifier() {
+  NestedNameSpecifier *readNestedNameSpecifier() {
     return Reader->ReadNestedNameSpecifier(*F, Record, Idx);
   }
 
-  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
+  NestedNameSpecifierLoc readNestedNameSpecifierLoc() {
     return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
   }
 
   /// \brief Read a template name, advancing Idx.
-  TemplateName ReadTemplateName() {
+  TemplateName readTemplateName() {
     return Reader->ReadTemplateName(*F, Record, Idx);
   }
 
   /// \brief Read a template argument, advancing Idx.
-  TemplateArgument ReadTemplateArgument(bool Canonicalize = false) {
+  TemplateArgument readTemplateArgument(bool Canonicalize = false) {
     return Reader->ReadTemplateArgument(*F, Record, Idx, Canonicalize);
   }
 
   /// \brief Read a template parameter list, advancing Idx.
-  TemplateParameterList *ReadTemplateParameterList() {
+  TemplateParameterList *readTemplateParameterList() {
     return Reader->ReadTemplateParameterList(*F, Record, Idx);
   }
 
   /// \brief Read a template argument array, advancing Idx.
-  void ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
+  void readTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
                                 bool Canonicalize = false) {
     return Reader->ReadTemplateArgumentList(TemplArgs, *F, Record, Idx,
                                             Canonicalize);
   }
 
   /// \brief Read a UnresolvedSet structure, advancing Idx.
-  void ReadUnresolvedSet(LazyASTUnresolvedSet &Set) {
+  void readUnresolvedSet(LazyASTUnresolvedSet &Set) {
     return Reader->ReadUnresolvedSet(*F, Set, Record, Idx);
   }
 
   /// \brief Read a C++ base specifier, advancing Idx.
-  CXXBaseSpecifier ReadCXXBaseSpecifier() {
+  CXXBaseSpecifier readCXXBaseSpecifier() {
     return Reader->ReadCXXBaseSpecifier(*F, Record, Idx);
   }
 
   /// \brief Read a CXXCtorInitializer array, advancing Idx.
-  CXXCtorInitializer **ReadCXXCtorInitializers() {
+  CXXCtorInitializer **readCXXCtorInitializers() {
     return Reader->ReadCXXCtorInitializers(*F, Record, Idx);
   }
 
-  CXXTemporary *ReadCXXTemporary() {
+  CXXTemporary *readCXXTemporary() {
     return Reader->ReadCXXTemporary(*F, Record, Idx);
   }
 
   /// \brief Read a source location, advancing Idx.
-  SourceLocation ReadSourceLocation() {
+  SourceLocation readSourceLocation() {
     return Reader->ReadSourceLocation(*F, Record, Idx);
   }
 
   /// \brief Read a source range, advancing Idx.
-  SourceRange ReadSourceRange() {
+  SourceRange readSourceRange() {
     return Reader->ReadSourceRange(*F, Record, Idx);
   }
 
   /// \brief Read an integral value, advancing Idx.
-  llvm::APInt ReadAPInt() {
+  llvm::APInt readAPInt() {
     return Reader->ReadAPInt(Record, Idx);
   }
 
   /// \brief Read a signed integral value, advancing Idx.
-  llvm::APSInt ReadAPSInt() {
+  llvm::APSInt readAPSInt() {
     return Reader->ReadAPSInt(Record, Idx);
   }
 
   /// \brief Read a floating-point value, advancing Idx.
-  llvm::APFloat ReadAPFloat(const llvm::fltSemantics &Sem) {
+  llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem) {
     return Reader->ReadAPFloat(Record, Sem,Idx);
   }
 
   /// \brief Read a string, advancing Idx.
-  std::string ReadString() {
+  std::string readString() {
     return Reader->ReadString(Record, Idx);
   }
 
   /// \brief Read a path, advancing Idx.
-  std::string ReadPath() {
+  std::string readPath() {
     return Reader->ReadPath(*F, Record, Idx);
   }
 
   /// \brief Read a version tuple, advancing Idx.
-  VersionTuple ReadVersionTuple() {
+  VersionTuple readVersionTuple() {
     return ASTReader::ReadVersionTuple(Record, Idx);
   }
 
   /// \brief Reads attributes from the current stream position, advancing Idx.
-  void ReadAttributes(AttrVec &Attrs) {
+  void readAttributes(AttrVec &Attrs) {
     return Reader->ReadAttributes(*F, Attrs, Record, Idx);
   }
 
   /// \brief Reads a token out of a record, advancing Idx.
-  Token ReadToken() {
+  Token readToken() {
     return Reader->ReadToken(*F, Record, Idx);
   }
 
-  void RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
+  void recordSwitchCaseID(SwitchCase *SC, unsigned ID) {
     Reader->RecordSwitchCaseID(SC, ID);
   }
 
   /// \brief Retrieve the switch-case statement with the given ID.
   SwitchCase *getSwitchCaseWithID(unsigned ID) {
     return Reader->getSwitchCaseWithID(ID);
   }
 };

lib/Serialization/ASTReaderDecl.cpp

class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
     }
 
     uint64_t ReadGlobalOffset() {
       uint64_t Local = ReadLocalOffset();
       return Local ? Record.getGlobalBitOffset(Local) : 0;
     }
 
     SourceLocation ReadSourceLocation() {
-      return Record.ReadSourceLocation();
+      return Record.readSourceLocation();
     }
 
     SourceRange ReadSourceRange() {
-      return Record.ReadSourceRange();
+      return Record.readSourceRange();
     }
 
     TypeSourceInfo *GetTypeSourceInfo() {
-      return Record.GetTypeSourceInfo();
+      return Record.getTypeSourceInfo();
     }
 
     serialization::DeclID ReadDeclID() {
-      return Record.ReadDeclID();
+      return Record.readDeclID();
     }
 
     std::string ReadString() {
-      return Record.ReadString();
+      return Record.readString();
     }
 
     void ReadDeclIDList(SmallVectorImpl<DeclID> &IDs) {
       for (unsigned I = 0, Size = Record.readInt(); I != Size; ++I)
         IDs.push_back(ReadDeclID());
     }
 
     Decl *ReadDecl() {
-      return Record.ReadDecl();
+      return Record.readDecl();
     }
 
     template<typename T>
     T *ReadDeclAs() {
-      return Record.ReadDeclAs<T>();
+      return Record.readDeclAs<T>();
     }
 
     void ReadQualifierInfo(QualifierInfo &Info) {
-      Record.ReadQualifierInfo(Info);
+      Record.readQualifierInfo(Info);
     }
 
     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name) {
-      Record.ReadDeclarationNameLoc(DNLoc, Name);
+      Record.readDeclarationNameLoc(DNLoc, Name);
     }
 
     serialization::SubmoduleID readSubmoduleID() {
       if (Record.getIdx() == Record.size())
         return 0;
 
       return Record.getGlobalSubmoduleID(Record.readInt());
     }
if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
     // Decl::getASTContext() internally which is unsafe during derialization.
     D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
                            Reader.getContext());
   }
   D->setLocation(ThisDeclLoc);
   D->setInvalidDecl(Record.readInt());
   if (Record.readInt()) { // hasAttrs
     AttrVec Attrs;
-    Record.ReadAttributes(Attrs);
+    Record.readAttributes(Attrs);
     // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
     // internally which is unsafe during derialization.
     D->setAttrsImpl(Attrs, Reader.getContext());
   }
   D->setImplicit(Record.readInt());
   D->Used = Record.readInt();
   IsDeclMarkedUsed |= D->Used;
   D->setReferenced(Record.readInt());

 }
 
 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
   llvm_unreachable("Translation units are not serialized");
 }
 
 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
   VisitDecl(ND);
-  ND->setDeclName(Record.ReadDeclarationName());
+  ND->setDeclName(Record.readDeclarationName());
   AnonymousDeclNumber = Record.readInt();
 }
 
 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
   VisitNamedDecl(TD);
   TD->setLocStart(ReadSourceLocation());
   // Delay type reading until after we have fully initialized the decl.
   TypeIDForTypeDecl = Record.getGlobalTypeID(Record.readInt());
ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
   case 1: { // ExtInfo
     TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
     ReadQualifierInfo(*Info);
     TD->TypedefNameDeclOrQualifier = Info;
     break;
   }
   case 2: // TypedefNameForAnonDecl
     NamedDeclForTagDecl = ReadDeclID();
-    TypedefNameForLinkage = Record.GetIdentifierInfo();
+    TypedefNameForLinkage = Record.getIdentifierInfo();
     break;
   default:
     llvm_unreachable("unexpected tag info kind");
   }
 
   if (!isa<CXXRecordDecl>(TD))
     mergeRedeclarable(TD, Redecl);
   return Redecl;

 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
   VisitNamedDecl(VD);
   VD->setType(Record.readType());
 }
 
 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
   VisitValueDecl(ECD);
   if (Record.readInt())
-    ECD->setInitExpr(Record.ReadExpr());
-  ECD->setInitVal(Record.ReadAPSInt());
+    ECD->setInitExpr(Record.readExpr());
+  ECD->setInitVal(Record.readAPSInt());
   mergeMergeable(ECD);
 }
 
 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
   VisitValueDecl(DD);
   DD->setInnerLocStart(ReadSourceLocation());
   if (Record.readInt()) { // hasExtInfo
     DeclaratorDecl::ExtInfo *Info
void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   }
   case FunctionDecl::TK_FunctionTemplateSpecialization: {
     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>();
     TemplateSpecializationKind TSK =
         (TemplateSpecializationKind)Record.readInt();
 
     // Template arguments.
     SmallVector<TemplateArgument, 8> TemplArgs;
-    Record.ReadTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
+    Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
 
     // Template args as written.
     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
     SourceLocation LAngleLoc, RAngleLoc;
     bool HasTemplateArgumentsAsWritten = Record.readInt();
     if (HasTemplateArgumentsAsWritten) {
       unsigned NumTemplateArgLocs = Record.readInt();
       TemplArgLocs.reserve(NumTemplateArgLocs);
       for (unsigned i=0; i != NumTemplateArgLocs; ++i)
-        TemplArgLocs.push_back(Record.ReadTemplateArgumentLoc());
+        TemplArgLocs.push_back(Record.readTemplateArgumentLoc());
 
       LAngleLoc = ReadSourceLocation();
       RAngleLoc = ReadSourceLocation();
     }
 
     SourceLocation POI = ReadSourceLocation();
 
     ASTContext &C = Reader.getContext();
case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     unsigned NumTemplates = Record.readInt();
     while (NumTemplates--)
       TemplDecls.addDecl(ReadDeclAs<NamedDecl>());
 
     // Templates args.
     TemplateArgumentListInfo TemplArgs;
     unsigned NumArgs = Record.readInt();
     while (NumArgs--)
-      TemplArgs.addArgument(Record.ReadTemplateArgumentLoc());
+      TemplArgs.addArgument(Record.readTemplateArgumentLoc());
     TemplArgs.setLAngleLoc(ReadSourceLocation());
     TemplArgs.setRAngleLoc(ReadSourceLocation());
 
     FD->setDependentTemplateSpecialization(Reader.getContext(),
                                            TemplDecls, TemplArgs);
     // These are not merged; we don't need to merge redeclarations of dependent
     // template friends.
     break;
void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
   TypeSourceInfo *TSI = GetTypeSourceInfo();
   D->setType(T, TSI);
   D->setPropertyAttributes(
       (ObjCPropertyDecl::PropertyAttributeKind)Record.readInt());
   D->setPropertyAttributesAsWritten(
       (ObjCPropertyDecl::PropertyAttributeKind)Record.readInt());
   D->setPropertyImplementation(
       (ObjCPropertyDecl::PropertyControl)Record.readInt());
-  D->setGetterName(Record.ReadDeclarationName().getObjCSelector());
-  D->setSetterName(Record.ReadDeclarationName().getObjCSelector());
+  D->setGetterName(Record.readDeclarationName().getObjCSelector());
+  D->setSetterName(Record.readDeclarationName().getObjCSelector());
   D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>());
   D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>());
   D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>());
 }
 
 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
   VisitObjCContainerDecl(D);
   D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>());
 }
 
 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
   VisitObjCImplDecl(D);
-  D->setIdentifier(Record.GetIdentifierInfo());
+  D->setIdentifier(Record.getIdentifierInfo());
   D->CategoryNameLoc = ReadSourceLocation();
 }
 
 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
   VisitObjCImplDecl(D);
   D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>());
   D->SuperLoc = ReadSourceLocation();
   D->setIvarLBraceLoc(ReadSourceLocation());
   D->setIvarRBraceLoc(ReadSourceLocation());
   D->setHasNonZeroConstructors(Record.readInt());
   D->setHasDestructors(Record.readInt());
   D->NumIvarInitializers = Record.readInt();
   if (D->NumIvarInitializers)
     D->IvarInitializers = ReadGlobalOffset();
 }
 
 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
   VisitDecl(D);
   D->setAtLoc(ReadSourceLocation());
   D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>());
   D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>();
   D->IvarLoc = ReadSourceLocation();
-  D->setGetterCXXConstructor(Record.ReadExpr());
-  D->setSetterCXXAssignment(Record.ReadExpr());
+  D->setGetterCXXConstructor(Record.readExpr());
+  D->setSetterCXXAssignment(Record.readExpr());
 }
 
 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
   VisitDeclaratorDecl(FD);
   FD->Mutable = Record.readInt();
   if (int BitWidthOrInitializer = Record.readInt()) {
     FD->InitStorage.setInt(
           static_cast<FieldDecl::InitStorageKind>(BitWidthOrInitializer - 1));
     if (FD->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
       // Read captured variable length array.
       FD->InitStorage.setPointer(Record.readType().getAsOpaquePtr());
     } else {
-      FD->InitStorage.setPointer(Record.ReadExpr());
+      FD->InitStorage.setPointer(Record.readExpr());
     }
   }
   if (!FD->getDeclName()) {
     if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>())
       Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
   }
   mergeMergeable(FD);
 }
 
 void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
   VisitDeclaratorDecl(PD);
-  PD->GetterId = Record.GetIdentifierInfo();
-  PD->SetterId = Record.GetIdentifierInfo();
+  PD->GetterId = Record.getIdentifierInfo();
+  PD->SetterId = Record.getIdentifierInfo();
 }
 
 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
   VisitValueDecl(FD);
 
   FD->ChainingSize = Record.readInt();
   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
   VD->setCachedLinkage(VarLinkage);
 
   // Reconstruct the one piece of the IdentifierNamespace that we need.
   if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
       VD->getLexicalDeclContext()->isFunctionOrMethod())
     VD->setLocalExternDecl();
 
   if (uint64_t Val = Record.readInt()) {
-    VD->setInit(Record.ReadExpr());
+    VD->setInit(Record.readExpr());
     if (Val > 1) { // IsInitKnownICE = 1, IsInitNotICE = 2, IsInitICE = 3
       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
       Eval->CheckedICE = true;
       Eval->IsICE = Val == 3;
     }
   }
 
   enum VarKind {
if (isObjCMethodParam) {
     PD->setObjCMethodScopeInfo(scopeIndex);
     PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
   } else {
     PD->setScopeInfo(scopeDepth, scopeIndex);
   }
   PD->ParmVarDeclBits.IsKNRPromoted = Record.readInt();
   PD->ParmVarDeclBits.HasInheritedDefaultArg = Record.readInt();
   if (Record.readInt()) // hasUninstantiatedDefaultArg.
-    PD->setUninstantiatedDefaultArg(Record.ReadExpr());
+    PD->setUninstantiatedDefaultArg(Record.readExpr());
 
   // FIXME: If this is a redeclaration of a function from another module, handle
   // inheritance of default arguments.
 }
 
 void ASTDeclReader::VisitDecompositionDecl(DecompositionDecl *DD) {
   VisitVarDecl(DD);
   BindingDecl **BDs = DD->getTrailingObjects<BindingDecl*>();
   for (unsigned I = 0; I != DD->NumBindings; ++I)
     BDs[I] = ReadDeclAs<BindingDecl>();
 }
 
 void ASTDeclReader::VisitBindingDecl(BindingDecl *BD) {
   VisitValueDecl(BD);
-  BD->Binding = Record.ReadExpr();
+  BD->Binding = Record.readExpr();
 }
 
 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
   VisitDecl(AD);
-  AD->setAsmString(cast<StringLiteral>(Record.ReadExpr()));
+  AD->setAsmString(cast<StringLiteral>(Record.readExpr()));
   AD->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
   VisitDecl(BD);
-  BD->setBody(cast_or_null<CompoundStmt>(Record.ReadStmt()));
+  BD->setBody(cast_or_null<CompoundStmt>(Record.readStmt()));
   BD->setSignatureAsWritten(GetTypeSourceInfo());
   unsigned NumParams = Record.readInt();
   SmallVector<ParmVarDecl *, 16> Params;
   Params.reserve(NumParams);
   for (unsigned I = 0; I != NumParams; ++I)
     Params.push_back(ReadDeclAs<ParmVarDecl>());
   BD->setParams(Params);
 
   BD->setIsVariadic(Record.readInt());
   BD->setBlockMissingReturnType(Record.readInt());
   BD->setIsConversionFromLambda(Record.readInt());
 
   bool capturesCXXThis = Record.readInt();
   unsigned numCaptures = Record.readInt();
   SmallVector<BlockDecl::Capture, 16> captures;
   captures.reserve(numCaptures);
   for (unsigned i = 0; i != numCaptures; ++i) {
     VarDecl *decl = ReadDeclAs<VarDecl>();
     unsigned flags = Record.readInt();
     bool byRef = (flags & 1);
     bool nested = (flags & 2);
-    Expr *copyExpr = ((flags & 4) ? Record.ReadExpr() : nullptr);
+    Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);
 
     captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
   }
   BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
 }
 
 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
   VisitDecl(CD);
void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
   }
 }
 
 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
   RedeclarableResult Redecl = VisitRedeclarable(D);
   VisitNamedDecl(D);
   D->NamespaceLoc = ReadSourceLocation();
   D->IdentLoc = ReadSourceLocation();
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   D->Namespace = ReadDeclAs<NamedDecl>();
   mergeRedeclarable(D, Redecl);
 }
 
 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
   VisitNamedDecl(D);
   D->setUsingLoc(ReadSourceLocation());
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName());
   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>());
   D->setTypename(Record.readInt());
   if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>())
     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
   mergeMergeable(D);
 }
 
void ASTDeclReader::VisitConstructorUsingShadowDecl(
   D->ConstructedBaseClassShadowDecl = ReadDeclAs<ConstructorUsingShadowDecl>();
   D->IsVirtual = Record.readInt();
 }
 
 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   VisitNamedDecl(D);
   D->UsingLoc = ReadSourceLocation();
   D->NamespaceLoc = ReadSourceLocation();
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   D->NominatedNamespace = ReadDeclAs<NamedDecl>();
   D->CommonAncestor = ReadDeclAs<DeclContext>();
 }
 
 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
   VisitValueDecl(D);
   D->setUsingLoc(ReadSourceLocation());
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName());
   D->EllipsisLoc = ReadSourceLocation();
   mergeMergeable(D);
 }
 
 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
                                                UnresolvedUsingTypenameDecl *D) {
   VisitTypeDecl(D);
   D->TypenameLocation = ReadSourceLocation();
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   D->EllipsisLoc = ReadSourceLocation();
   mergeMergeable(D);
 }
 
 void ASTDeclReader::ReadCXXDefinitionData(
                                    struct CXXRecordDecl::DefinitionData &Data) {
   // Note: the caller has deserialized the IsLambda bit already.
   Data.UserDeclaredConstructor = Record.readInt();
void ASTDeclReader::ReadCXXDefinitionData(
 
   Data.NumBases = Record.readInt();
   if (Data.NumBases)
     Data.Bases = ReadGlobalOffset();
   Data.NumVBases = Record.readInt();
   if (Data.NumVBases)
     Data.VBases = ReadGlobalOffset();
 
-  Record.ReadUnresolvedSet(Data.Conversions);
-  Record.ReadUnresolvedSet(Data.VisibleConversions);
+  Record.readUnresolvedSet(Data.Conversions);
+  Record.readUnresolvedSet(Data.VisibleConversions);
   assert(Data.Definition && "Data.Definition should be already set!");
   Data.FirstFriend = ReadDeclID();
 
   if (Data.IsLambda) {
     typedef LambdaCapture Capture;
     CXXRecordDecl::LambdaDefinitionData &Lambda
       = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
     Lambda.Dependent = Record.readInt();

 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
   VisitDecl(D);
   if (Record.readInt()) // hasFriendDecl
     D->Friend = ReadDeclAs<NamedDecl>();
   else
     D->Friend = GetTypeSourceInfo();
   for (unsigned i = 0; i != D->NumTPLists; ++i)
     D->getTrailingObjects<TemplateParameterList *>()[i] =
-        Record.ReadTemplateParameterList();
+        Record.readTemplateParameterList();
   D->NextFriend = ReadDeclID();
   D->UnsupportedFriend = (Record.readInt() != 0);
   D->FriendLoc = ReadSourceLocation();
 }
 
 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
   VisitDecl(D);
   unsigned NumParams = Record.readInt();
   D->NumParams = NumParams;
   D->Params = new TemplateParameterList*[NumParams];
   for (unsigned i = 0; i != NumParams; ++i)
-    D->Params[i] = Record.ReadTemplateParameterList();
+    D->Params[i] = Record.readTemplateParameterList();
   if (Record.readInt()) // HasFriendDecl
     D->Friend = ReadDeclAs<NamedDecl>();
   else
     D->Friend = GetTypeSourceInfo();
   D->FriendLoc = ReadSourceLocation();
 }
 
 DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
   VisitNamedDecl(D);
 
   DeclID PatternID = ReadDeclID();
   NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
-  TemplateParameterList *TemplateParams = Record.ReadTemplateParameterList();
+  TemplateParameterList *TemplateParams = Record.readTemplateParameterList();
   D->init(TemplatedDecl, TemplateParams);
 
   return PatternID;
 }
 
 ASTDeclReader::RedeclarableResult
 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
   RedeclarableResult Redecl = VisitRedeclarable(D);
ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
   RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
 
   ASTContext &C = Reader.getContext();
   if (Decl *InstD = ReadDecl()) {
     if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
       D->SpecializedTemplate = CTD;
     } else {
       SmallVector<TemplateArgument, 8> TemplArgs;
-      Record.ReadTemplateArgumentList(TemplArgs);
+      Record.readTemplateArgumentList(TemplArgs);
       TemplateArgumentList *ArgList
         = TemplateArgumentList::CreateCopy(C, TemplArgs);
       ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
           = new (C) ClassTemplateSpecializationDecl::
                                              SpecializedPartialSpecialization();
       PS->PartialSpecialization
           = cast<ClassTemplatePartialSpecializationDecl>(InstD);
       PS->TemplateArgs = ArgList;
       D->SpecializedTemplate = PS;
     }
   }
 
   SmallVector<TemplateArgument, 8> TemplArgs;
-  Record.ReadTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
+  Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
   D->PointOfInstantiation = ReadSourceLocation();
   D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
 
   bool writtenAsCanonicalDecl = Record.readInt();
   if (writtenAsCanonicalDecl) {
     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>();
     if (D->isCanonicalDecl()) { // It's kept in the folding set.
ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
 
   return Redecl;
 }
 
 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
                                     ClassTemplatePartialSpecializationDecl *D) {
   RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
 
-  D->TemplateParams = Record.ReadTemplateParameterList();
-  D->ArgsAsWritten = Record.ReadASTTemplateArgumentListInfo();
+  D->TemplateParams = Record.readTemplateParameterList();
+  D->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
 
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {
     D->InstantiatedFromMember.setPointer(
       ReadDeclAs<ClassTemplatePartialSpecializationDecl>());
     D->InstantiatedFromMember.setInt(Record.readInt());
   }
 }
ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
   RedeclarableResult Redecl = VisitVarDeclImpl(D);
 
   ASTContext &C = Reader.getContext();
   if (Decl *InstD = ReadDecl()) {
     if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
       D->SpecializedTemplate = VTD;
     } else {
       SmallVector<TemplateArgument, 8> TemplArgs;
-      Record.ReadTemplateArgumentList(TemplArgs);
+      Record.readTemplateArgumentList(TemplArgs);
       TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
           C, TemplArgs);
       VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
           new (C)
           VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
       PS->PartialSpecialization =
           cast<VarTemplatePartialSpecializationDecl>(InstD);
       PS->TemplateArgs = ArgList;
       D->SpecializedTemplate = PS;
     }
   }
 
   // Explicit info.
   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo()) {
     VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
         new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
     ExplicitInfo->TypeAsWritten = TyInfo;
     ExplicitInfo->ExternLoc = ReadSourceLocation();
     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation();
     D->ExplicitInfo = ExplicitInfo;
   }
 
   SmallVector<TemplateArgument, 8> TemplArgs;
-  Record.ReadTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
+  Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
   D->PointOfInstantiation = ReadSourceLocation();
   D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
 
   bool writtenAsCanonicalDecl = Record.readInt();
   if (writtenAsCanonicalDecl) {
     VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>();
     if (D->isCanonicalDecl()) { // It's kept in the folding set.

 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and
 ///        VarTemplate(Partial)SpecializationDecl with a new data
 ///        structure Template(Partial)SpecializationDecl, and
 ///        using Template(Partial)SpecializationDecl as input type.
 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
     VarTemplatePartialSpecializationDecl *D) {
   RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
 
-  D->TemplateParams = Record.ReadTemplateParameterList();
-  D->ArgsAsWritten = Record.ReadASTTemplateArgumentListInfo();
+  D->TemplateParams = Record.readTemplateParameterList();
+  D->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
 
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {
     D->InstantiatedFromMember.setPointer(
         ReadDeclAs<VarTemplatePartialSpecializationDecl>());
     D->InstantiatedFromMember.setInt(Record.readInt());
   }
 }
if (D->isExpandedParameterPack()) {
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
       new (&TypesAndInfos[I].first) QualType(Record.readType());
       TypesAndInfos[I].second = GetTypeSourceInfo();
     }
   } else {
     // Rest of NonTypeTemplateParmDecl.
     D->ParameterPack = Record.readInt();
     if (Record.readInt())
-      D->setDefaultArgument(Record.ReadExpr());
+      D->setDefaultArgument(Record.readExpr());
   }
 }
 
 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   VisitTemplateDecl(D);
   // TemplateParmPosition.
   D->setDepth(Record.readInt());
   D->setPosition(Record.readInt());
   if (D->isExpandedParameterPack()) {
     TemplateParameterList **Data =
         D->getTrailingObjects<TemplateParameterList *>();
     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
          I != N; ++I)
-      Data[I] = Record.ReadTemplateParameterList();
+      Data[I] = Record.readTemplateParameterList();
   } else {
     // Rest of TemplateTemplateParmDecl.
     D->ParameterPack = Record.readInt();
     if (Record.readInt())
       D->setDefaultArgument(Reader.getContext(),
-                            Record.ReadTemplateArgumentLoc());
+                            Record.readTemplateArgumentLoc());
   }
 }
 
 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
   VisitRedeclarableTemplateDecl(D);
 }
 
 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
   VisitDecl(D);
-  D->AssertExprAndFailed.setPointer(Record.ReadExpr());
+  D->AssertExprAndFailed.setPointer(Record.readExpr());
   D->AssertExprAndFailed.setInt(Record.readInt());
-  D->Message = cast_or_null<StringLiteral>(Record.ReadExpr());
+  D->Message = cast_or_null<StringLiteral>(Record.readExpr());
   D->RParenLoc = ReadSourceLocation();
 }
 
 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
   VisitDecl(D);
 }
 
 std::pair<uint64_t, uint64_t>

 }
 
 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
   VisitDecl(D);
   unsigned NumVars = D->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i) {
-    Vars.push_back(Record.ReadExpr());
+    Vars.push_back(Record.readExpr());
   }
   D->setVars(Vars);
 }
 
 void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
   VisitValueDecl(D);
   D->setLocation(ReadSourceLocation());
-  D->setCombiner(Record.ReadExpr());
-  D->setInitializer(Record.ReadExpr());
+  D->setCombiner(Record.readExpr());
+  D->setInitializer(Record.readExpr());
   D->PrevDeclInScope = ReadDeclID();
 }
 
 void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
   VisitVarDecl(D);
 }
 
 //===----------------------------------------------------------------------===//

 
 void ASTDeclReader::UpdateDecl(Decl *D) {
   while (Record.getIdx() < Record.size()) {
     switch ((DeclUpdateKind)Record.readInt()) {
     case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
       auto *RD = cast<CXXRecordDecl>(D);
       // FIXME: If we also have an update record for instantiating the
       // definition of D, we need that to happen before we get here.
-      Decl *MD = Record.ReadDecl();
+      Decl *MD = Record.readDecl();
       assert(MD && "couldn't read decl from update record");
       // FIXME: We should call addHiddenDecl instead, to add the member
       // to its DeclContext.
       RD->addedMember(MD);
       break;
     }
 
     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
       // It will be added to the template's specializations set when loaded.
-      (void)Record.ReadDecl();
+      (void)Record.readDecl();
       break;
 
     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
       NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>();
 
       // Each module has its own anonymous namespace, which is disjoint from
       // any other module's anonymous namespaces, so don't attach the anonymous
       // namespace at all.
case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
       break;
 
     case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: {
       auto Param = cast<ParmVarDecl>(D);
 
       // We have to read the default argument regardless of whether we use it
       // so that hypothetical further update records aren't messed up.
       // TODO: Add a function to skip over the next expr record.
-      auto DefaultArg = Record.ReadExpr();
+      auto DefaultArg = Record.readExpr();
 
       // Only apply the update if the parameter still has an uninstantiated
       // default argument.
       if (Param->hasUninstantiatedDefaultArg())
         Param->setDefaultArg(DefaultArg);
       break;
     }
 
     case UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER: {
       auto FD = cast<FieldDecl>(D);
-      auto DefaultInit = Record.ReadExpr();
+      auto DefaultInit = Record.readExpr();
 
       // Only apply the update if the field still has an uninstantiated
       // default member initializer.
       if (FD->hasInClassInitializer() && !FD->getInClassInitializer()) {
         if (DefaultInit)
           FD->setInClassInitializer(DefaultInit);
         else
           // Instantiation failed. We can get here if we serialized an AST for
case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
       bool HadRealDefinition =
           OldDD && (OldDD->Definition != RD ||
                     !Reader.PendingFakeDefinitionData.count(OldDD));
       ReadCXXRecordDefinition(RD, /*Update*/true);
 
       // Visible update is handled separately.
       uint64_t LexicalOffset = ReadLocalOffset();
       if (!HadRealDefinition && LexicalOffset) {
-        Record.ReadLexicalDeclContextStorage(LexicalOffset, RD);
+        Record.readLexicalDeclContextStorage(LexicalOffset, RD);
         Reader.PendingFakeDefinitionData.erase(OldDD);
       }
 
       auto TSK = (TemplateSpecializationKind)Record.readInt();
       SourceLocation POI = ReadSourceLocation();
       if (MemberSpecializationInfo *MSInfo =
               RD->getMemberSpecializationInfo()) {
         MSInfo->setTemplateSpecializationKind(TSK);
         MSInfo->setPointOfInstantiation(POI);
       } else {
         ClassTemplateSpecializationDecl *Spec =
             cast<ClassTemplateSpecializationDecl>(RD);
         Spec->setTemplateSpecializationKind(TSK);
         Spec->setPointOfInstantiation(POI);
 
         if (Record.readInt()) {
           auto PartialSpec =
               ReadDeclAs<ClassTemplatePartialSpecializationDecl>();
           SmallVector<TemplateArgument, 8> TemplArgs;
-          Record.ReadTemplateArgumentList(TemplArgs);
+          Record.readTemplateArgumentList(TemplArgs);
           auto *TemplArgList = TemplateArgumentList::CreateCopy(
               Reader.getContext(), TemplArgs);
 
           // FIXME: If we already have a partial specialization set,
           // check that it matches.
           if (!Spec->getSpecializedTemplateOrPartial()
                    .is<ClassTemplatePartialSpecializationDecl *>())
             Spec->setInstantiationOf(PartialSpec, TemplArgList);
         }
       }
 
       RD->setTagKind((TagTypeKind)Record.readInt());
       RD->setLocation(ReadSourceLocation());
       RD->setLocStart(ReadSourceLocation());
       RD->setBraceRange(ReadSourceRange());
 
       if (Record.readInt()) {
         AttrVec Attrs;
-        Record.ReadAttributes(Attrs);
+        Record.readAttributes(Attrs);
         // If the declaration already has attributes, we assume that some other
         // AST file already loaded them.
         if (!D->hasAttrs())
           D->setAttrsImpl(Attrs, Reader.getContext());
       }
       break;
     }
 
case UPD_DECL_EXPORTED: {
         Exported->Hidden = false;
       }
       break;
     }
 
     case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
     case UPD_ADDED_ATTR_TO_RECORD:
       AttrVec Attrs;
-      Record.ReadAttributes(Attrs);
+      Record.readAttributes(Attrs);
       assert(Attrs.size() == 1);
       D->addAttr(Attrs[0]);
       break;
     }
   }
 }

lib/Serialization/ASTReaderStmt.cpp

namespace clang {
 
   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
     friend class OMPClauseReader;
 
     ASTRecordReader &Record;
     llvm::BitstreamCursor &DeclsCursor;
 
     SourceLocation ReadSourceLocation() {
-      return Record.ReadSourceLocation();
+      return Record.readSourceLocation();
     }
 
     SourceRange ReadSourceRange() {
-      return Record.ReadSourceRange();
+      return Record.readSourceRange();
     }
 
     std::string ReadString() {
-      return Record.ReadString();
+      return Record.readString();
     }
 
     TypeSourceInfo *GetTypeSourceInfo() {
-      return Record.GetTypeSourceInfo();
+      return Record.getTypeSourceInfo();
     }
 
     Decl *ReadDecl() {
-      return Record.ReadDecl();
+      return Record.readDecl();
     }
 
     template<typename T>
     T *ReadDeclAs() {
-      return Record.ReadDeclAs<T>();
+      return Record.readDeclAs<T>();
     }
 
     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc,
                                 DeclarationName Name) {
-      Record.ReadDeclarationNameLoc(DNLoc, Name);
+      Record.readDeclarationNameLoc(DNLoc, Name);
     }
 
     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
-      Record.ReadDeclarationNameInfo(NameInfo);
+      Record.readDeclarationNameInfo(NameInfo);
     }
 
   public:
     ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
         : Record(Record), DeclsCursor(Cursor) {}
 
     /// \brief The number of record fields required for the Stmt class
     /// itself.

 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
                                               TemplateArgumentLoc *ArgsLocArray,
                                               unsigned NumTemplateArgs) {
   SourceLocation TemplateKWLoc = ReadSourceLocation();
   TemplateArgumentListInfo ArgInfo;
   ArgInfo.setLAngleLoc(ReadSourceLocation());
   ArgInfo.setRAngleLoc(ReadSourceLocation());
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
-    ArgInfo.addArgument(Record.ReadTemplateArgumentLoc());
+    ArgInfo.addArgument(Record.readTemplateArgumentLoc());
   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
 }
 
 void ASTStmtReader::VisitStmt(Stmt *S) {
   assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
 }
 
 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
   VisitStmt(S);
   S->setSemiLoc(ReadSourceLocation());
   S->HasLeadingEmptyMacro = Record.readInt();
 }
 
 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
   VisitStmt(S);
   SmallVector<Stmt *, 16> Stmts;
   unsigned NumStmts = Record.readInt();
   while (NumStmts--)
-    Stmts.push_back(Record.ReadSubStmt());
+    Stmts.push_back(Record.readSubStmt());
   S->setStmts(Record.getContext(), Stmts);
   S->LBraceLoc = ReadSourceLocation();
   S->RBraceLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
   VisitStmt(S);
-  Record.RecordSwitchCaseID(S, Record.readInt());
+  Record.recordSwitchCaseID(S, Record.readInt());
   S->setKeywordLoc(ReadSourceLocation());
   S->setColonLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
   VisitSwitchCase(S);
-  S->setLHS(Record.ReadSubExpr());
-  S->setRHS(Record.ReadSubExpr());
-  S->setSubStmt(Record.ReadSubStmt());
+  S->setLHS(Record.readSubExpr());
+  S->setRHS(Record.readSubExpr());
+  S->setSubStmt(Record.readSubStmt());
   S->setEllipsisLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
   VisitSwitchCase(S);
-  S->setSubStmt(Record.ReadSubStmt());
+  S->setSubStmt(Record.readSubStmt());
 }
 
 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
   VisitStmt(S);
   LabelDecl *LD = ReadDeclAs<LabelDecl>();
   LD->setStmt(S);
   S->setDecl(LD);
-  S->setSubStmt(Record.ReadSubStmt());
+  S->setSubStmt(Record.readSubStmt());
   S->setIdentLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
   VisitStmt(S);
   uint64_t NumAttrs = Record.readInt();
   AttrVec Attrs;
-  Record.ReadAttributes(Attrs);
+  Record.readAttributes(Attrs);
   (void)NumAttrs;
   assert(NumAttrs == S->NumAttrs);
   assert(NumAttrs == Attrs.size());
   std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
-  S->SubStmt = Record.ReadSubStmt();
+  S->SubStmt = Record.readSubStmt();
   S->AttrLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
   S->setConstexpr(Record.readInt());
-  S->setInit(Record.ReadSubStmt());
+  S->setInit(Record.readSubStmt());
   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
-  S->setCond(Record.ReadSubExpr());
-  S->setThen(Record.ReadSubStmt());
-  S->setElse(Record.ReadSubStmt());
+  S->setCond(Record.readSubExpr());
+  S->setThen(Record.readSubStmt());
+  S->setElse(Record.readSubStmt());
   S->setIfLoc(ReadSourceLocation());
   S->setElseLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
   VisitStmt(S);
-  S->setInit(Record.ReadSubStmt());
+  S->setInit(Record.readSubStmt());
   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
-  S->setCond(Record.ReadSubExpr());
-  S->setBody(Record.ReadSubStmt());
+  S->setCond(Record.readSubExpr());
+  S->setBody(Record.readSubStmt());
   S->setSwitchLoc(ReadSourceLocation());
   if (Record.readInt())
     S->setAllEnumCasesCovered();
 
   SwitchCase *PrevSC = nullptr;
   for (auto E = Record.size(); Record.getIdx() != E; ) {
     SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
     if (PrevSC)
       PrevSC->setNextSwitchCase(SC);
     else
       S->setSwitchCaseList(SC);
 
     PrevSC = SC;
   }
 }
 
 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
   VisitStmt(S);
   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
 
-  S->setCond(Record.ReadSubExpr());
-  S->setBody(Record.ReadSubStmt());
+  S->setCond(Record.readSubExpr());
+  S->setBody(Record.readSubStmt());
   S->setWhileLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
   VisitStmt(S);
-  S->setCond(Record.ReadSubExpr());
-  S->setBody(Record.ReadSubStmt());
+  S->setCond(Record.readSubExpr());
+  S->setBody(Record.readSubStmt());
   S->setDoLoc(ReadSourceLocation());
   S->setWhileLoc(ReadSourceLocation());
   S->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitForStmt(ForStmt *S) {
   VisitStmt(S);
-  S->setInit(Record.ReadSubStmt());
-  S->setCond(Record.ReadSubExpr());
+  S->setInit(Record.readSubStmt());
+  S->setCond(Record.readSubExpr());
   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
-  S->setInc(Record.ReadSubExpr());
-  S->setBody(Record.ReadSubStmt());
+  S->setInc(Record.readSubExpr());
+  S->setBody(Record.readSubStmt());
   S->setForLoc(ReadSourceLocation());
   S->setLParenLoc(ReadSourceLocation());
   S->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
   VisitStmt(S);
   S->setLabel(ReadDeclAs<LabelDecl>());
   S->setGotoLoc(ReadSourceLocation());
   S->setLabelLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
   VisitStmt(S);
   S->setGotoLoc(ReadSourceLocation());
   S->setStarLoc(ReadSourceLocation());
-  S->setTarget(Record.ReadSubExpr());
+  S->setTarget(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
   VisitStmt(S);
   S->setContinueLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
   VisitStmt(S);
   S->setBreakLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
   VisitStmt(S);
-  S->setRetValue(Record.ReadSubExpr());
+  S->setRetValue(Record.readSubExpr());
   S->setReturnLoc(ReadSourceLocation());
   S->setNRVOCandidate(ReadDeclAs<VarDecl>());
 }
 
 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
   VisitStmt(S);
   S->setStartLoc(ReadSourceLocation());
   S->setEndLoc(ReadSourceLocation());
void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
   S->setAsmLoc(ReadSourceLocation());
   S->setVolatile(Record.readInt());
   S->setSimple(Record.readInt());
 }
 
 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
   VisitAsmStmt(S);
   S->setRParenLoc(ReadSourceLocation());
-  S->setAsmString(cast_or_null<StringLiteral>(Record.ReadSubStmt()));
+  S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
 
   unsigned NumOutputs = S->getNumOutputs();
   unsigned NumInputs = S->getNumInputs();
   unsigned NumClobbers = S->getNumClobbers();
 
   // Outputs and inputs
   SmallVector<IdentifierInfo *, 16> Names;
   SmallVector<StringLiteral*, 16> Constraints;
   SmallVector<Stmt*, 16> Exprs;
   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
-    Names.push_back(Record.GetIdentifierInfo());
-    Constraints.push_back(cast_or_null<StringLiteral>(Record.ReadSubStmt()));
-    Exprs.push_back(Record.ReadSubStmt());
+    Names.push_back(Record.getIdentifierInfo());
+    Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
+    Exprs.push_back(Record.readSubStmt());
   }
 
   // Constraints
   SmallVector<StringLiteral*, 16> Clobbers;
   for (unsigned I = 0; I != NumClobbers; ++I)
-    Clobbers.push_back(cast_or_null<StringLiteral>(Record.ReadSubStmt()));
+    Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
 
   S->setOutputsAndInputsAndClobbers(Record.getContext(),
                                     Names.data(), Constraints.data(),
                                     Exprs.data(), NumOutputs, NumInputs,
                                     Clobbers.data(), NumClobbers);
 }
 
 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
   VisitAsmStmt(S);
   S->LBraceLoc = ReadSourceLocation();
   S->EndLoc = ReadSourceLocation();
   S->NumAsmToks = Record.readInt();
   std::string AsmStr = ReadString();
 
   // Read the tokens.
   SmallVector<Token, 16> AsmToks;
   AsmToks.reserve(S->NumAsmToks);
   for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
-    AsmToks.push_back(Record.ReadToken());
+    AsmToks.push_back(Record.readToken());
   }
 
   // The calls to reserve() for the FooData vectors are mandatory to
   // prevent dead StringRefs in the Foo vectors.
 
   // Read the clobbers.
   SmallVector<std::string, 16> ClobbersData;
   SmallVector<StringRef, 16> Clobbers;
   ClobbersData.reserve(S->NumClobbers);
   Clobbers.reserve(S->NumClobbers);
   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
     ClobbersData.push_back(ReadString());
     Clobbers.push_back(ClobbersData.back());
   }
 
   // Read the operands.
   unsigned NumOperands = S->NumOutputs + S->NumInputs;
   SmallVector<Expr*, 16> Exprs;
   SmallVector<std::string, 16> ConstraintsData;
   SmallVector<StringRef, 16> Constraints;
   Exprs.reserve(NumOperands);
   ConstraintsData.reserve(NumOperands);
   Constraints.reserve(NumOperands);
   for (unsigned i = 0; i != NumOperands; ++i) {
-    Exprs.push_back(cast<Expr>(Record.ReadSubStmt()));
+    Exprs.push_back(cast<Expr>(Record.readSubStmt()));
     ConstraintsData.push_back(ReadString());
     Constraints.push_back(ConstraintsData.back());
   }
 
   S->initialize(Record.getContext(), AsmStr, AsmToks,
                 Constraints, Exprs, Clobbers);
 }
 
void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
   S->setCapturedDecl(ReadDeclAs<CapturedDecl>());
   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>());
 
   // Capture inits
   for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
                                            E = S->capture_init_end();
        I != E; ++I)
-    *I = Record.ReadSubExpr();
+    *I = Record.readSubExpr();
 
   // Body
-  S->setCapturedStmt(Record.ReadSubStmt());
+  S->setCapturedStmt(Record.readSubStmt());
   S->getCapturedDecl()->setBody(S->getCapturedStmt());
 
   // Captures
   for (auto &I : S->captures()) {
     I.VarAndKind.setPointer(ReadDeclAs<VarDecl>());
     I.VarAndKind.setInt(
         static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
     I.Loc = ReadSourceLocation();
void ASTStmtReader::VisitExpr(Expr *E) {
   assert(Record.getIdx() == NumExprFields &&
          "Incorrect expression field count");
 }
 
 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
   E->Type = (PredefinedExpr::IdentType)Record.readInt();
-  E->FnName = cast_or_null<StringLiteral>(Record.ReadSubExpr());
+  E->FnName = cast_or_null<StringLiteral>(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
   VisitExpr(E);
 
   E->DeclRefExprBits.HasQualifier = Record.readInt();
   E->DeclRefExprBits.HasFoundDecl = Record.readInt();
   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
   E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
   E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
   unsigned NumTemplateArgs = 0;
   if (E->hasTemplateKWAndArgsInfo())
     NumTemplateArgs = Record.readInt();
 
   if (E->hasQualifier())
     new (E->getTrailingObjects<NestedNameSpecifierLoc>())
-        NestedNameSpecifierLoc(Record.ReadNestedNameSpecifierLoc());
+        NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
 
   if (E->hasFoundDecl())
     *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();
 
   if (E->hasTemplateKWAndArgsInfo())
     ReadTemplateKWAndArgsInfo(
         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
 
   E->setDecl(ReadDeclAs<ValueDecl>());
   E->setLocation(ReadSourceLocation());
   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
 }
 
 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
-  E->setValue(Record.getContext(), Record.ReadAPInt());
+  E->setValue(Record.getContext(), Record.readAPInt());
 }
 
 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
   VisitExpr(E);
   E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record.readInt()));
   E->setExact(Record.readInt());
-  E->setValue(Record.getContext(), Record.ReadAPFloat(E->getSemantics()));
+  E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
   E->setLocation(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
   VisitExpr(E);
-  E->setSubExpr(Record.ReadSubExpr());
+  E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
   VisitExpr(E);
   unsigned Len = Record.readInt();
   assert(Record.peekInt() == E->getNumConcatenated() &&
          "Wrong number of concatenated tokens!");
   Record.skipInts(1);
void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
   E->setLocation(ReadSourceLocation());
   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
 }
 
 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
   VisitExpr(E);
   E->setLParen(ReadSourceLocation());
   E->setRParen(ReadSourceLocation());
-  E->setSubExpr(Record.ReadSubExpr());
+  E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
   VisitExpr(E);
   unsigned NumExprs = Record.readInt();
   E->Exprs = new (Record.getContext()) Stmt*[NumExprs];
   for (unsigned i = 0; i != NumExprs; ++i)
-    E->Exprs[i] = Record.ReadSubStmt();
+    E->Exprs[i] = Record.readSubStmt();
   E->NumExprs = NumExprs;
   E->LParenLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
-  E->setSubExpr(Record.ReadSubExpr());
+  E->setSubExpr(Record.readSubExpr());
   E->setOpcode((UnaryOperator::Opcode)Record.readInt());
   E->setOperatorLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
   VisitExpr(E);
   assert(E->getNumComponents() == Record.peekInt());
   Record.skipInts(1);
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
     case OffsetOfNode::Field:
       E->setComponent(
           I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(), End));
       break;
 
     case OffsetOfNode::Identifier:
       E->setComponent(
           I,
-          OffsetOfNode(Start, Record.GetIdentifierInfo(), End));
+          OffsetOfNode(Start, Record.getIdentifierInfo(), End));
       break;
 
     case OffsetOfNode::Base: {
       CXXBaseSpecifier *Base = new (Record.getContext()) CXXBaseSpecifier();
-      *Base = Record.ReadCXXBaseSpecifier();
+      *Base = Record.readCXXBaseSpecifier();
       E->setComponent(I, OffsetOfNode(Base));
       break;
     }
     }
   }
 
   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
-    E->setIndexExpr(I, Record.ReadSubExpr());
+    E->setIndexExpr(I, Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
   VisitExpr(E);
   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
   if (Record.peekInt() == 0) {
-    E->setArgument(Record.ReadSubExpr());
+    E->setArgument(Record.readSubExpr());
     Record.skipInts(1);
   } else {
     E->setArgument(GetTypeSourceInfo());
   }
   E->setOperatorLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
-  E->setLHS(Record.ReadSubExpr());
-  E->setRHS(Record.ReadSubExpr());
+  E->setLHS(Record.readSubExpr());
+  E->setRHS(Record.readSubExpr());
   E->setRBracketLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
   VisitExpr(E);
-  E->setBase(Record.ReadSubExpr());
-  E->setLowerBound(Record.ReadSubExpr());
-  E->setLength(Record.ReadSubExpr());
+  E->setBase(Record.readSubExpr());
+  E->setLowerBound(Record.readSubExpr());
+  E->setLength(Record.readSubExpr());
   E->setColonLoc(ReadSourceLocation());
   E->setRBracketLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   E->setNumArgs(Record.getContext(), Record.readInt());
   E->setRParenLoc(ReadSourceLocation());
-  E->setCallee(Record.ReadSubExpr());
+  E->setCallee(Record.readSubExpr());
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
-    E->setArg(I, Record.ReadSubExpr());
+    E->setArg(I, Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   VisitCallExpr(E);
 }
 
 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
   // Don't call VisitExpr, this is fully initialized at creation.
   assert(E->getStmtClass() == Stmt::MemberExprClass &&
          "It's a subclass, we must advance Idx!");
 }
 
 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
   VisitExpr(E);
-  E->setBase(Record.ReadSubExpr());
+  E->setBase(Record.readSubExpr());
   E->setIsaMemberLoc(ReadSourceLocation());
   E->setOpLoc(ReadSourceLocation());
   E->setArrow(Record.readInt());
 }
 
 void ASTStmtReader::
 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
   VisitExpr(E);
-  E->Operand = Record.ReadSubExpr();
+  E->Operand = Record.readSubExpr();
   E->setShouldCopy(Record.readInt());
 }
 
 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
   VisitExplicitCastExpr(E);
   E->LParenLoc = ReadSourceLocation();
   E->BridgeKeywordLoc = ReadSourceLocation();
   E->Kind = Record.readInt();
 }
 
 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
   VisitExpr(E);
   unsigned NumBaseSpecs = Record.readInt();
   assert(NumBaseSpecs == E->path_size());
-  E->setSubExpr(Record.ReadSubExpr());
+  E->setSubExpr(Record.readSubExpr());
   E->setCastKind((CastKind)Record.readInt());
   CastExpr::path_iterator BaseI = E->path_begin();
   while (NumBaseSpecs--) {
     CXXBaseSpecifier *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
-    *BaseSpec = Record.ReadCXXBaseSpecifier();
+    *BaseSpec = Record.readCXXBaseSpecifier();
     *BaseI++ = BaseSpec;
   }
 }
 
 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
   VisitExpr(E);
-  E->setLHS(Record.ReadSubExpr());
-  E->setRHS(Record.ReadSubExpr());
+  E->setLHS(Record.readSubExpr());
+  E->setRHS(Record.readSubExpr());
   E->setOpcode((BinaryOperator::Opcode)Record.readInt());
   E->setOperatorLoc(ReadSourceLocation());
   E->setFPContractable((bool)Record.readInt());
 }
 
 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   VisitBinaryOperator(E);
   E->setComputationLHSType(Record.readType());
   E->setComputationResultType(Record.readType());
 }
 
 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
   VisitExpr(E);
-  E->SubExprs[ConditionalOperator::COND] = Record.ReadSubExpr();
-  E->SubExprs[ConditionalOperator::LHS] = Record.ReadSubExpr();
-  E->SubExprs[ConditionalOperator::RHS] = Record.ReadSubExpr();
+  E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
+  E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
+  E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
   E->QuestionLoc = ReadSourceLocation();
   E->ColonLoc = ReadSourceLocation();
 }
 
 void
 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
   VisitExpr(E);
-  E->OpaqueValue = cast<OpaqueValueExpr>(Record.ReadSubExpr());
-  E->SubExprs[BinaryConditionalOperator::COMMON] = Record.ReadSubExpr();
-  E->SubExprs[BinaryConditionalOperator::COND] = Record.ReadSubExpr();
-  E->SubExprs[BinaryConditionalOperator::LHS] = Record.ReadSubExpr();
-  E->SubExprs[BinaryConditionalOperator::RHS] = Record.ReadSubExpr();
+  E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
+  E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
+  E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
+  E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
+  E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
   E->QuestionLoc = ReadSourceLocation();
   E->ColonLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
   VisitCastExpr(E);
 }
 
 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   VisitCastExpr(E);
   E->setTypeInfoAsWritten(GetTypeSourceInfo());
 }
 
 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
   VisitExplicitCastExpr(E);
   E->setLParenLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   E->setLParenLoc(ReadSourceLocation());
   E->setTypeSourceInfo(GetTypeSourceInfo());
-  E->setInitializer(Record.ReadSubExpr());
+  E->setInitializer(Record.readSubExpr());
   E->setFileScope(Record.readInt());
 }
 
 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   VisitExpr(E);
-  E->setBase(Record.ReadSubExpr());
-  E->setAccessor(Record.GetIdentifierInfo());
+  E->setBase(Record.readSubExpr());
+  E->setAccessor(Record.getIdentifierInfo());
   E->setAccessorLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
   VisitExpr(E);
-  if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Record.ReadSubStmt()))
+  if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
     E->setSyntacticForm(SyntForm);
   E->setLBraceLoc(ReadSourceLocation());
   E->setRBraceLoc(ReadSourceLocation());
   bool isArrayFiller = Record.readInt();
   Expr *filler = nullptr;
   if (isArrayFiller) {
-    filler = Record.ReadSubExpr();
+    filler = Record.readSubExpr();
     E->ArrayFillerOrUnionFieldInit = filler;
   } else
     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>();
   E->sawArrayRangeDesignator(Record.readInt());
   unsigned NumInits = Record.readInt();
   E->reserveInits(Record.getContext(), NumInits);
   if (isArrayFiller) {
     for (unsigned I = 0; I != NumInits; ++I) {
-      Expr *init = Record.ReadSubExpr();
+      Expr *init = Record.readSubExpr();
       E->updateInit(Record.getContext(), I, init ? init : filler);
     }
   } else {
     for (unsigned I = 0; I != NumInits; ++I)
-      E->updateInit(Record.getContext(), I, Record.ReadSubExpr());
+      E->updateInit(Record.getContext(), I, Record.readSubExpr());
   }
 }
 
 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
   typedef DesignatedInitExpr::Designator Designator;
 
   VisitExpr(E);
   unsigned NumSubExprs = Record.readInt();
   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
   for (unsigned I = 0; I != NumSubExprs; ++I)
-    E->setSubExpr(I, Record.ReadSubExpr());
+    E->setSubExpr(I, Record.readSubExpr());
   E->setEqualOrColonLoc(ReadSourceLocation());
   E->setGNUSyntax(Record.readInt());
 
   SmallVector<Designator, 4> Designators;
   while (Record.getIdx() < Record.size()) {
     switch ((DesignatorTypes)Record.readInt()) {
     case DESIG_FIELD_DECL: {
       FieldDecl *Field = ReadDeclAs<FieldDecl>();
       SourceLocation DotLoc = ReadSourceLocation();
       SourceLocation FieldLoc = ReadSourceLocation();
       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
                                        FieldLoc));
       Designators.back().setField(Field);
       break;
     }
 
     case DESIG_FIELD_NAME: {
-      const IdentifierInfo *Name = Record.GetIdentifierInfo();
+      const IdentifierInfo *Name = Record.getIdentifierInfo();
       SourceLocation DotLoc = ReadSourceLocation();
       SourceLocation FieldLoc = ReadSourceLocation();
       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
       break;
     }
 
     case DESIG_ARRAY: {
       unsigned Index = Record.readInt();
while (Record.getIdx() < Record.size()) {
     }
   }
   E->setDesignators(Record.getContext(),
                     Designators.data(), Designators.size());
 }
 
 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
   VisitExpr(E);
-  E->setBase(Record.ReadSubExpr());
-  E->setUpdater(Record.ReadSubExpr());
+  E->setBase(Record.readSubExpr());
+  E->setUpdater(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
   VisitExpr(E);
 }
 
 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
   VisitExpr(E);
-  E->SubExprs[0] = Record.ReadSubExpr();
-  E->SubExprs[1] = Record.ReadSubExpr();
+  E->SubExprs[0] = Record.readSubExpr();
+  E->SubExprs[1] = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
   VisitExpr(E);
 }
 
 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
   VisitExpr(E);
 }
 
 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
   VisitExpr(E);
-  E->setSubExpr(Record.ReadSubExpr());
+  E->setSubExpr(Record.readSubExpr());
   E->setWrittenTypeInfo(GetTypeSourceInfo());
   E->setBuiltinLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
   E->setIsMicrosoftABI(Record.readInt());
 }
 
 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
   VisitExpr(E);
   E->setAmpAmpLoc(ReadSourceLocation());
   E->setLabelLoc(ReadSourceLocation());
   E->setLabel(ReadDeclAs<LabelDecl>());
 }
 
 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
   VisitExpr(E);
   E->setLParenLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
-  E->setSubStmt(cast_or_null<CompoundStmt>(Record.ReadSubStmt()));
+  E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
 }
 
 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
   VisitExpr(E);
-  E->setCond(Record.ReadSubExpr());
-  E->setLHS(Record.ReadSubExpr());
-  E->setRHS(Record.ReadSubExpr());
+  E->setCond(Record.readSubExpr());
+  E->setLHS(Record.readSubExpr());
+  E->setRHS(Record.readSubExpr());
   E->setBuiltinLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
   E->setIsConditionTrue(Record.readInt());
 }
 
 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
   VisitExpr(E);
   E->setTokenLocation(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   SmallVector<Expr *, 16> Exprs;
   unsigned NumExprs = Record.readInt();
   while (NumExprs--)
-    Exprs.push_back(Record.ReadSubExpr());
+    Exprs.push_back(Record.readSubExpr());
   E->setExprs(Record.getContext(), Exprs);
   E->setBuiltinLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
   VisitExpr(E);
   E->BuiltinLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
   E->TInfo = GetTypeSourceInfo();
-  E->SrcExpr = Record.ReadSubExpr();
+  E->SrcExpr = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
   VisitExpr(E);
   E->setBlockDecl(ReadDeclAs<BlockDecl>());
 }
 
 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
   VisitExpr(E);
   E->NumAssocs = Record.readInt();
   E->AssocTypes = new (Record.getContext()) TypeSourceInfo*[E->NumAssocs];
   E->SubExprs =
    new(Record.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
 
-  E->SubExprs[GenericSelectionExpr::CONTROLLING] = Record.ReadSubExpr();
+  E->SubExprs[GenericSelectionExpr::CONTROLLING] = Record.readSubExpr();
   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
     E->AssocTypes[I] = GetTypeSourceInfo();
-    E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.ReadSubExpr();
+    E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.readSubExpr();
   }
   E->ResultIndex = Record.readInt();
 
   E->GenericLoc = ReadSourceLocation();
   E->DefaultLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
   VisitExpr(E);
   unsigned numSemanticExprs = Record.readInt();
   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
   E->PseudoObjectExprBits.ResultIndex = Record.readInt();
 
   // Read the syntactic expression.
-  E->getSubExprsBuffer()[0] = Record.ReadSubExpr();
+  E->getSubExprsBuffer()[0] = Record.readSubExpr();
 
   // Read all the semantic expressions.
   for (unsigned i = 0; i != numSemanticExprs; ++i) {
-    Expr *subExpr = Record.ReadSubExpr();
+    Expr *subExpr = Record.readSubExpr();
     E->getSubExprsBuffer()[i+1] = subExpr;
   }
 }
 
 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
   VisitExpr(E);
   E->Op = AtomicExpr::AtomicOp(Record.readInt());
   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
   for (unsigned I = 0; I != E->NumSubExprs; ++I)
-    E->SubExprs[I] = Record.ReadSubExpr();
+    E->SubExprs[I] = Record.readSubExpr();
   E->BuiltinLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
 }
 
 //===----------------------------------------------------------------------===//
 // Objective-C Expressions and Statements
 
 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
   VisitExpr(E);
-  E->setString(cast<StringLiteral>(Record.ReadSubStmt()));
+  E->setString(cast<StringLiteral>(Record.readSubStmt()));
   E->setAtLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
   VisitExpr(E);
   // could be one of several IntegerLiteral, FloatLiteral, etc.
-  E->SubExpr = Record.ReadSubStmt();
+  E->SubExpr = Record.readSubStmt();
   E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>();
   E->Range = ReadSourceRange();
 }
 
 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
   VisitExpr(E);
   unsigned NumElements = Record.readInt();
   assert(NumElements == E->getNumElements() && "Wrong number of elements");
   Expr **Elements = E->getElements();
   for (unsigned I = 0, N = NumElements; I != N; ++I)
-    Elements[I] = Record.ReadSubExpr();
+    Elements[I] = Record.readSubExpr();
   E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
   E->Range = ReadSourceRange();
 }
 
 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
   VisitExpr(E);
   unsigned NumElements = Record.readInt();
   assert(NumElements == E->getNumElements() && "Wrong number of elements");
   bool HasPackExpansions = Record.readInt();
   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
   ObjCDictionaryLiteral::KeyValuePair *KeyValues =
       E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
   ObjCDictionaryLiteral::ExpansionData *Expansions =
       E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
   for (unsigned I = 0; I != NumElements; ++I) {
-    KeyValues[I].Key = Record.ReadSubExpr();
-    KeyValues[I].Value = Record.ReadSubExpr();
+    KeyValues[I].Key = Record.readSubExpr();
+    KeyValues[I].Value = Record.readSubExpr();
     if (HasPackExpansions) {
       Expansions[I].EllipsisLoc = ReadSourceLocation();
       Expansions[I].NumExpansionsPlusOne = Record.readInt();
     }
   }
   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
   E->Range = ReadSourceRange();
 }
 
 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
   VisitExpr(E);
   E->setEncodedTypeSourceInfo(GetTypeSourceInfo());
   E->setAtLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
   VisitExpr(E);
-  E->setSelector(Record.ReadSelector());
+  E->setSelector(Record.readSelector());
   E->setAtLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
   VisitExpr(E);
   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>());
   E->setAtLoc(ReadSourceLocation());
   E->ProtoLoc = ReadSourceLocation();
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
   VisitExpr(E);
   E->setDecl(ReadDeclAs<ObjCIvarDecl>());
   E->setLocation(ReadSourceLocation());
   E->setOpLoc(ReadSourceLocation());
-  E->setBase(Record.ReadSubExpr());
+  E->setBase(Record.readSubExpr());
   E->setIsArrow(Record.readInt());
   E->setIsFreeIvar(Record.readInt());
 }
 
 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
   VisitExpr(E);
   unsigned MethodRefFlags = Record.readInt();
   bool Implicit = Record.readInt() != 0;
   if (Implicit) {
     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>();
     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>();
     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
   } else {
     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
   }
   E->setLocation(ReadSourceLocation());
   E->setReceiverLocation(ReadSourceLocation());
   switch (Record.readInt()) {
   case 0:
-    E->setBase(Record.ReadSubExpr());
+    E->setBase(Record.readSubExpr());
     break;
   case 1:
     E->setSuperReceiver(Record.readType());
     break;
   case 2:
     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>());
     break;
   }
 }
 
 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
   VisitExpr(E);
   E->setRBracket(ReadSourceLocation());
-  E->setBaseExpr(Record.ReadSubExpr());
-  E->setKeyExpr(Record.ReadSubExpr());
+  E->setBaseExpr(Record.readSubExpr());
+  E->setKeyExpr(Record.readSubExpr());
   E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
   E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
 }
 
 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
   VisitExpr(E);
   assert(Record.peekInt() == E->getNumArgs());
   Record.skipInts(1);
   unsigned NumStoredSelLocs = Record.readInt();
   E->SelLocsKind = Record.readInt();
   E->setDelegateInitCall(Record.readInt());
   E->IsImplicit = Record.readInt();
   ObjCMessageExpr::ReceiverKind Kind
     = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
   switch (Kind) {
   case ObjCMessageExpr::Instance:
-    E->setInstanceReceiver(Record.ReadSubExpr());
+    E->setInstanceReceiver(Record.readSubExpr());
     break;
 
   case ObjCMessageExpr::Class:
     E->setClassReceiver(GetTypeSourceInfo());
     break;
 
   case ObjCMessageExpr::SuperClass:
   case ObjCMessageExpr::SuperInstance: {
     QualType T = Record.readType();
     SourceLocation SuperLoc = ReadSourceLocation();
     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
     break;
   }
   }
 
   assert(Kind == E->getReceiverKind());
 
   if (Record.readInt())
     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>());
   else
-    E->setSelector(Record.ReadSelector());
+    E->setSelector(Record.readSelector());
 
   E->LBracLoc = ReadSourceLocation();
   E->RBracLoc = ReadSourceLocation();
 
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
-    E->setArg(I, Record.ReadSubExpr());
+    E->setArg(I, Record.readSubExpr());
 
   SourceLocation *Locs = E->getStoredSelLocs();
   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
     Locs[I] = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
   VisitStmt(S);
-  S->setElement(Record.ReadSubStmt());
-  S->setCollection(Record.ReadSubExpr());
-  S->setBody(Record.ReadSubStmt());
+  S->setElement(Record.readSubStmt());
+  S->setCollection(Record.readSubExpr());
+  S->setBody(Record.readSubStmt());
   S->setForLoc(ReadSourceLocation());
   S->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
   VisitStmt(S);
-  S->setCatchBody(Record.ReadSubStmt());
+  S->setCatchBody(Record.readSubStmt());
   S->setCatchParamDecl(ReadDeclAs<VarDecl>());
   S->setAtCatchLoc(ReadSourceLocation());
   S->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
   VisitStmt(S);
-  S->setFinallyBody(Record.ReadSubStmt());
+  S->setFinallyBody(Record.readSubStmt());
   S->setAtFinallyLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
   VisitStmt(S);
-  S->setSubStmt(Record.ReadSubStmt());
+  S->setSubStmt(Record.readSubStmt());
   S->setAtLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
   VisitStmt(S);
   assert(Record.peekInt() == S->getNumCatchStmts());
   Record.skipInts(1);
   bool HasFinally = Record.readInt();
-  S->setTryBody(Record.ReadSubStmt());
+  S->setTryBody(Record.readSubStmt());
   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
-    S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.ReadSubStmt()));
+    S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
 
   if (HasFinally)
-    S->setFinallyStmt(Record.ReadSubStmt());
+    S->setFinallyStmt(Record.readSubStmt());
   S->setAtTryLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
   VisitStmt(S);
-  S->setSynchExpr(Record.ReadSubStmt());
-  S->setSynchBody(Record.ReadSubStmt());
+  S->setSynchExpr(Record.readSubStmt());
+  S->setSynchBody(Record.readSubStmt());
   S->setAtSynchronizedLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
   VisitStmt(S);
-  S->setThrowExpr(Record.ReadSubStmt());
+  S->setThrowExpr(Record.readSubStmt());
   S->setThrowLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
   VisitExpr(E);
   E->setValue(Record.readInt());
   E->setLocation(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
   VisitExpr(E);
-  SourceRange R = Record.ReadSourceRange();
+  SourceRange R = Record.readSourceRange();
   E->AtLoc = R.getBegin();
   E->RParen = R.getEnd();
-  E->VersionToCheck = Record.ReadVersionTuple();
+  E->VersionToCheck = Record.readVersionTuple();
 }
 
 //===----------------------------------------------------------------------===//
 // C++ Expressions and Statements
 //===----------------------------------------------------------------------===//
 
 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
   VisitStmt(S);
   S->CatchLoc = ReadSourceLocation();
   S->ExceptionDecl = ReadDeclAs<VarDecl>();
-  S->HandlerBlock = Record.ReadSubStmt();
+  S->HandlerBlock = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
   VisitStmt(S);
   assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
   Record.skipInts(1);
   S->TryLoc = ReadSourceLocation();
-  S->getStmts()[0] = Record.ReadSubStmt();
+  S->getStmts()[0] = Record.readSubStmt();
   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
-    S->getStmts()[i + 1] = Record.ReadSubStmt();
+    S->getStmts()[i + 1] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
   VisitStmt(S);
   S->ForLoc = ReadSourceLocation();
   S->CoawaitLoc = ReadSourceLocation();
   S->ColonLoc = ReadSourceLocation();
   S->RParenLoc = ReadSourceLocation();
-  S->setRangeStmt(Record.ReadSubStmt());
-  S->setBeginStmt(Record.ReadSubStmt());
-  S->setEndStmt(Record.ReadSubStmt());
-  S->setCond(Record.ReadSubExpr());
-  S->setInc(Record.ReadSubExpr());
-  S->setLoopVarStmt(Record.ReadSubStmt());
-  S->setBody(Record.ReadSubStmt());
+  S->setRangeStmt(Record.readSubStmt());
+  S->setBeginStmt(Record.readSubStmt());
+  S->setEndStmt(Record.readSubStmt());
+  S->setCond(Record.readSubExpr());
+  S->setInc(Record.readSubExpr());
+  S->setLoopVarStmt(Record.readSubStmt());
+  S->setBody(Record.readSubStmt());
 }
 
 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
   VisitStmt(S);
   S->KeywordLoc = ReadSourceLocation();
   S->IsIfExists = Record.readInt();
-  S->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  S->QualifierLoc = Record.readNestedNameSpecifierLoc();
   ReadDeclarationNameInfo(S->NameInfo);
-  S->SubStmt = Record.ReadSubStmt();
+  S->SubStmt = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
   VisitCallExpr(E);
   E->Operator = (OverloadedOperatorKind)Record.readInt();
-  E->Range = Record.ReadSourceRange();
+  E->Range = Record.readSourceRange();
   E->setFPContractable((bool)Record.readInt());
 }
 
 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
   VisitExpr(E);
   E->NumArgs = Record.readInt();
   if (E->NumArgs)
     E->Args = new (Record.getContext()) Stmt*[E->NumArgs];
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
-    E->setArg(I, Record.ReadSubExpr());
+    E->setArg(I, Record.readSubExpr());
   E->setConstructor(ReadDeclAs<CXXConstructorDecl>());
   E->setLocation(ReadSourceLocation());
   E->setElidable(Record.readInt());
   E->setHadMultipleCandidates(Record.readInt());
   E->setListInitialization(Record.readInt());
   E->setStdInitListInitialization(Record.readInt());
   E->setRequiresZeroInitialization(Record.readInt());
   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record.readInt());
void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
   E->ExplicitParams = Record.readInt();
   E->ExplicitResultType = Record.readInt();
   E->ClosingBrace = ReadSourceLocation();
 
   // Read capture initializers.
   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
                                       CEnd = E->capture_init_end();
        C != CEnd; ++C)
-    *C = Record.ReadSubExpr();
+    *C = Record.readSubExpr();
 }
 
 void
 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
   VisitExpr(E);
-  E->SubExpr = Record.ReadSubExpr();
+  E->SubExpr = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
   VisitExplicitCastExpr(E);
   SourceRange R = ReadSourceRange();
   E->Loc = R.getBegin();
   E->RParenLoc = R.getEnd();
   R = ReadSourceRange();
void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
   E->setSourceRange(ReadSourceRange());
   if (E->isTypeOperand()) { // typeid(int)
     E->setTypeOperandSourceInfo(
         GetTypeSourceInfo());
     return;
   }
 
   // typeid(42+2)
-  E->setExprOperand(Record.ReadSubExpr());
+  E->setExprOperand(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
   E->setImplicit(Record.readInt());
 }
 
 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
   VisitExpr(E);
   E->ThrowLoc = ReadSourceLocation();
-  E->Op = Record.ReadSubExpr();
+  E->Op = Record.readSubExpr();
   E->IsThrownVariableInScope = Record.readInt();
 }
 
 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
   VisitExpr(E);
   E->Param = ReadDeclAs<ParmVarDecl>();
   E->Loc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
   VisitExpr(E);
   E->Field = ReadDeclAs<FieldDecl>();
   E->Loc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
-  E->setTemporary(Record.ReadCXXTemporary());
-  E->setSubExpr(Record.ReadSubExpr());
+  E->setTemporary(Record.readCXXTemporary());
+  E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
   VisitExpr(E);
   E->TypeInfo = GetTypeSourceInfo();
   E->RParenLoc = ReadSourceLocation();
 }
 
void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
   E->DirectInitRange = ReadSourceRange();
 
   E->AllocateArgsArray(Record.getContext(), isArray, NumPlacementArgs,
                        E->StoredInitializationStyle != 0);
 
   // Install all the subexpressions.
   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
        I != e; ++I)
-    *I = Record.ReadSubStmt();
+    *I = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   VisitExpr(E);
   E->GlobalDelete = Record.readInt();
   E->ArrayForm = Record.readInt();
   E->ArrayFormAsWritten = Record.readInt();
   E->UsualArrayDeleteWantsSize = Record.readInt();
   E->OperatorDelete = ReadDeclAs<FunctionDecl>();
-  E->Argument = Record.ReadSubExpr();
+  E->Argument = Record.readSubExpr();
   E->Loc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
   VisitExpr(E);
 
-  E->Base = Record.ReadSubExpr();
+  E->Base = Record.readSubExpr();
   E->IsArrow = Record.readInt();
   E->OperatorLoc = ReadSourceLocation();
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
   E->ScopeType = GetTypeSourceInfo();
   E->ColonColonLoc = ReadSourceLocation();
   E->TildeLoc = ReadSourceLocation();
 
-  IdentifierInfo *II = Record.GetIdentifierInfo();
+  IdentifierInfo *II = Record.getIdentifierInfo();
   if (II)
     E->setDestroyedType(II, ReadSourceLocation());
   else
     E->setDestroyedType(GetTypeSourceInfo());
 }
 
 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
   VisitExpr(E);
 
   unsigned NumObjects = Record.readInt();
   assert(NumObjects == E->getNumObjects());
   for (unsigned i = 0; i != NumObjects; ++i)
     E->getTrailingObjects<BlockDecl *>()[i] =
         ReadDeclAs<BlockDecl>();
 
   E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
-  E->SubExpr = Record.ReadSubExpr();
+  E->SubExpr = Record.readSubExpr();
 }
 
 void
 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
   VisitExpr(E);
 
   if (Record.readInt()) // HasTemplateKWAndArgsInfo
     ReadTemplateKWAndArgsInfo(
         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
         E->getTrailingObjects<TemplateArgumentLoc>(),
         /*NumTemplateArgs=*/Record.readInt());
 
-  E->Base = Record.ReadSubExpr();
+  E->Base = Record.readSubExpr();
   E->BaseType = Record.readType();
   E->IsArrow = Record.readInt();
   E->OperatorLoc = ReadSourceLocation();
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>();
   ReadDeclarationNameInfo(E->MemberNameInfo);
 }
 
 void
 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
   VisitExpr(E);
 
   if (Record.readInt()) // HasTemplateKWAndArgsInfo
     ReadTemplateKWAndArgsInfo(
         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
         E->getTrailingObjects<TemplateArgumentLoc>(),
         /*NumTemplateArgs=*/Record.readInt());
 
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
   ReadDeclarationNameInfo(E->NameInfo);
 }
 
 void
 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
   VisitExpr(E);
   assert(Record.peekInt() == E->arg_size() &&
          "Read wrong record during creation ?");
   Record.skipInts(1);
   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
-    E->setArg(I, Record.ReadSubExpr());
+    E->setArg(I, Record.readSubExpr());
   E->Type = GetTypeSourceInfo();
   E->setLParenLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
   VisitExpr(E);
 
   if (Record.readInt()) // HasTemplateKWAndArgsInfo
     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
                               E->getTrailingTemplateArgumentLoc(),
                               /*NumTemplateArgs=*/Record.readInt());
 
   unsigned NumDecls = Record.readInt();
   UnresolvedSet<8> Decls;
   for (unsigned i = 0; i != NumDecls; ++i) {
     NamedDecl *D = ReadDeclAs<NamedDecl>();
     AccessSpecifier AS = (AccessSpecifier)Record.readInt();
     Decls.addDecl(D, AS);
   }
   E->initializeResults(Record.getContext(), Decls.begin(), Decls.end());
 
   ReadDeclarationNameInfo(E->NameInfo);
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
 }
 
 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
   VisitOverloadExpr(E);
   E->IsArrow = Record.readInt();
   E->HasUnresolvedUsing = Record.readInt();
-  E->Base = Record.ReadSubExpr();
+  E->Base = Record.readSubExpr();
   E->BaseType = Record.readType();
   E->OperatorLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
   VisitOverloadExpr(E);
   E->RequiresADL = Record.readInt();
   E->Overloaded = Record.readInt();

 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
   VisitExpr(E);
   E->ATT = (ArrayTypeTrait)Record.readInt();
   E->Value = (unsigned int)Record.readInt();
   SourceRange Range = ReadSourceRange();
   E->Loc = Range.getBegin();
   E->RParen = Range.getEnd();
   E->QueriedType = GetTypeSourceInfo();
-  E->Dimension = Record.ReadSubExpr();
+  E->Dimension = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
   VisitExpr(E);
   E->ET = (ExpressionTrait)Record.readInt();
   E->Value = (bool)Record.readInt();
   SourceRange Range = ReadSourceRange();
-  E->QueriedExpression = Record.ReadSubExpr();
+  E->QueriedExpression = Record.readSubExpr();
   E->Loc = Range.getBegin();
   E->RParen = Range.getEnd();
 }
 
 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
   VisitExpr(E);
   E->Value = (bool)Record.readInt();
   E->Range = ReadSourceRange();
-  E->Operand = Record.ReadSubExpr();
+  E->Operand = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
   VisitExpr(E);
   E->EllipsisLoc = ReadSourceLocation();
   E->NumExpansions = Record.readInt();
-  E->Pattern = Record.ReadSubExpr();
+  E->Pattern = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
   VisitExpr(E);
   unsigned NumPartialArgs = Record.readInt();
   E->OperatorLoc = ReadSourceLocation();
   E->PackLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
-  E->Pack = Record.ReadDeclAs<NamedDecl>();
+  E->Pack = Record.readDeclAs<NamedDecl>();
   if (E->isPartiallySubstituted()) {
     assert(E->Length == NumPartialArgs);
     for (auto *I = E->getTrailingObjects<TemplateArgument>(),
               *E = I + NumPartialArgs;
          I != E; ++I)
-      new (I) TemplateArgument(Record.ReadTemplateArgument());
+      new (I) TemplateArgument(Record.readTemplateArgument());
   } else if (!E->isValueDependent()) {
     E->Length = Record.readInt();
   }
 }
 
 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
                                               SubstNonTypeTemplateParmExpr *E) {
   VisitExpr(E);
   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
   E->NameLoc = ReadSourceLocation();
-  E->Replacement = Record.ReadSubExpr();
+  E->Replacement = Record.readSubExpr();
 }
 
 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
                                           SubstNonTypeTemplateParmPackExpr *E) {
   VisitExpr(E);
   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
-  TemplateArgument ArgPack = Record.ReadTemplateArgument();
+  TemplateArgument ArgPack = Record.readTemplateArgument();
   if (ArgPack.getKind() != TemplateArgument::Pack)
     return;
 
   E->Arguments = ArgPack.pack_begin();
   E->NumArguments = ArgPack.pack_size();
   E->NameLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
   VisitExpr(E);
   E->NumParameters = Record.readInt();
   E->ParamPack = ReadDeclAs<ParmVarDecl>();
   E->NameLoc = ReadSourceLocation();
   ParmVarDecl **Parms = E->getTrailingObjects<ParmVarDecl *>();
   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
     Parms[i] = ReadDeclAs<ParmVarDecl>();
 }
 
 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
   VisitExpr(E);
-  E->State = Record.ReadSubExpr();
+  E->State = Record.readSubExpr();
   auto VD = ReadDeclAs<ValueDecl>();
   unsigned ManglingNumber = Record.readInt();
   E->setExtendingDecl(VD, ManglingNumber);
 }
 
 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
   VisitExpr(E);
   E->LParenLoc = ReadSourceLocation();
   E->EllipsisLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
-  E->SubExprs[0] = Record.ReadSubExpr();
-  E->SubExprs[1] = Record.ReadSubExpr();
+  E->SubExprs[0] = Record.readSubExpr();
+  E->SubExprs[1] = Record.readSubExpr();
   E->Opcode = (BinaryOperatorKind)Record.readInt();
 }
 
 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
   VisitExpr(E);
-  E->SourceExpr = Record.ReadSubExpr();
+  E->SourceExpr = Record.readSubExpr();
   E->Loc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
   llvm_unreachable("Cannot read TypoExpr nodes");
 }
 
 //===----------------------------------------------------------------------===//
 // Microsoft Expressions and Statements
 //===----------------------------------------------------------------------===//
 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
   VisitExpr(E);
   E->IsArrow = (Record.readInt() != 0);
-  E->BaseExpr = Record.ReadSubExpr();
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+  E->BaseExpr = Record.readSubExpr();
+  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
   E->MemberLoc = ReadSourceLocation();
   E->TheDecl = ReadDeclAs<MSPropertyDecl>();
 }
 
 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
   VisitExpr(E);
-  E->setBase(Record.ReadSubExpr());
-  E->setIdx(Record.ReadSubExpr());
+  E->setBase(Record.readSubExpr());
+  E->setIdx(Record.readSubExpr());
   E->setRBracketLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
   VisitExpr(E);
   E->setSourceRange(ReadSourceRange());
   std::string UuidStr = ReadString();
   E->setUuidStr(StringRef(UuidStr).copy(Record.getContext()));
   if (E->isTypeOperand()) { // __uuidof(ComType)
     E->setTypeOperandSourceInfo(
         GetTypeSourceInfo());
     return;
   }
 
   // __uuidof(expr)
-  E->setExprOperand(Record.ReadSubExpr());
+  E->setExprOperand(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   S->setLeaveLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
   VisitStmt(S);
   S->Loc = ReadSourceLocation();
-  S->Children[SEHExceptStmt::FILTER_EXPR] = Record.ReadSubStmt();
-  S->Children[SEHExceptStmt::BLOCK] = Record.ReadSubStmt();
+  S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
+  S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
   VisitStmt(S);
   S->Loc = ReadSourceLocation();
-  S->Block = Record.ReadSubStmt();
+  S->Block = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
   VisitStmt(S);
   S->IsCXXTry = Record.readInt();
   S->TryLoc = ReadSourceLocation();
-  S->Children[SEHTryStmt::TRY] = Record.ReadSubStmt();
-  S->Children[SEHTryStmt::HANDLER] = Record.ReadSubStmt();
+  S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
+  S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
 }
 
 //===----------------------------------------------------------------------===//
 // CUDA Expressions and Statements
 //===----------------------------------------------------------------------===//
 
 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
   VisitCallExpr(E);
-  E->setConfig(cast<CallExpr>(Record.ReadSubExpr()));
+  E->setConfig(cast<CallExpr>(Record.readSubExpr()));
 }
 
 //===----------------------------------------------------------------------===//
 // OpenCL Expressions and Statements.
 //===----------------------------------------------------------------------===//
 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
   VisitExpr(E);
   E->BuiltinLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
-  E->SrcExpr = Record.ReadSubExpr();
+  E->SrcExpr = Record.readSubExpr();
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMP Clauses.
 //===----------------------------------------------------------------------===//
 
 namespace clang {
 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
OMPClause *OMPClauseReader::readClause() {
   Visit(C);
   C->setLocStart(Reader->ReadSourceLocation());
   C->setLocEnd(Reader->ReadSourceLocation());
 
   return C;
 }
 
 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
-  C->setPreInitStmt(Reader->Record.ReadSubStmt());
+  C->setPreInitStmt(Reader->Record.readSubStmt());
 }
 
 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
   VisitOMPClauseWithPreInit(C);
-  C->setPostUpdateExpr(Reader->Record.ReadSubExpr());
+  C->setPostUpdateExpr(Reader->Record.readSubExpr());
 }
 
 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
   C->setNameModifier(static_cast<OpenMPDirectiveKind>(Reader->Record.readInt()));
   C->setNameModifierLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
-  C->setCondition(Reader->Record.ReadSubExpr());
+  C->setCondition(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
-  C->setCondition(Reader->Record.ReadSubExpr());
+  C->setCondition(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
-  C->setNumThreads(Reader->Record.ReadSubExpr());
+  C->setNumThreads(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
-  C->setSafelen(Reader->Record.ReadSubExpr());
+  C->setSafelen(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
-  C->setSimdlen(Reader->Record.ReadSubExpr());
+  C->setSimdlen(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
-  C->setNumForLoops(Reader->Record.ReadSubExpr());
+  C->setNumForLoops(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
   C->setDefaultKind(
        static_cast<OpenMPDefaultClauseKind>(Reader->Record.readInt()));
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDefaultKindKwLoc(Reader->ReadSourceLocation());

 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
   VisitOMPClauseWithPreInit(C);
   C->setScheduleKind(
        static_cast<OpenMPScheduleClauseKind>(Reader->Record.readInt()));
   C->setFirstScheduleModifier(
       static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt()));
   C->setSecondScheduleModifier(
       static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt()));
-  C->setChunkSize(Reader->Record.ReadSubExpr());
+  C->setChunkSize(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation());
   C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation());
   C->setScheduleKindLoc(Reader->ReadSourceLocation());
   C->setCommaLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
-  C->setNumForLoops(Reader->Record.ReadSubExpr());
+  C->setNumForLoops(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
 
 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
 
 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}

 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
 
 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setPrivateCopies(Vars);
 }
 
 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
   VisitOMPClauseWithPreInit(C);
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setPrivateCopies(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setInits(Vars);
 }
 
 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
   VisitOMPClauseWithPostUpdate(C);
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setPrivateCopies(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setSourceExprs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setDestinationExprs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setAssignmentOps(Vars);
 }
 
 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
 }
 
 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
   VisitOMPClauseWithPostUpdate(C);
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
-  NestedNameSpecifierLoc NNSL = Reader->Record.ReadNestedNameSpecifierLoc();
+  NestedNameSpecifierLoc NNSL = Reader->Record.readNestedNameSpecifierLoc();
   DeclarationNameInfo DNI;
   Reader->ReadDeclarationNameInfo(DNI);
   C->setQualifierLoc(NNSL);
   C->setNameInfo(DNI);
 
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setPrivates(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setLHSExprs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setRHSExprs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setReductionOps(Vars);
 }
 
 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
   VisitOMPClauseWithPostUpdate(C);
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   C->setModifier(static_cast<OpenMPLinearClauseKind>(Reader->Record.readInt()));
   C->setModifierLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setPrivates(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setInits(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setUpdates(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setFinals(Vars);
-  C->setStep(Reader->Record.ReadSubExpr());
-  C->setCalcStep(Reader->Record.ReadSubExpr());
+  C->setStep(Reader->Record.readSubExpr());
+  C->setCalcStep(Reader->Record.readSubExpr());
 }
 
 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
-  C->setAlignment(Reader->Record.ReadSubExpr());
+  C->setAlignment(Reader->Record.readSubExpr());
 }
 
 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Exprs;
   Exprs.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Exprs);
   Exprs.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setSourceExprs(Exprs);
   Exprs.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setDestinationExprs(Exprs);
   Exprs.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setAssignmentOps(Exprs);
 }
 
 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Exprs;
   Exprs.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Exprs);
   Exprs.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setSourceExprs(Exprs);
   Exprs.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setDestinationExprs(Exprs);
   Exprs.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Exprs.push_back(Reader->Record.ReadSubExpr());
+    Exprs.push_back(Reader->Record.readSubExpr());
   C->setAssignmentOps(Exprs);
 }
 
 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
 }
 
 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDependencyKind(
       static_cast<OpenMPDependClauseKind>(Reader->Record.readInt()));
   C->setDependencyLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
-  C->setCounterValue(Reader->Record.ReadSubExpr());
+  C->setCounterValue(Reader->Record.readSubExpr());
 }
 
 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
-  C->setDevice(Reader->Record.ReadSubExpr());
+  C->setDevice(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setMapTypeModifier(
      static_cast<OpenMPMapClauseKind>(Reader->Record.readInt()));
   C->setMapType(
      static_cast<OpenMPMapClauseKind>(Reader->Record.readInt()));
   C->setMapLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   auto NumVars = C->varlist_size();
   auto UniqueDecls = C->getUniqueDeclarationsNum();
   auto TotalLists = C->getTotalComponentListNum();
   auto TotalComponents = C->getTotalComponentsNum();
 
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
 
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>());
+    Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
   C->setUniqueDecls(Decls);
 
   SmallVector<unsigned, 16> ListsPerDecl;
   ListsPerDecl.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
     ListsPerDecl.push_back(Reader->Record.readInt());
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
     ListSizes.push_back(Reader->Record.readInt());
   C->setComponentListSizes(ListSizes);
 
   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
   Components.reserve(TotalComponents);
   for (unsigned i = 0; i < TotalComponents; ++i) {
-    Expr *AssociatedExpr = Reader->Record.ReadSubExpr();
-    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
+    Expr *AssociatedExpr = Reader->Record.readSubExpr();
+    ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
   C->setComponents(Components, ListSizes);
 }
 
 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
-  C->setNumTeams(Reader->Record.ReadSubExpr());
+  C->setNumTeams(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
-  C->setThreadLimit(Reader->Record.ReadSubExpr());
+  C->setThreadLimit(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
-  C->setPriority(Reader->Record.ReadSubExpr());
+  C->setPriority(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
-  C->setGrainsize(Reader->Record.ReadSubExpr());
+  C->setGrainsize(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
-  C->setNumTasks(Reader->Record.ReadSubExpr());
+  C->setNumTasks(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
-  C->setHint(Reader->Record.ReadSubExpr());
+  C->setHint(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
   VisitOMPClauseWithPreInit(C);
   C->setDistScheduleKind(
       static_cast<OpenMPDistScheduleClauseKind>(Reader->Record.readInt()));
-  C->setChunkSize(Reader->Record.ReadSubExpr());
+  C->setChunkSize(Reader->Record.readSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDistScheduleKindLoc(Reader->ReadSourceLocation());
   C->setCommaLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
   C->setDefaultmapKind(
        static_cast<OpenMPDefaultmapClauseKind>(Reader->Record.readInt()));
void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
   auto NumVars = C->varlist_size();
   auto UniqueDecls = C->getUniqueDeclarationsNum();
   auto TotalLists = C->getTotalComponentListNum();
   auto TotalComponents = C->getTotalComponentsNum();
 
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
 
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>());
+    Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
   C->setUniqueDecls(Decls);
 
   SmallVector<unsigned, 16> ListsPerDecl;
   ListsPerDecl.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
     ListsPerDecl.push_back(Reader->Record.readInt());
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
     ListSizes.push_back(Reader->Record.readInt());
   C->setComponentListSizes(ListSizes);
 
   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
   Components.reserve(TotalComponents);
   for (unsigned i = 0; i < TotalComponents; ++i) {
-    Expr *AssociatedExpr = Reader->Record.ReadSubExpr();
-    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
+    Expr *AssociatedExpr = Reader->Record.readSubExpr();
+    ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
   C->setComponents(Components, ListSizes);
 }
 
 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   auto NumVars = C->varlist_size();
   auto UniqueDecls = C->getUniqueDeclarationsNum();
   auto TotalLists = C->getTotalComponentListNum();
   auto TotalComponents = C->getTotalComponentsNum();
 
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
 
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>());
+    Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
   C->setUniqueDecls(Decls);
 
   SmallVector<unsigned, 16> ListsPerDecl;
   ListsPerDecl.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
     ListsPerDecl.push_back(Reader->Record.readInt());
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
     ListSizes.push_back(Reader->Record.readInt());
   C->setComponentListSizes(ListSizes);
 
   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
   Components.reserve(TotalComponents);
   for (unsigned i = 0; i < TotalComponents; ++i) {
-    Expr *AssociatedExpr = Reader->Record.ReadSubExpr();
-    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
+    Expr *AssociatedExpr = Reader->Record.readSubExpr();
+    ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
   C->setComponents(Components, ListSizes);
 }
 
 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   auto NumVars = C->varlist_size();
   auto UniqueDecls = C->getUniqueDeclarationsNum();
   auto TotalLists = C->getTotalComponentListNum();
   auto TotalComponents = C->getTotalComponentsNum();
 
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setPrivateCopies(Vars);
   Vars.clear();
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setInits(Vars);
 
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>());
+    Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
   C->setUniqueDecls(Decls);
 
   SmallVector<unsigned, 16> ListsPerDecl;
   ListsPerDecl.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
     ListsPerDecl.push_back(Reader->Record.readInt());
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
     ListSizes.push_back(Reader->Record.readInt());
   C->setComponentListSizes(ListSizes);
 
   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
   Components.reserve(TotalComponents);
   for (unsigned i = 0; i < TotalComponents; ++i) {
-    Expr *AssociatedExpr = Reader->Record.ReadSubExpr();
-    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
+    Expr *AssociatedExpr = Reader->Record.readSubExpr();
+    ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
   C->setComponents(Components, ListSizes);
 }
 
 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   auto NumVars = C->varlist_size();
   auto UniqueDecls = C->getUniqueDeclarationsNum();
   auto TotalLists = C->getTotalComponentListNum();
   auto TotalComponents = C->getTotalComponentsNum();
 
   SmallVector<Expr *, 16> Vars;
   Vars.reserve(NumVars);
   for (unsigned i = 0; i != NumVars; ++i)
-    Vars.push_back(Reader->Record.ReadSubExpr());
+    Vars.push_back(Reader->Record.readSubExpr());
   C->setVarRefs(Vars);
   Vars.clear();
 
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>());
+    Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
   C->setUniqueDecls(Decls);
 
   SmallVector<unsigned, 16> ListsPerDecl;
   ListsPerDecl.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
     ListsPerDecl.push_back(Reader->Record.readInt());
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
     ListSizes.push_back(Reader->Record.readInt());
   C->setComponentListSizes(ListSizes);
 
   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
   Components.reserve(TotalComponents);
   for (unsigned i = 0; i < TotalComponents; ++i) {
-    Expr *AssociatedExpr = Reader->Record.ReadSubExpr();
-    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
+    Expr *AssociatedExpr = Reader->Record.readSubExpr();
+    ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
   C->setComponents(Components, ListSizes);
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   E->setLocStart(ReadSourceLocation());
   E->setLocEnd(ReadSourceLocation());
   OMPClauseReader ClauseReader(this, Record);
   SmallVector<OMPClause *, 5> Clauses;
   for (unsigned i = 0; i < E->getNumClauses(); ++i)
     Clauses.push_back(ClauseReader.readClause());
   E->setClauses(Clauses);
   if (E->hasAssociatedStmt())
-    E->setAssociatedStmt(Record.ReadSubStmt());
+    E->setAssociatedStmt(Record.readSubStmt());
 }
 
 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
   VisitStmt(D);
   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
   Record.skipInts(2);
   VisitOMPExecutableDirective(D);
-  D->setIterationVariable(Record.ReadSubExpr());
-  D->setLastIteration(Record.ReadSubExpr());
-  D->setCalcLastIteration(Record.ReadSubExpr());
-  D->setPreCond(Record.ReadSubExpr());
-  D->setCond(Record.ReadSubExpr());
-  D->setInit(Record.ReadSubExpr());
-  D->setInc(Record.ReadSubExpr());
-  D->setPreInits(Record.ReadSubStmt());
+  D->setIterationVariable(Record.readSubExpr());
+  D->setLastIteration(Record.readSubExpr());
+  D->setCalcLastIteration(Record.readSubExpr());
+  D->setPreCond(Record.readSubExpr());
+  D->setCond(Record.readSubExpr());
+  D->setInit(Record.readSubExpr());
+  D->setInc(Record.readSubExpr());
+  D->setPreInits(Record.readSubStmt());
   if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
       isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
       isOpenMPDistributeDirective(D->getDirectiveKind())) {
-    D->setIsLastIterVariable(Record.ReadSubExpr());
-    D->setLowerBoundVariable(Record.ReadSubExpr());
-    D->setUpperBoundVariable(Record.ReadSubExpr());
-    D->setStrideVariable(Record.ReadSubExpr());
-    D->setEnsureUpperBound(Record.ReadSubExpr());
-    D->setNextLowerBound(Record.ReadSubExpr());
-    D->setNextUpperBound(Record.ReadSubExpr());
-    D->setNumIterations(Record.ReadSubExpr());
+    D->setIsLastIterVariable(Record.readSubExpr());
+    D->setLowerBoundVariable(Record.readSubExpr());
+    D->setUpperBoundVariable(Record.readSubExpr());
+    D->setStrideVariable(Record.readSubExpr());
+    D->setEnsureUpperBound(Record.readSubExpr());
+    D->setNextLowerBound(Record.readSubExpr());
+    D->setNextUpperBound(Record.readSubExpr());
+    D->setNumIterations(Record.readSubExpr());
   }
   if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
-    D->setPrevLowerBoundVariable(Record.ReadSubExpr());
-    D->setPrevUpperBoundVariable(Record.ReadSubExpr());
+    D->setPrevLowerBoundVariable(Record.readSubExpr());
+    D->setPrevUpperBoundVariable(Record.readSubExpr());
   }
   SmallVector<Expr *, 4> Sub;
   unsigned CollapsedNum = D->getCollapsedNumber();
   Sub.reserve(CollapsedNum);
   for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.ReadSubExpr());
+    Sub.push_back(Record.readSubExpr());
   D->setCounters(Sub);
   Sub.clear();
   for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.ReadSubExpr());
+    Sub.push_back(Record.readSubExpr());
   D->setPrivateCounters(Sub);
   Sub.clear();
   for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.ReadSubExpr());
+    Sub.push_back(Record.readSubExpr());
   D->setInits(Sub);
   Sub.clear();
   for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.ReadSubExpr());
+    Sub.push_back(Record.readSubExpr());
   D->setUpdates(Sub);
   Sub.clear();
   for (unsigned i = 0; i < CollapsedNum; ++i)
-    Sub.push_back(Record.ReadSubExpr());
+    Sub.push_back(Record.readSubExpr());
   D->setFinals(Sub);
 }
 
 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
   Record.skipInts(1);
   VisitOMPExecutableDirective(D);
void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
   Record.skipInts(1);
   VisitOMPExecutableDirective(D);
-  D->setX(Record.ReadSubExpr());
-  D->setV(Record.ReadSubExpr());
-  D->setExpr(Record.ReadSubExpr());
-  D->setUpdateExpr(Record.ReadSubExpr());
+  D->setX(Record.readSubExpr());
+  D->setV(Record.readSubExpr());
+  D->setExpr(Record.readSubExpr());
+  D->setUpdateExpr(Record.readSubExpr());
   D->IsXLHSInRHSPart = Record.readInt() != 0;
   D->IsPostfixUpdate = Record.readInt() != 0;
 }
 
 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
   Record.skipInts(1);
while (true) {
     case EXPR_MEMBER: {
       // We load everything here and fully initialize it at creation.
       // That way we can use MemberExpr::Create and don't have to duplicate its
       // logic with a MemberExpr::CreateEmpty.
 
       assert(Record.getIdx() == 0);
       NestedNameSpecifierLoc QualifierLoc;
       if (Record.readInt()) { // HasQualifier.
-        QualifierLoc = Record.ReadNestedNameSpecifierLoc();
+        QualifierLoc = Record.readNestedNameSpecifierLoc();
       }
 
       SourceLocation TemplateKWLoc;
       TemplateArgumentListInfo ArgInfo;
       bool HasTemplateKWAndArgsInfo = Record.readInt();
       if (HasTemplateKWAndArgsInfo) {
-        TemplateKWLoc = Record.ReadSourceLocation();
+        TemplateKWLoc = Record.readSourceLocation();
         unsigned NumTemplateArgs = Record.readInt();
-        ArgInfo.setLAngleLoc(Record.ReadSourceLocation());
-        ArgInfo.setRAngleLoc(Record.ReadSourceLocation());
+        ArgInfo.setLAngleLoc(Record.readSourceLocation());
+        ArgInfo.setRAngleLoc(Record.readSourceLocation());
         for (unsigned i = 0; i != NumTemplateArgs; ++i)
-          ArgInfo.addArgument(Record.ReadTemplateArgumentLoc());
+          ArgInfo.addArgument(Record.readTemplateArgumentLoc());
       }
 
       bool HadMultipleCandidates = Record.readInt();
 
-      NamedDecl *FoundD = Record.ReadDeclAs<NamedDecl>();
+      NamedDecl *FoundD = Record.readDeclAs<NamedDecl>();
       AccessSpecifier AS = (AccessSpecifier)Record.readInt();
       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
 
       QualType T = Record.readType();
       ExprValueKind VK = static_cast<ExprValueKind>(Record.readInt());
       ExprObjectKind OK = static_cast<ExprObjectKind>(Record.readInt());
       Expr *Base = ReadSubExpr();
-      ValueDecl *MemberD = Record.ReadDeclAs<ValueDecl>();
-      SourceLocation MemberLoc = Record.ReadSourceLocation();
+      ValueDecl *MemberD = Record.readDeclAs<ValueDecl>();
+      SourceLocation MemberLoc = Record.readSourceLocation();
       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
       bool IsArrow = Record.readInt();
-      SourceLocation OperatorLoc = Record.ReadSourceLocation();
+      SourceLocation OperatorLoc = Record.readSourceLocation();
 
       S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
                              HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
                              VK, OK);
-      Record.ReadDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
+      Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
                                     MemberD->getDeclName());
       if (HadMultipleCandidates)
         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
       break;
     }
 
     case EXPR_BINARY_OPERATOR:
       S = new (Context) BinaryOperator(Empty);