Index: include/clang/Serialization/ASTReader.h
===================================================================
--- include/clang/Serialization/ASTReader.h
+++ include/clang/Serialization/ASTReader.h
@@ -47,6 +47,7 @@
 #include <vector>
 
 namespace llvm {
+  class BitstreamCursor;
   class MemoryBuffer;
   class APInt;
   class APSInt;
@@ -88,6 +89,7 @@
 class ASTReader;
 class ASTDeclReader;
 class ASTStmtReader;
+class ASTRecordReader;
 class TypeLocReader;
 struct HeaderFileInfo;
 class VersionTuple;
@@ -2189,29 +2191,45 @@
   typedef serialization::ModuleFile ModuleFile;
 
   ASTReader *Reader;
-  const ASTReader::RecordData *Record;
   ModuleFile *F;
+  unsigned Idx = 0;
+  ASTReader::RecordData Record;
 
   typedef ASTReader::RecordData RecordData;
   typedef ASTReader::RecordDataImpl RecordDataImpl;
 
 public:
   /// Construct an ASTRecordReader that uses the default encoding scheme.
-  ASTRecordReader(ASTReader &Reader, const ASTReader::RecordData &Record,
-                  ModuleFile& F)
-      : Reader(&Reader), Record(&Record), F(&F) {}
+  ASTRecordReader(ASTReader &Reader, ModuleFile &F)
+      : Reader(&Reader), F(&F) {}
 
-  /// Construct an ASTRecordReader that uses the same encoding scheme as another
-  /// ASTRecordReader.
-  ASTRecordReader(ASTRecordReader &Parent)
-      : Reader(Parent.Reader), Record(Parent.Record), F(Parent.F) {}
+  /// \brief Reads a record with id AbbrevID from Cursor, resetting the
+  /// internal state.
+  unsigned readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID);
 
+  /// \brief The current position in this record.
+  unsigned getIdx() const { return Idx; }
   /// \brief The length of this record.
-  size_t size() const { return Record->size(); }
+  size_t size() const { return Record.size(); }
+
   /// \brief An arbitrary index in this record.
-  const uint64_t &operator[](size_t N) { return (*Record)[N]; }
+  const uint64_t &operator[](size_t N) { return Record[N]; }
   /// \brief The last element in this record.
-  const uint64_t &back() const { return Record->back(); }
+  const uint64_t &back() const { return Record.back(); }
+
+  /// \brief Returns the current position in the record, and advances it.
+  uint64_t* operator++(int) { return Record.begin() + (Idx++); }
+  /// \brief Advances the position in the record, and returns the new position.
+  uint64_t* operator++() { return Record.begin() + (++Idx); }
+  /// \brief Returns the current value.
+  uint64_t& operator*() { return Record[Idx]; }
+  const uint64_t& operator*() const { return Record[Idx]; }
+
+  /// \brief Container-like access to iterators over the record.
+  uint64_t* begin() { return Record.begin(); }
+  uint64_t* end() { return Record.end(); }
+  const uint64_t* begin() const { return Record.begin(); }
+  const uint64_t* end() const { return Record.end(); }
 
   /// \brief Is this a module file for a module (rather than a PCH or similar).
   bool isModule() const { return F->isModule(); }
@@ -2244,9 +2262,8 @@
   }
 
   void readExceptionSpec(SmallVectorImpl<QualType> &ExceptionStorage,
-                         FunctionProtoType::ExceptionSpecInfo &ESI,
-                         unsigned &Index) {
-    return Reader->readExceptionSpec(*F, ExceptionStorage, ESI, *Record, Index);
+                         FunctionProtoType::ExceptionSpecInfo &ESI) {
+    return Reader->readExceptionSpec(*F, ExceptionStorage, ESI, Record, Idx);
   }
 
   /// \brief Get the global offset corresponding to a local offset.
@@ -2269,24 +2286,24 @@
   /// \brief Reads a TemplateArgumentLocInfo appropriate for the
   /// given TemplateArgument kind, advancing Idx.
   TemplateArgumentLocInfo
-  GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, unsigned &Idx) {
-    return Reader->GetTemplateArgumentLocInfo(*F, Kind, *Record, Idx);
+  GetTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
+    return Reader->GetTemplateArgumentLocInfo(*F, Kind, Record, Idx);
   }
 
   /// \brief Reads a TemplateArgumentLoc, advancing Idx.
   TemplateArgumentLoc
-  ReadTemplateArgumentLoc(unsigned &Idx) {
-    return Reader->ReadTemplateArgumentLoc(*F, *Record, Idx);
+  ReadTemplateArgumentLoc() {
+    return Reader->ReadTemplateArgumentLoc(*F, Record, Idx);
   }
 
   const ASTTemplateArgumentListInfo*
-  ReadASTTemplateArgumentListInfo(unsigned &Idx) {
-    return Reader->ReadASTTemplateArgumentListInfo(*F, *Record, Idx);
+  ReadASTTemplateArgumentListInfo() {
+    return Reader->ReadASTTemplateArgumentListInfo(*F, Record, Idx);
   }
 
   /// \brief Reads a declarator info from the given record, advancing Idx.
-  TypeSourceInfo *GetTypeSourceInfo(unsigned &Idx) {
-    return Reader->GetTypeSourceInfo(*F, *Record, Idx);
+  TypeSourceInfo *GetTypeSourceInfo() {
+    return Reader->GetTypeSourceInfo(*F, Record, Idx);
   }
 
   /// \brief Map a local type ID within a given AST file to a global type ID.
@@ -2295,21 +2312,21 @@
   }
 
   /// \brief Read a type from the current position in the record.
-  QualType readType(unsigned &Idx) {
-    return Reader->readType(*F, *Record, Idx);
+  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(unsigned &Idx) {
-    return Reader->ReadDeclID(*F, *Record, Idx);
+  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(unsigned &Idx) {
-    return Reader->ReadDecl(*F, *Record, Idx);
+  Decl *ReadDecl() {
+    return Reader->ReadDecl(*F, Record, Idx);
   }
 
   /// \brief Reads a declaration from the given position in the record,
@@ -2318,133 +2335,131 @@
   /// \returns The declaration read from this location, casted to the given
   /// result type.
   template<typename T>
-  T *ReadDeclAs(unsigned &Idx) {
-    return Reader->ReadDeclAs<T>(*F, *Record, Idx);
+  T *ReadDeclAs() {
+    return Reader->ReadDeclAs<T>(*F, Record, Idx);
   }
 
-  IdentifierInfo *GetIdentifierInfo(unsigned &Idx) {
-    return Reader->GetIdentifierInfo(*F, *Record, Idx);
+  IdentifierInfo *GetIdentifierInfo() {
+    return Reader->GetIdentifierInfo(*F, Record, Idx);
   }
 
   /// \brief Read a selector from the Record, advancing Idx.
-  Selector ReadSelector(unsigned &Idx) {
-    return Reader->ReadSelector(*F, *Record, Idx);
+  Selector ReadSelector() {
+    return Reader->ReadSelector(*F, Record, Idx);
   }
 
   /// \brief Read a declaration name, advancing Idx.
-  DeclarationName ReadDeclarationName(unsigned &Idx) {
-    return Reader->ReadDeclarationName(*F, *Record, Idx);
+  DeclarationName ReadDeclarationName() {
+    return Reader->ReadDeclarationName(*F, Record, Idx);
   }
-  void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
-                              unsigned &Idx) {
-    return Reader->ReadDeclarationNameLoc(*F, DNLoc, Name, *Record, Idx);
+  void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name) {
+    return Reader->ReadDeclarationNameLoc(*F, DNLoc, Name, Record, Idx);
   }
-  void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo, unsigned &Idx) {
-    return Reader->ReadDeclarationNameInfo(*F, NameInfo, *Record, Idx);
+  void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
+    return Reader->ReadDeclarationNameInfo(*F, NameInfo, Record, Idx);
   }
 
-  void ReadQualifierInfo(QualifierInfo &Info, unsigned &Idx) {
-    return Reader->ReadQualifierInfo(*F, Info, *Record, Idx);
+  void ReadQualifierInfo(QualifierInfo &Info) {
+    return Reader->ReadQualifierInfo(*F, Info, Record, Idx);
   }
 
-  NestedNameSpecifier *ReadNestedNameSpecifier(unsigned &Idx) {
-    return Reader->ReadNestedNameSpecifier(*F, *Record, Idx);
+  NestedNameSpecifier *ReadNestedNameSpecifier() {
+    return Reader->ReadNestedNameSpecifier(*F, Record, Idx);
   }
 
-  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc(unsigned &Idx) {
-    return Reader->ReadNestedNameSpecifierLoc(*F, *Record, Idx);
+  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
+    return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
   }
 
   /// \brief Read a template name, advancing Idx.
-  TemplateName ReadTemplateName(unsigned &Idx) {
-    return Reader->ReadTemplateName(*F, *Record, Idx);
+  TemplateName ReadTemplateName() {
+    return Reader->ReadTemplateName(*F, Record, Idx);
   }
 
   /// \brief Read a template argument, advancing Idx.
-  TemplateArgument ReadTemplateArgument(unsigned &Idx,
-                                        bool Canonicalize = false) {
-    return Reader->ReadTemplateArgument(*F, *Record, Idx, Canonicalize);
+  TemplateArgument ReadTemplateArgument(bool Canonicalize = false) {
+    return Reader->ReadTemplateArgument(*F, Record, Idx, Canonicalize);
   }
 
   /// \brief Read a template parameter list, advancing Idx.
-  TemplateParameterList *ReadTemplateParameterList(unsigned &Idx) {
-    return Reader->ReadTemplateParameterList(*F, *Record, Idx);
+  TemplateParameterList *ReadTemplateParameterList() {
+    return Reader->ReadTemplateParameterList(*F, Record, Idx);
   }
 
   /// \brief Read a template argument array, advancing Idx.
   void ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
-                                unsigned &Idx, bool Canonicalize = false) {
-    return Reader->ReadTemplateArgumentList(TemplArgs, *F, *Record, Idx,
+                                bool Canonicalize = false) {
+    return Reader->ReadTemplateArgumentList(TemplArgs, *F, Record, Idx,
                                             Canonicalize);
   }
 
   /// \brief Read a UnresolvedSet structure, advancing Idx.
-  void ReadUnresolvedSet(LazyASTUnresolvedSet &Set, unsigned &Idx) {
-    return Reader->ReadUnresolvedSet(*F, Set, *Record, Idx);
+  void ReadUnresolvedSet(LazyASTUnresolvedSet &Set) {
+    return Reader->ReadUnresolvedSet(*F, Set, Record, Idx);
   }
 
   /// \brief Read a C++ base specifier, advancing Idx.
-  CXXBaseSpecifier ReadCXXBaseSpecifier(unsigned &Idx) {
-    return Reader->ReadCXXBaseSpecifier(*F, *Record, Idx);
+  CXXBaseSpecifier ReadCXXBaseSpecifier() {
+    return Reader->ReadCXXBaseSpecifier(*F, Record, Idx);
   }
 
   /// \brief Read a CXXCtorInitializer array, advancing Idx.
-  CXXCtorInitializer **ReadCXXCtorInitializers(unsigned &Idx) {
-    return Reader->ReadCXXCtorInitializers(*F, *Record, Idx);
+  CXXCtorInitializer **ReadCXXCtorInitializers() {
+    return Reader->ReadCXXCtorInitializers(*F, Record, Idx);
   }
 
-  CXXTemporary *ReadCXXTemporary(unsigned &Idx) {
-    return Reader->ReadCXXTemporary(*F, *Record, Idx);
+  CXXTemporary *ReadCXXTemporary() {
+    return Reader->ReadCXXTemporary(*F, Record, Idx);
   }
 
   /// \brief Read a source location, advancing Idx.
-  SourceLocation ReadSourceLocation(unsigned &Idx) {
-    return Reader->ReadSourceLocation(*F, *Record, Idx);
+  SourceLocation ReadSourceLocation() {
+    return Reader->ReadSourceLocation(*F, Record, Idx);
   }
 
   /// \brief Read a source range, advancing Idx.
-  SourceRange ReadSourceRange(unsigned &Idx) {
-    return Reader->ReadSourceRange(*F, *Record, Idx);
+  SourceRange ReadSourceRange() {
+    return Reader->ReadSourceRange(*F, Record, Idx);
   }
 
   /// \brief Read an integral value, advancing Idx.
-  llvm::APInt ReadAPInt(unsigned &Idx) {
-    return Reader->ReadAPInt(*Record, Idx);
+  llvm::APInt ReadAPInt() {
+    return Reader->ReadAPInt(Record, Idx);
   }
 
   /// \brief Read a signed integral value, advancing Idx.
-  llvm::APSInt ReadAPSInt(unsigned &Idx) {
-    return Reader->ReadAPSInt(*Record, Idx);
+  llvm::APSInt ReadAPSInt() {
+    return Reader->ReadAPSInt(Record, Idx);
   }
 
   /// \brief Read a floating-point value, advancing Idx.
-  llvm::APFloat ReadAPFloat(const llvm::fltSemantics &Sem, unsigned &Idx) {
-    return Reader->ReadAPFloat(*Record, Sem,Idx);
+  llvm::APFloat ReadAPFloat(const llvm::fltSemantics &Sem) {
+    return Reader->ReadAPFloat(Record, Sem,Idx);
   }
 
   /// \brief Read a string, advancing Idx.
-  std::string ReadString(unsigned &Idx) {
-    return Reader->ReadString(*Record, Idx);
+  std::string ReadString() {
+    return Reader->ReadString(Record, Idx);
   }
 
   /// \brief Read a path, advancing Idx.
-  std::string ReadPath(unsigned &Idx) {
-    return Reader->ReadPath(*F, *Record, Idx);
+  std::string ReadPath() {
+    return Reader->ReadPath(*F, Record, Idx);
   }
 
   /// \brief Read a version tuple, advancing Idx.
-  VersionTuple ReadVersionTuple(unsigned &Idx) {
-    return ASTReader::ReadVersionTuple(*Record, Idx);
+  VersionTuple ReadVersionTuple() {
+    return ASTReader::ReadVersionTuple(Record, Idx);
   }
 
   /// \brief Reads attributes from the current stream position, advancing Idx.
-  void ReadAttributes(AttrVec &Attrs, unsigned &Idx) {
-    return Reader->ReadAttributes(*F, Attrs, *Record, Idx);
+  void ReadAttributes(AttrVec &Attrs) {
+    return Reader->ReadAttributes(*F, Attrs, Record, Idx);
   }
 
   /// \brief Reads a token out of a record, advancing Idx.
-  Token ReadToken(unsigned &Idx) {
-    return Reader->ReadToken(*F, *Record, Idx);
+  Token ReadToken() {
+    return Reader->ReadToken(*F, Record, Idx);
   }
 
   void RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
@@ -2456,6 +2471,49 @@
     return Reader->getSwitchCaseWithID(ID);
   }
 
+  uint64_t* operator+=(ptrdiff_t l) {
+    return &Record[Idx += l];
+  }
+
+private:
+  ptrdiff_t getIndex(const uint64_t* x) const {
+    assert(Record.begin() <= x && x <= Record.end() &&
+           "out of range comparison");
+    return x - Record.begin();
+  }
+
+  friend bool operator==(const ASTRecordReader& l, const uint64_t* r) {
+    return l.Idx == l.getIndex(r);
+  }
+  friend bool operator==(const uint64_t* l, const ASTRecordReader& r) {
+    return r == l;
+  }
+  friend bool operator!=(const ASTRecordReader& l, const uint64_t* r) {
+    return !(l == r);
+  }
+  friend bool operator!=(const uint64_t* l, const ASTRecordReader& r) {
+    return !(r == l);
+  }
+  friend bool operator<(const ASTRecordReader& l, const uint64_t* r) {
+    return l.Idx < l.getIndex(r);
+  }
+  friend bool operator<(const uint64_t* l, const ASTRecordReader& r) {
+    return r.getIndex(l) < r.Idx;
+  }
+  friend ptrdiff_t operator-(const ASTRecordReader& l, const uint64_t* r) {
+    return l.Idx - l.getIndex(r);
+  }
+  friend ptrdiff_t operator-(const uint64_t* l, const ASTRecordReader& r) {
+    return r.getIndex(l) - r.Idx;
+  }
+  friend uint64_t* operator+(ASTRecordReader& l, ptrdiff_t r) {
+    assert(l.Idx < l.Record.size() - r && "out of range arithmetic");
+    return l.Record.begin() + l.Idx + r;
+  }
+  friend const uint64_t* operator+(const ASTRecordReader& l, ptrdiff_t r) {
+    assert(l.Idx < l.Record.size() - r && "out of range arithmetic");
+    return l.Record.begin() + l.Idx + r;
+  }
 };
 
 /// \brief Helper class that saves the current stream position and
Index: lib/Serialization/ASTReader.cpp
===================================================================
--- lib/Serialization/ASTReader.cpp
+++ lib/Serialization/ASTReader.cpp
@@ -5836,17 +5836,27 @@
 }
 
 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
-  ASTRecordReader Reader;
+  ModuleFile *F;
+  ASTReader *Reader;
+  const ASTReader::RecordData &Record;
   unsigned &Idx;
 
   SourceLocation ReadSourceLocation() {
-    return Reader.ReadSourceLocation(Idx);
+    return Reader->ReadSourceLocation(*F, Record, Idx);
+  }
+
+  TypeSourceInfo *GetTypeSourceInfo() {
+    return Reader->GetTypeSourceInfo(*F, Record, Idx);
+  }
+
+  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
+    return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
   }
 
 public:
-  TypeLocReader(ASTReader &Reader, ModuleFile &F,
+  TypeLocReader(ModuleFile &F, ASTReader &Reader,
                 const ASTReader::RecordData &Record, unsigned &Idx)
-      : Reader(Reader, Record, F), Idx(Idx) {}
+      : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
 
   // We want compile-time assurance that we've enumerated all of
   // these, so unfortunately we have to declare them first, then
@@ -5867,10 +5877,10 @@
 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
   TL.setBuiltinLoc(ReadSourceLocation());
   if (TL.needsExtraLocalData()) {
-    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Reader[Idx++]));
-    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Reader[Idx++]));
-    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Reader[Idx++]));
-    TL.setModeAttr(Reader[Idx++]);
+    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
+    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
+    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
+    TL.setModeAttr(Record[Idx++]);
   }
 }
 
@@ -5904,14 +5914,14 @@
 
 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
   TL.setStarLoc(ReadSourceLocation());
-  TL.setClassTInfo(Reader.GetTypeSourceInfo(Idx));
+  TL.setClassTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
   TL.setLBracketLoc(ReadSourceLocation());
   TL.setRBracketLoc(ReadSourceLocation());
-  if (Reader[Idx++])
-    TL.setSizeExpr(Reader.ReadExpr());
+  if (Record[Idx++])
+    TL.setSizeExpr(Reader->ReadExpr(*F));
   else
     TL.setSizeExpr(nullptr);
 }
@@ -5952,7 +5962,7 @@
   TL.setRParenLoc(ReadSourceLocation());
   TL.setLocalRangeEnd(ReadSourceLocation());
   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
-    TL.setParam(i, Reader.ReadDeclAs<ParmVarDecl>(Idx));
+    TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
   }
 }
 
@@ -5978,7 +5988,7 @@
   TL.setTypeofLoc(ReadSourceLocation());
   TL.setLParenLoc(ReadSourceLocation());
   TL.setRParenLoc(ReadSourceLocation());
-  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(Idx));
+  TL.setUnderlyingTInfo(GetTypeSourceInfo());
 }
 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
   TL.setNameLoc(ReadSourceLocation());
@@ -5988,7 +5998,7 @@
   TL.setKWLoc(ReadSourceLocation());
   TL.setLParenLoc(ReadSourceLocation());
   TL.setRParenLoc(ReadSourceLocation());
-  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(Idx));
+  TL.setUnderlyingTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
@@ -6012,8 +6022,8 @@
     TL.setAttrOperandParensRange(range);
   }
   if (TL.hasAttrExprOperand()) {
-    if (Reader[Idx++])
-      TL.setAttrExprOperand(Reader.ReadExpr());
+    if (Record[Idx++])
+      TL.setAttrExprOperand(Reader->ReadExpr(*F));
     else
       TL.setAttrExprOperand(nullptr);
   } else if (TL.hasAttrEnumOperand())
@@ -6039,9 +6049,10 @@
   TL.setLAngleLoc(ReadSourceLocation());
   TL.setRAngleLoc(ReadSourceLocation());
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
-    TL.setArgLocInfo(i,
-        Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(i).getKind(),
-                                          Idx));
+    TL.setArgLocInfo(
+        i,
+        Reader->GetTemplateArgumentLocInfo(
+            *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
 }
 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
   TL.setLParenLoc(ReadSourceLocation());
@@ -6050,7 +6061,7 @@
 
 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
   TL.setElaboratedKeywordLoc(ReadSourceLocation());
-  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(Idx));
+  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
 }
 
 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
@@ -6059,22 +6070,23 @@
 
 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
   TL.setElaboratedKeywordLoc(ReadSourceLocation());
-  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(Idx));
+  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
   TL.setNameLoc(ReadSourceLocation());
 }
 
 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
        DependentTemplateSpecializationTypeLoc TL) {
   TL.setElaboratedKeywordLoc(ReadSourceLocation());
-  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(Idx));
+  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
   TL.setTemplateKeywordLoc(ReadSourceLocation());
   TL.setTemplateNameLoc(ReadSourceLocation());
   TL.setLAngleLoc(ReadSourceLocation());
   TL.setRAngleLoc(ReadSourceLocation());
   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
-    TL.setArgLocInfo(I,
-        Reader.GetTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(),
-                                          Idx));
+    TL.setArgLocInfo(
+        I,
+        Reader->GetTemplateArgumentLocInfo(
+            *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
 }
 
 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
@@ -6095,11 +6107,11 @@
 }
 
 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
-  TL.setHasBaseTypeAsWritten(Reader[Idx++]);
+  TL.setHasBaseTypeAsWritten(Record[Idx++]);
   TL.setTypeArgsLAngleLoc(ReadSourceLocation());
   TL.setTypeArgsRAngleLoc(ReadSourceLocation());
   for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
-    TL.setTypeArgTInfo(i, Reader.GetTypeSourceInfo(Idx));
+    TL.setTypeArgTInfo(i, GetTypeSourceInfo());
   TL.setProtocolLAngleLoc(ReadSourceLocation());
   TL.setProtocolRAngleLoc(ReadSourceLocation());
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
@@ -6120,15 +6132,15 @@
   TL.setKWLoc(ReadSourceLocation());
 }
 
-TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
-                                             const RecordData &Record,
-                                             unsigned &Idx) {
+TypeSourceInfo *
+ASTReader::GetTypeSourceInfo(ModuleFile &F, const ASTReader::RecordData &Record,
+                             unsigned &Idx) {
   QualType InfoTy = readType(F, Record, Idx);
   if (InfoTy.isNull())
     return nullptr;
 
   TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
-  TypeLocReader TLR(*this, F, Record, Idx);
+  TypeLocReader TLR(F, *this, Record, Idx);
   for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
     TLR.Visit(TL);
   return TInfo;
@@ -8910,3 +8922,10 @@
 IdentifierResolver &ASTReader::getIdResolver() {
   return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
 }
+
+unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
+                                     unsigned AbbrevID) {
+  Idx = 0;
+  Record.clear();
+  return Cursor.readRecord(AbbrevID, Record);
+}
Index: lib/Serialization/ASTReaderDecl.cpp
===================================================================
--- lib/Serialization/ASTReaderDecl.cpp
+++ lib/Serialization/ASTReaderDecl.cpp
@@ -35,12 +35,11 @@
 namespace clang {
   class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
     ASTReader &Reader;
-    ASTRecordReader Record;
+    ASTRecordReader &Record;
     ASTReader::RecordLocation Loc;
     const DeclID ThisDeclID;
     const SourceLocation ThisDeclLoc;
     typedef ASTReader::RecordData RecordData;
-    unsigned &Idx;
     TypeID TypeIDForTypeDecl;
     unsigned AnonymousDeclNumber;
     GlobalDeclID NamedDeclForTagDecl;
@@ -56,7 +55,7 @@
     uint64_t GetCurrentCursorOffset();
 
     uint64_t ReadLocalOffset() {
-      uint64_t LocalOffset = Record[Idx++];
+      uint64_t LocalOffset = *Record++;
       assert(LocalOffset < Loc.Offset && "offset point after current record");
       return LocalOffset ? Loc.Offset - LocalOffset : 0;
     }
@@ -67,56 +66,52 @@
     }
 
     SourceLocation ReadSourceLocation() {
-      return Record.ReadSourceLocation(Idx);
+      return Record.ReadSourceLocation();
     }
 
     SourceRange ReadSourceRange() {
-      return Record.ReadSourceRange(Idx);
+      return Record.ReadSourceRange();
     }
 
     TypeSourceInfo *GetTypeSourceInfo() {
-      return Record.GetTypeSourceInfo(Idx);
+      return Record.GetTypeSourceInfo();
     }
 
     serialization::DeclID ReadDeclID() {
-      return Record.ReadDeclID(Idx);
+      return Record.ReadDeclID();
     }
 
     std::string ReadString() {
-      return Record.ReadString(Idx);
+      return Record.ReadString();
     }
 
     void ReadDeclIDList(SmallVectorImpl<DeclID> &IDs) {
-      for (unsigned I = 0, Size = Record[Idx++]; I != Size; ++I)
+      for (unsigned I = 0, Size = *Record++; I != Size; ++I)
         IDs.push_back(ReadDeclID());
     }
 
     Decl *ReadDecl() {
-      return Record.ReadDecl(Idx);
+      return Record.ReadDecl();
     }
 
     template<typename T>
     T *ReadDeclAs() {
-      return Record.ReadDeclAs<T>(Idx);
+      return Record.ReadDeclAs<T>();
     }
 
     void ReadQualifierInfo(QualifierInfo &Info) {
-      Record.ReadQualifierInfo(Info, Idx);
+      Record.ReadQualifierInfo(Info);
     }
 
     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name) {
-      Record.ReadDeclarationNameLoc(DNLoc, Name, Idx);
-    }
-
-    void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo, unsigned &I) {
-      Record.ReadDeclarationNameInfo(NameInfo, I);
+      Record.ReadDeclarationNameLoc(DNLoc, Name);
     }
 
     serialization::SubmoduleID readSubmoduleID() {
-      if (Idx >= Record.size())
+      if (Record == Record.end())
         return 0;
 
-      return Record.getGlobalSubmoduleID(Record[Idx++]);
+      return Record.getGlobalSubmoduleID(*Record++);
     }
 
     Module *readModule() {
@@ -124,12 +119,10 @@
     }
 
     void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update);
-    void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
-                               unsigned &I);
+    void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data);
     void MergeDefinitionData(CXXRecordDecl *D,
                              struct CXXRecordDecl::DefinitionData &&NewDD);
-    void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data,
-                                unsigned &I);
+    void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data);
     void MergeDefinitionData(ObjCInterfaceDecl *D,
                              struct ObjCInterfaceDecl::DefinitionData &&NewDD);
 
@@ -213,12 +206,12 @@
     FindExistingResult findExisting(NamedDecl *D);
 
   public:
-    ASTDeclReader(ASTReader &Reader, ASTReader::RecordLocation Loc,
-                  DeclID thisDeclID, SourceLocation ThisDeclLoc,
-                  const RecordData &Record, unsigned &Idx)
-        : Reader(Reader), Record(Reader, Record, *Loc.F), Loc(Loc),
+    ASTDeclReader(ASTReader &Reader, ASTRecordReader &Record,
+                  ASTReader::RecordLocation Loc,
+                  DeclID thisDeclID, SourceLocation ThisDeclLoc)
+        : Reader(Reader), Record(Record), Loc(Loc),
           ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc),
-          Idx(Idx), TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
+          TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
           TypedefNameForLinkage(nullptr), HasPendingBody(false),
           IsDeclMarkedUsed(false) {}
 
@@ -463,9 +456,9 @@
     // We only read it if FD doesn't already have a body (e.g., from another
     // module).
     // FIXME: Can we diagnose ODR violations somehow?
-    if (Record[Idx++]) {
+    if (*Record++) {
       if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
-        CD->NumCtorInitializers = Record[Idx++];
+        CD->NumCtorInitializers = *Record++;
         if (CD->NumCtorInitializers)
           CD->CtorInitializers = ReadGlobalOffset();
       }
@@ -504,22 +497,22 @@
                            Reader.getContext());
   }
   D->setLocation(ThisDeclLoc);
-  D->setInvalidDecl(Record[Idx++]);
-  if (Record[Idx++]) { // hasAttrs
+  D->setInvalidDecl(*Record++);
+  if (*Record++) { // hasAttrs
     AttrVec Attrs;
-    Record.ReadAttributes(Attrs, Idx);
+    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[Idx++]);
-  D->Used = Record[Idx++];
+  D->setImplicit(*Record++);
+  D->Used = *Record++;
   IsDeclMarkedUsed |= D->Used;
-  D->setReferenced(Record[Idx++]);
-  D->setTopLevelDeclInObjCContainer(Record[Idx++]);
-  D->setAccess((AccessSpecifier)Record[Idx++]);
+  D->setReferenced(*Record++);
+  D->setTopLevelDeclInObjCContainer(*Record++);
+  D->setAccess((AccessSpecifier)*Record++);
   D->FromASTFile = true;
-  D->setModulePrivate(Record[Idx++]);
+  D->setModulePrivate(*Record++);
   D->Hidden = D->isModulePrivate();
 
   // Determine whether this declaration is part of a (sub)module. If so, it
@@ -551,7 +544,7 @@
 void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
   VisitDecl(D);
   D->setLocation(ReadSourceLocation());
-  D->CommentKind = (PragmaMSCommentKind)Record[Idx++];
+  D->CommentKind = (PragmaMSCommentKind)*Record++;
   std::string Arg = ReadString();
   memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
   D->getTrailingObjects<char>()[Arg.size()] = '\0';
@@ -577,15 +570,15 @@
 
 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
   VisitDecl(ND);
-  ND->setDeclName(Record.ReadDeclarationName(Idx));
-  AnonymousDeclNumber = Record[Idx++];
+  ND->setDeclName(Record.ReadDeclarationName());
+  AnonymousDeclNumber = *Record++;
 }
 
 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[Idx++]);
+  TypeIDForTypeDecl = Record.getGlobalTypeID(*Record++);
 }
 
 ASTDeclReader::RedeclarableResult
@@ -593,8 +586,8 @@
   RedeclarableResult Redecl = VisitRedeclarable(TD);
   VisitTypeDecl(TD);
   TypeSourceInfo *TInfo = GetTypeSourceInfo();
-  if (Record[Idx++]) { // isModed
-    QualType modedT = Record.readType(Idx);
+  if (*Record++) { // isModed
+    QualType modedT = Record.readType();
     TD->setModedTypeSourceInfo(TInfo, modedT);
   } else
     TD->setTypeSourceInfo(TInfo);
@@ -619,16 +612,16 @@
   RedeclarableResult Redecl = VisitRedeclarable(TD);
   VisitTypeDecl(TD);
   
-  TD->IdentifierNamespace = Record[Idx++];
-  TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
+  TD->IdentifierNamespace = *Record++;
+  TD->setTagKind((TagDecl::TagKind)*Record++);
   if (!isa<CXXRecordDecl>(TD))
-    TD->setCompleteDefinition(Record[Idx++]);
-  TD->setEmbeddedInDeclarator(Record[Idx++]);
-  TD->setFreeStanding(Record[Idx++]);
-  TD->setCompleteDefinitionRequired(Record[Idx++]);
+    TD->setCompleteDefinition(*Record++);
+  TD->setEmbeddedInDeclarator(*Record++);
+  TD->setFreeStanding(*Record++);
+  TD->setCompleteDefinitionRequired(*Record++);
   TD->setBraceRange(ReadSourceRange());
   
-  switch (Record[Idx++]) {
+  switch (*Record++) {
   case 0:
     break;
   case 1: { // ExtInfo
@@ -639,7 +632,7 @@
   }
   case 2: // TypedefNameForAnonDecl
     NamedDeclForTagDecl = ReadDeclID();
-    TypedefNameForLinkage = Record.GetIdentifierInfo(Idx);
+    TypedefNameForLinkage = Record.GetIdentifierInfo();
     break;
   default:
     llvm_unreachable("unexpected tag info kind");
@@ -655,13 +648,13 @@
   if (TypeSourceInfo *TI = GetTypeSourceInfo())
     ED->setIntegerTypeSourceInfo(TI);
   else
-    ED->setIntegerType(Record.readType(Idx));
-  ED->setPromotionType(Record.readType(Idx));
-  ED->setNumPositiveBits(Record[Idx++]);
-  ED->setNumNegativeBits(Record[Idx++]);
-  ED->IsScoped = Record[Idx++];
-  ED->IsScopedUsingClassTag = Record[Idx++];
-  ED->IsFixed = Record[Idx++];
+    ED->setIntegerType(Record.readType());
+  ED->setPromotionType(Record.readType());
+  ED->setNumPositiveBits(*Record++);
+  ED->setNumNegativeBits(*Record++);
+  ED->IsScoped = *Record++;
+  ED->IsScopedUsingClassTag = *Record++;
+  ED->IsFixed = *Record++;
 
   // If this is a definition subject to the ODR, and we already have a
   // definition, merge this one into it.
@@ -689,7 +682,7 @@
   }
 
   if (EnumDecl *InstED = ReadDeclAs<EnumDecl>()) {
-    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
+    TemplateSpecializationKind TSK = (TemplateSpecializationKind)*Record++;
     SourceLocation POI = ReadSourceLocation();
     ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
     ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
@@ -699,30 +692,30 @@
 ASTDeclReader::RedeclarableResult
 ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
   RedeclarableResult Redecl = VisitTagDecl(RD);
-  RD->setHasFlexibleArrayMember(Record[Idx++]);
-  RD->setAnonymousStructOrUnion(Record[Idx++]);
-  RD->setHasObjectMember(Record[Idx++]);
-  RD->setHasVolatileMember(Record[Idx++]);
+  RD->setHasFlexibleArrayMember(*Record++);
+  RD->setAnonymousStructOrUnion(*Record++);
+  RD->setHasObjectMember(*Record++);
+  RD->setHasVolatileMember(*Record++);
   return Redecl;
 }
 
 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
   VisitNamedDecl(VD);
-  VD->setType(Record.readType(Idx));
+  VD->setType(Record.readType());
 }
 
 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
   VisitValueDecl(ECD);
-  if (Record[Idx++])
+  if (*Record++)
     ECD->setInitExpr(Record.ReadExpr());
-  ECD->setInitVal(Record.ReadAPSInt(Idx));
+  ECD->setInitVal(Record.ReadAPSInt());
   mergeMergeable(ECD);
 }
 
 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
   VisitValueDecl(DD);
   DD->setInnerLocStart(ReadSourceLocation());
-  if (Record[Idx++]) { // hasExtInfo
+  if (*Record++) { // hasExtInfo
     DeclaratorDecl::ExtInfo *Info
         = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
     ReadQualifierInfo(*Info);
@@ -735,30 +728,30 @@
   VisitDeclaratorDecl(FD);
 
   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName());
-  FD->IdentifierNamespace = Record[Idx++];
+  FD->IdentifierNamespace = *Record++;
 
   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
   // after everything else is read.
 
-  FD->SClass = (StorageClass)Record[Idx++];
-  FD->IsInline = Record[Idx++];
-  FD->IsInlineSpecified = Record[Idx++];
-  FD->IsVirtualAsWritten = Record[Idx++];
-  FD->IsPure = Record[Idx++];
-  FD->HasInheritedPrototype = Record[Idx++];
-  FD->HasWrittenPrototype = Record[Idx++];
-  FD->IsDeleted = Record[Idx++];
-  FD->IsTrivial = Record[Idx++];
-  FD->IsDefaulted = Record[Idx++];
-  FD->IsExplicitlyDefaulted = Record[Idx++];
-  FD->HasImplicitReturnZero = Record[Idx++];
-  FD->IsConstexpr = Record[Idx++];
-  FD->HasSkippedBody = Record[Idx++];
-  FD->IsLateTemplateParsed = Record[Idx++];
-  FD->setCachedLinkage(Linkage(Record[Idx++]));
+  FD->SClass = (StorageClass)*Record++;
+  FD->IsInline = *Record++;
+  FD->IsInlineSpecified = *Record++;
+  FD->IsVirtualAsWritten = *Record++;
+  FD->IsPure = *Record++;
+  FD->HasInheritedPrototype = *Record++;
+  FD->HasWrittenPrototype = *Record++;
+  FD->IsDeleted = *Record++;
+  FD->IsTrivial = *Record++;
+  FD->IsDefaulted = *Record++;
+  FD->IsExplicitlyDefaulted = *Record++;
+  FD->HasImplicitReturnZero = *Record++;
+  FD->IsConstexpr = *Record++;
+  FD->HasSkippedBody = *Record++;
+  FD->IsLateTemplateParsed = *Record++;
+  FD->setCachedLinkage(Linkage(*Record++));
   FD->EndRangeLoc = ReadSourceLocation();
 
-  switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
+  switch ((FunctionDecl::TemplatedKind)*Record++) {
   case FunctionDecl::TK_NonTemplate:
     mergeRedeclarable(FD, Redecl);
     break;
@@ -768,7 +761,7 @@
     break;
   case FunctionDecl::TK_MemberSpecialization: {
     FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>();
-    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
+    TemplateSpecializationKind TSK = (TemplateSpecializationKind)*Record++;
     SourceLocation POI = ReadSourceLocation();
     FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
     FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
@@ -777,22 +770,21 @@
   }
   case FunctionDecl::TK_FunctionTemplateSpecialization: {
     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>();
-    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
+    TemplateSpecializationKind TSK = (TemplateSpecializationKind)*Record++;
 
     // Template arguments.
     SmallVector<TemplateArgument, 8> TemplArgs;
-    Record.ReadTemplateArgumentList(TemplArgs, Idx,
-                                    /*Canonicalize*/ true);
+    Record.ReadTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
 
     // Template args as written.
     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
     SourceLocation LAngleLoc, RAngleLoc;
-    bool HasTemplateArgumentsAsWritten = Record[Idx++];
+    bool HasTemplateArgumentsAsWritten = *Record++;
     if (HasTemplateArgumentsAsWritten) {
-      unsigned NumTemplateArgLocs = Record[Idx++];
+      unsigned NumTemplateArgLocs = *Record++;
       TemplArgLocs.reserve(NumTemplateArgLocs);
       for (unsigned i=0; i != NumTemplateArgLocs; ++i)
-        TemplArgLocs.push_back(Record.ReadTemplateArgumentLoc(Idx));
+        TemplArgLocs.push_back(Record.ReadTemplateArgumentLoc());
 
       LAngleLoc = ReadSourceLocation();
       RAngleLoc = ReadSourceLocation();
@@ -842,15 +834,15 @@
   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     // Templates.
     UnresolvedSet<8> TemplDecls;
-    unsigned NumTemplates = Record[Idx++];
+    unsigned NumTemplates = *Record++;
     while (NumTemplates--)
       TemplDecls.addDecl(ReadDeclAs<NamedDecl>());
 
     // Templates args.
     TemplateArgumentListInfo TemplArgs;
-    unsigned NumArgs = Record[Idx++];
+    unsigned NumArgs = *Record++;
     while (NumArgs--)
-      TemplArgs.addArgument(Record.ReadTemplateArgumentLoc(Idx));
+      TemplArgs.addArgument(Record.ReadTemplateArgumentLoc());
     TemplArgs.setLAngleLoc(ReadSourceLocation());
     TemplArgs.setRAngleLoc(ReadSourceLocation());
 
@@ -863,7 +855,7 @@
   }
 
   // Read in the parameters.
-  unsigned NumParams = Record[Idx++];
+  unsigned NumParams = *Record++;
   SmallVector<ParmVarDecl *, 16> Params;
   Params.reserve(NumParams);
   for (unsigned I = 0; I != NumParams; ++I)
@@ -873,7 +865,7 @@
 
 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
   VisitNamedDecl(MD);
-  if (Record[Idx++]) {
+  if (*Record++) {
     // Load the body on-demand. Most clients won't care, because method
     // definitions rarely show up in headers.
     Reader.PendingBodies[MD] = GetCurrentCursorOffset();
@@ -881,33 +873,33 @@
     MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>());
     MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>());
   }
-  MD->setInstanceMethod(Record[Idx++]);
-  MD->setVariadic(Record[Idx++]);
-  MD->setPropertyAccessor(Record[Idx++]);
-  MD->setDefined(Record[Idx++]);
-  MD->IsOverriding = Record[Idx++];
-  MD->HasSkippedBody = Record[Idx++];
+  MD->setInstanceMethod(*Record++);
+  MD->setVariadic(*Record++);
+  MD->setPropertyAccessor(*Record++);
+  MD->setDefined(*Record++);
+  MD->IsOverriding = *Record++;
+  MD->HasSkippedBody = *Record++;
 
-  MD->IsRedeclaration = Record[Idx++];
-  MD->HasRedeclaration = Record[Idx++];
+  MD->IsRedeclaration = *Record++;
+  MD->HasRedeclaration = *Record++;
   if (MD->HasRedeclaration)
     Reader.getContext().setObjCMethodRedeclaration(MD,
                                        ReadDeclAs<ObjCMethodDecl>());
 
-  MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
-  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
-  MD->SetRelatedResultType(Record[Idx++]);
-  MD->setReturnType(Record.readType(Idx));
+  MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)*Record++);
+  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)*Record++);
+  MD->SetRelatedResultType(*Record++);
+  MD->setReturnType(Record.readType());
   MD->setReturnTypeSourceInfo(GetTypeSourceInfo());
   MD->DeclEndLoc = ReadSourceLocation();
-  unsigned NumParams = Record[Idx++];
+  unsigned NumParams = *Record++;
   SmallVector<ParmVarDecl *, 16> Params;
   Params.reserve(NumParams);
   for (unsigned I = 0; I != NumParams; ++I)
     Params.push_back(ReadDeclAs<ParmVarDecl>());
 
-  MD->SelLocsKind = Record[Idx++];
-  unsigned NumStoredSelLocs = Record[Idx++];
+  MD->SelLocsKind = *Record++;
+  unsigned NumStoredSelLocs = *Record++;
   SmallVector<SourceLocation, 16> SelLocs;
   SelLocs.reserve(NumStoredSelLocs);
   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
@@ -919,8 +911,8 @@
 void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
   VisitTypedefNameDecl(D);
 
-  D->Variance = Record[Idx++];
-  D->Index = Record[Idx++];
+  D->Variance = *Record++;
+  D->Index = *Record++;
   D->VarianceLoc = ReadSourceLocation();
   D->ColonLoc = ReadSourceLocation();
 }
@@ -932,7 +924,7 @@
 }
 
 ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {
-  unsigned numParams = Record[Idx++];
+  unsigned numParams = *Record++;
   if (numParams == 0)
     return nullptr;
 
@@ -954,15 +946,15 @@
 }
 
 void ASTDeclReader::ReadObjCDefinitionData(
-         struct ObjCInterfaceDecl::DefinitionData &Data, unsigned &I) {
+         struct ObjCInterfaceDecl::DefinitionData &Data) {
   // Read the superclass.
   Data.SuperClassTInfo = GetTypeSourceInfo();
 
   Data.EndLoc = ReadSourceLocation();
-  Data.HasDesignatedInitializers = Record[Idx++];
+  Data.HasDesignatedInitializers = *Record++;
 
   // Read the directly referenced protocols and their SourceLocations.
-  unsigned NumProtocols = Record[Idx++];
+  unsigned NumProtocols = *Record++;
   SmallVector<ObjCProtocolDecl *, 16> Protocols;
   Protocols.reserve(NumProtocols);
   for (unsigned I = 0; I != NumProtocols; ++I)
@@ -975,7 +967,7 @@
                                Reader.getContext());
 
   // Read the transitive closure of protocols referenced by this class.
-  NumProtocols = Record[Idx++];
+  NumProtocols = *Record++;
   Protocols.clear();
   Protocols.reserve(NumProtocols);
   for (unsigned I = 0; I != NumProtocols; ++I)
@@ -992,15 +984,15 @@
 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
   RedeclarableResult Redecl = VisitRedeclarable(ID);
   VisitObjCContainerDecl(ID);
-  TypeIDForTypeDecl = Record.getGlobalTypeID(Record[Idx++]);
+  TypeIDForTypeDecl = Record.getGlobalTypeID(*Record++);
   mergeRedeclarable(ID, Redecl);
 
   ID->TypeParamList = ReadObjCTypeParamList();
-  if (Record[Idx++]) {
+  if (*Record++) {
     // Read the definition.
     ID->allocateDefinitionData();
 
-    ReadObjCDefinitionData(ID->data(), Idx);
+    ReadObjCDefinitionData(ID->data());
     ObjCInterfaceDecl *Canon = ID->getCanonicalDecl();
     if (Canon->Data.getPointer()) {
       // If we already have a definition, keep the definition invariant and
@@ -1028,10 +1020,10 @@
 
 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
   VisitFieldDecl(IVD);
-  IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
+  IVD->setAccessControl((ObjCIvarDecl::AccessControl)*Record++);
   // This field will be built lazily.
   IVD->setNextIvar(nullptr);
-  bool synth = Record[Idx++];
+  bool synth = *Record++;
   IVD->setSynthesize(synth);
 }
 
@@ -1040,7 +1032,7 @@
   VisitObjCContainerDecl(PD);
   mergeRedeclarable(PD, Redecl);
 
-  if (Record[Idx++]) {
+  if (*Record++) {
     // Read the definition.
     PD->allocateDefinitionData();
 
@@ -1048,7 +1040,7 @@
     // redeclarations will see it.
     PD->getCanonicalDecl()->Data = PD->Data;
 
-    unsigned NumProtoRefs = Record[Idx++];
+    unsigned NumProtoRefs = *Record++;
     SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
     ProtoRefs.reserve(NumProtoRefs);
     for (unsigned I = 0; I != NumProtoRefs; ++I)
@@ -1084,7 +1076,7 @@
 
   CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>();
   CD->TypeParamList = ReadObjCTypeParamList();
-  unsigned NumProtoRefs = Record[Idx++];
+  unsigned NumProtoRefs = *Record++;
   SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
   ProtoRefs.reserve(NumProtoRefs);
   for (unsigned I = 0; I != NumProtoRefs; ++I)
@@ -1106,17 +1098,17 @@
   VisitNamedDecl(D);
   D->setAtLoc(ReadSourceLocation());
   D->setLParenLoc(ReadSourceLocation());
-  QualType T = Record.readType(Idx);
+  QualType T = Record.readType();
   TypeSourceInfo *TSI = GetTypeSourceInfo();
   D->setType(T, TSI);
   D->setPropertyAttributes(
-                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
+                      (ObjCPropertyDecl::PropertyAttributeKind)*Record++);
   D->setPropertyAttributesAsWritten(
-                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
+                      (ObjCPropertyDecl::PropertyAttributeKind)*Record++);
   D->setPropertyImplementation(
-                            (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
-  D->setGetterName(Record.ReadDeclarationName(Idx).getObjCSelector());
-  D->setSetterName(Record.ReadDeclarationName(Idx).getObjCSelector());
+                            (ObjCPropertyDecl::PropertyControl)*Record++);
+  D->setGetterName(Record.ReadDeclarationName().getObjCSelector());
+  D->setSetterName(Record.ReadDeclarationName().getObjCSelector());
   D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>());
   D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>());
   D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>());
@@ -1129,7 +1121,7 @@
 
 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
   VisitObjCImplDecl(D);
-  D->setIdentifier(Record.GetIdentifierInfo(Idx));
+  D->setIdentifier(Record.GetIdentifierInfo());
   D->CategoryNameLoc = ReadSourceLocation();
 }
 
@@ -1139,9 +1131,9 @@
   D->SuperLoc = ReadSourceLocation();
   D->setIvarLBraceLoc(ReadSourceLocation());
   D->setIvarRBraceLoc(ReadSourceLocation());
-  D->setHasNonZeroConstructors(Record[Idx++]);
-  D->setHasDestructors(Record[Idx++]);
-  D->NumIvarInitializers = Record[Idx++];
+  D->setHasNonZeroConstructors(*Record++);
+  D->setHasDestructors(*Record++);
+  D->NumIvarInitializers = *Record++;
   if (D->NumIvarInitializers)
     D->IvarInitializers = ReadGlobalOffset();
 }
@@ -1158,14 +1150,13 @@
 
 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
   VisitDeclaratorDecl(FD);
-  FD->Mutable = Record[Idx++];
-  if (int BitWidthOrInitializer = Record[Idx++]) {
+  FD->Mutable = *Record++;
+  if (int BitWidthOrInitializer = *Record++) {
     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(Idx).getAsOpaquePtr());
+      FD->InitStorage.setPointer(Record.readType().getAsOpaquePtr());
     } else {
       FD->InitStorage.setPointer(Record.ReadExpr());
     }
@@ -1179,14 +1170,14 @@
 
 void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
   VisitDeclaratorDecl(PD);
-  PD->GetterId = Record.GetIdentifierInfo(Idx);
-  PD->SetterId = Record.GetIdentifierInfo(Idx);
+  PD->GetterId = Record.GetIdentifierInfo();
+  PD->SetterId = Record.GetIdentifierInfo();
 }
 
 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
   VisitValueDecl(FD);
 
-  FD->ChainingSize = Record[Idx++];
+  FD->ChainingSize = *Record++;
   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
 
@@ -1200,22 +1191,22 @@
   RedeclarableResult Redecl = VisitRedeclarable(VD);
   VisitDeclaratorDecl(VD);
 
-  VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
-  VD->VarDeclBits.TSCSpec = Record[Idx++];
-  VD->VarDeclBits.InitStyle = Record[Idx++];
+  VD->VarDeclBits.SClass = (StorageClass)*Record++;
+  VD->VarDeclBits.TSCSpec = *Record++;
+  VD->VarDeclBits.InitStyle = *Record++;
   if (!isa<ParmVarDecl>(VD)) {
-    VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = Record[Idx++];
-    VD->NonParmVarDeclBits.ExceptionVar = Record[Idx++];
-    VD->NonParmVarDeclBits.NRVOVariable = Record[Idx++];
-    VD->NonParmVarDeclBits.CXXForRangeDecl = Record[Idx++];
-    VD->NonParmVarDeclBits.ARCPseudoStrong = Record[Idx++];
-    VD->NonParmVarDeclBits.IsInline = Record[Idx++];
-    VD->NonParmVarDeclBits.IsInlineSpecified = Record[Idx++];
-    VD->NonParmVarDeclBits.IsConstexpr = Record[Idx++];
-    VD->NonParmVarDeclBits.IsInitCapture = Record[Idx++];
-    VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
-  }
-  Linkage VarLinkage = Linkage(Record[Idx++]);
+    VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = *Record++;
+    VD->NonParmVarDeclBits.ExceptionVar = *Record++;
+    VD->NonParmVarDeclBits.NRVOVariable = *Record++;
+    VD->NonParmVarDeclBits.CXXForRangeDecl = *Record++;
+    VD->NonParmVarDeclBits.ARCPseudoStrong = *Record++;
+    VD->NonParmVarDeclBits.IsInline = *Record++;
+    VD->NonParmVarDeclBits.IsInlineSpecified = *Record++;
+    VD->NonParmVarDeclBits.IsConstexpr = *Record++;
+    VD->NonParmVarDeclBits.IsInitCapture = *Record++;
+    VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = *Record++;
+  }
+  Linkage VarLinkage = Linkage(*Record++);
   VD->setCachedLinkage(VarLinkage);
 
   // Reconstruct the one piece of the IdentifierNamespace that we need.
@@ -1223,7 +1214,7 @@
       VD->getLexicalDeclContext()->isFunctionOrMethod())
     VD->setLocalExternDecl();
 
-  if (uint64_t Val = Record[Idx++]) {
+  if (uint64_t Val = *Record++) {
     VD->setInit(Record.ReadExpr());
     if (Val > 1) { // IsInitKnownICE = 1, IsInitNotICE = 2, IsInitICE = 3
       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
@@ -1235,7 +1226,7 @@
   enum VarKind {
     VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
   };
-  switch ((VarKind)Record[Idx++]) {
+  switch ((VarKind)*Record++) {
   case VarNotTemplate:
     // Only true variables (not parameters or implicit parameters) can be
     // merged; the other kinds are not really redeclarable at all.
@@ -1249,7 +1240,7 @@
     break;
   case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
     VarDecl *Tmpl = ReadDeclAs<VarDecl>();
-    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
+    TemplateSpecializationKind TSK = (TemplateSpecializationKind)*Record++;
     SourceLocation POI = ReadSourceLocation();
     Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
     mergeRedeclarable(VD, Redecl);
@@ -1266,10 +1257,10 @@
 
 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
   VisitVarDecl(PD);
-  unsigned isObjCMethodParam = Record[Idx++];
-  unsigned scopeDepth = Record[Idx++];
-  unsigned scopeIndex = Record[Idx++];
-  unsigned declQualifier = Record[Idx++];
+  unsigned isObjCMethodParam = *Record++;
+  unsigned scopeDepth = *Record++;
+  unsigned scopeIndex = *Record++;
+  unsigned declQualifier = *Record++;
   if (isObjCMethodParam) {
     assert(scopeDepth == 0);
     PD->setObjCMethodScopeInfo(scopeIndex);
@@ -1277,9 +1268,9 @@
   } else {
     PD->setScopeInfo(scopeDepth, scopeIndex);
   }
-  PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
-  PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
-  if (Record[Idx++]) // hasUninstantiatedDefaultArg.
+  PD->ParmVarDeclBits.IsKNRPromoted = *Record++;
+  PD->ParmVarDeclBits.HasInheritedDefaultArg = *Record++;
+  if (*Record++) // hasUninstantiatedDefaultArg.
     PD->setUninstantiatedDefaultArg(Record.ReadExpr());
 
   // FIXME: If this is a redeclaration of a function from another module, handle
@@ -1308,24 +1299,24 @@
   VisitDecl(BD);
   BD->setBody(cast_or_null<CompoundStmt>(Record.ReadStmt()));
   BD->setSignatureAsWritten(GetTypeSourceInfo());
-  unsigned NumParams = Record[Idx++];
+  unsigned NumParams = *Record++;
   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[Idx++]);
-  BD->setBlockMissingReturnType(Record[Idx++]);
-  BD->setIsConversionFromLambda(Record[Idx++]);
+  BD->setIsVariadic(*Record++);
+  BD->setBlockMissingReturnType(*Record++);
+  BD->setIsConversionFromLambda(*Record++);
 
-  bool capturesCXXThis = Record[Idx++];
-  unsigned numCaptures = Record[Idx++];
+  bool capturesCXXThis = *Record++;
+  unsigned numCaptures = *Record++;
   SmallVector<BlockDecl::Capture, 16> captures;
   captures.reserve(numCaptures);
   for (unsigned i = 0; i != numCaptures; ++i) {
     VarDecl *decl = ReadDeclAs<VarDecl>();
-    unsigned flags = Record[Idx++];
+    unsigned flags = *Record++;
     bool byRef = (flags & 1);
     bool nested = (flags & 2);
     Expr *copyExpr = ((flags & 4) ? Record.ReadExpr() : nullptr);
@@ -1337,8 +1328,8 @@
 
 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
   VisitDecl(CD);
-  unsigned ContextParamPos = Record[Idx++];
-  CD->setNothrow(Record[Idx++] != 0);
+  unsigned ContextParamPos = *Record++;
+  CD->setNothrow(*Record++ != 0);
   // Body is set by VisitCapturedStmt.
   for (unsigned I = 0; I < CD->NumParams; ++I) {
     if (I != ContextParamPos)
@@ -1350,7 +1341,7 @@
 
 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
   VisitDecl(D);
-  D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
+  D->setLanguage((LinkageSpecDecl::LanguageIDs)*Record++);
   D->setExternLoc(ReadSourceLocation());
   D->setRBraceLoc(ReadSourceLocation());
 }
@@ -1368,7 +1359,7 @@
 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
   RedeclarableResult Redecl = VisitRedeclarable(D);
   VisitNamedDecl(D);
-  D->setInline(Record[Idx++]);
+  D->setInline(*Record++);
   D->LocStart = ReadSourceLocation();
   D->RBraceLoc = ReadSourceLocation();
 
@@ -1402,7 +1393,7 @@
   VisitNamedDecl(D);
   D->NamespaceLoc = ReadSourceLocation();
   D->IdentLoc = ReadSourceLocation();
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   D->Namespace = ReadDeclAs<NamedDecl>();
   mergeRedeclarable(D, Redecl);
 }
@@ -1410,10 +1401,10 @@
 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
   VisitNamedDecl(D);
   D->setUsingLoc(ReadSourceLocation());
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName());
   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>());
-  D->setTypename(Record[Idx++]);
+  D->setTypename(*Record++);
   if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>())
     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
   mergeMergeable(D);
@@ -1435,14 +1426,14 @@
   VisitUsingShadowDecl(D);
   D->NominatedBaseClassShadowDecl = ReadDeclAs<ConstructorUsingShadowDecl>();
   D->ConstructedBaseClassShadowDecl = ReadDeclAs<ConstructorUsingShadowDecl>();
-  D->IsVirtual = Record[Idx++];
+  D->IsVirtual = *Record++;
 }
 
 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   VisitNamedDecl(D);
   D->UsingLoc = ReadSourceLocation();
   D->NamespaceLoc = ReadSourceLocation();
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   D->NominatedNamespace = ReadDeclAs<NamedDecl>();
   D->CommonAncestor = ReadDeclAs<DeclContext>();
 }
@@ -1450,7 +1441,7 @@
 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
   VisitValueDecl(D);
   D->setUsingLoc(ReadSourceLocation());
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName());
   mergeMergeable(D);
 }
@@ -1459,65 +1450,64 @@
                                                UnresolvedUsingTypenameDecl *D) {
   VisitTypeDecl(D);
   D->TypenameLocation = ReadSourceLocation();
-  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  D->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   mergeMergeable(D);
 }
 
 void ASTDeclReader::ReadCXXDefinitionData(
-                                   struct CXXRecordDecl::DefinitionData &Data,
-                                   unsigned &Idx) {
+                                   struct CXXRecordDecl::DefinitionData &Data) {
   // Note: the caller has deserialized the IsLambda bit already.
-  Data.UserDeclaredConstructor = Record[Idx++];
-  Data.UserDeclaredSpecialMembers = Record[Idx++];
-  Data.Aggregate = Record[Idx++];
-  Data.PlainOldData = Record[Idx++];
-  Data.Empty = Record[Idx++];
-  Data.Polymorphic = Record[Idx++];
-  Data.Abstract = Record[Idx++];
-  Data.IsStandardLayout = Record[Idx++];
-  Data.HasNoNonEmptyBases = Record[Idx++];
-  Data.HasPrivateFields = Record[Idx++];
-  Data.HasProtectedFields = Record[Idx++];
-  Data.HasPublicFields = Record[Idx++];
-  Data.HasMutableFields = Record[Idx++];
-  Data.HasVariantMembers = Record[Idx++];
-  Data.HasOnlyCMembers = Record[Idx++];
-  Data.HasInClassInitializer = Record[Idx++];
-  Data.HasUninitializedReferenceMember = Record[Idx++];
-  Data.HasUninitializedFields = Record[Idx++];
-  Data.HasInheritedConstructor = Record[Idx++];
-  Data.HasInheritedAssignment = Record[Idx++];
-  Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
-  Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
-  Data.NeedOverloadResolutionForDestructor = Record[Idx++];
-  Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
-  Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
-  Data.DefaultedDestructorIsDeleted = Record[Idx++];
-  Data.HasTrivialSpecialMembers = Record[Idx++];
-  Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
-  Data.HasIrrelevantDestructor = Record[Idx++];
-  Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
-  Data.HasDefaultedDefaultConstructor = Record[Idx++];
-  Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
-  Data.HasConstexprDefaultConstructor = Record[Idx++];
-  Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
-  Data.ComputedVisibleConversions = Record[Idx++];
-  Data.UserProvidedDefaultConstructor = Record[Idx++];
-  Data.DeclaredSpecialMembers = Record[Idx++];
-  Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
-  Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
-  Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
-  Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
-
-  Data.NumBases = Record[Idx++];
+  Data.UserDeclaredConstructor = *Record++;
+  Data.UserDeclaredSpecialMembers = *Record++;
+  Data.Aggregate = *Record++;
+  Data.PlainOldData = *Record++;
+  Data.Empty = *Record++;
+  Data.Polymorphic = *Record++;
+  Data.Abstract = *Record++;
+  Data.IsStandardLayout = *Record++;
+  Data.HasNoNonEmptyBases = *Record++;
+  Data.HasPrivateFields = *Record++;
+  Data.HasProtectedFields = *Record++;
+  Data.HasPublicFields = *Record++;
+  Data.HasMutableFields = *Record++;
+  Data.HasVariantMembers = *Record++;
+  Data.HasOnlyCMembers = *Record++;
+  Data.HasInClassInitializer = *Record++;
+  Data.HasUninitializedReferenceMember = *Record++;
+  Data.HasUninitializedFields = *Record++;
+  Data.HasInheritedConstructor = *Record++;
+  Data.HasInheritedAssignment = *Record++;
+  Data.NeedOverloadResolutionForMoveConstructor = *Record++;
+  Data.NeedOverloadResolutionForMoveAssignment = *Record++;
+  Data.NeedOverloadResolutionForDestructor = *Record++;
+  Data.DefaultedMoveConstructorIsDeleted = *Record++;
+  Data.DefaultedMoveAssignmentIsDeleted = *Record++;
+  Data.DefaultedDestructorIsDeleted = *Record++;
+  Data.HasTrivialSpecialMembers = *Record++;
+  Data.DeclaredNonTrivialSpecialMembers = *Record++;
+  Data.HasIrrelevantDestructor = *Record++;
+  Data.HasConstexprNonCopyMoveConstructor = *Record++;
+  Data.HasDefaultedDefaultConstructor = *Record++;
+  Data.DefaultedDefaultConstructorIsConstexpr = *Record++;
+  Data.HasConstexprDefaultConstructor = *Record++;
+  Data.HasNonLiteralTypeFieldsOrBases = *Record++;
+  Data.ComputedVisibleConversions = *Record++;
+  Data.UserProvidedDefaultConstructor = *Record++;
+  Data.DeclaredSpecialMembers = *Record++;
+  Data.ImplicitCopyConstructorHasConstParam = *Record++;
+  Data.ImplicitCopyAssignmentHasConstParam = *Record++;
+  Data.HasDeclaredCopyConstructorWithConstParam = *Record++;
+  Data.HasDeclaredCopyAssignmentWithConstParam = *Record++;
+
+  Data.NumBases = *Record++;
   if (Data.NumBases)
     Data.Bases = ReadGlobalOffset();
-  Data.NumVBases = Record[Idx++];
+  Data.NumVBases = *Record++;
   if (Data.NumVBases)
     Data.VBases = ReadGlobalOffset();
 
-  Record.ReadUnresolvedSet(Data.Conversions, Idx);
-  Record.ReadUnresolvedSet(Data.VisibleConversions, Idx);
+  Record.ReadUnresolvedSet(Data.Conversions);
+  Record.ReadUnresolvedSet(Data.VisibleConversions);
   assert(Data.Definition && "Data.Definition should be already set!");
   Data.FirstFriend = ReadDeclID();
 
@@ -1525,12 +1515,12 @@
     typedef LambdaCapture Capture;
     CXXRecordDecl::LambdaDefinitionData &Lambda
       = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
-    Lambda.Dependent = Record[Idx++];
-    Lambda.IsGenericLambda = Record[Idx++];
-    Lambda.CaptureDefault = Record[Idx++];
-    Lambda.NumCaptures = Record[Idx++];
-    Lambda.NumExplicitCaptures = Record[Idx++];
-    Lambda.ManglingNumber = Record[Idx++];
+    Lambda.Dependent = *Record++;
+    Lambda.IsGenericLambda = *Record++;
+    Lambda.CaptureDefault = *Record++;
+    Lambda.NumCaptures = *Record++;
+    Lambda.NumExplicitCaptures = *Record++;
+    Lambda.ManglingNumber = *Record++;
     Lambda.ContextDecl = ReadDeclID();
     Lambda.Captures 
       = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
@@ -1538,8 +1528,8 @@
     Lambda.MethodTyInfo = GetTypeSourceInfo();
     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
       SourceLocation Loc = ReadSourceLocation();
-      bool IsImplicit = Record[Idx++];
-      LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
+      bool IsImplicit = *Record++;
+      LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(*Record++);
       switch (Kind) {
       case LCK_StarThis: 
       case LCK_This:
@@ -1671,14 +1661,14 @@
 
   // Determine whether this is a lambda closure type, so that we can
   // allocate the appropriate DefinitionData structure.
-  bool IsLambda = Record[Idx++];
+  bool IsLambda = *Record++;
   if (IsLambda)
     DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
                                                      LCD_None);
   else
     DD = new (C) struct CXXRecordDecl::DefinitionData(D);
 
-  ReadCXXDefinitionData(*DD, Idx);
+  ReadCXXDefinitionData(*DD);
 
   // We might already have a definition for this record. This can happen either
   // because we're reading an update record, or because we've already done some
@@ -1712,7 +1702,7 @@
   enum CXXRecKind {
     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
   };
-  switch ((CXXRecKind)Record[Idx++]) {
+  switch ((CXXRecKind)*Record++) {
   case CXXRecNotTemplate:
     // Merged when we merge the folding set entry in the primary template.
     if (!isa<ClassTemplateSpecializationDecl>(D))
@@ -1735,7 +1725,7 @@
   }
   case CXXRecMemberSpecialization: {
     CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>();
-    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
+    TemplateSpecializationKind TSK = (TemplateSpecializationKind)*Record++;
     SourceLocation POI = ReadSourceLocation();
     MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
     MSI->setPointOfInstantiation(POI);
@@ -1745,7 +1735,7 @@
   }
   }
 
-  bool WasDefinition = Record[Idx++];
+  bool WasDefinition = *Record++;
   if (WasDefinition)
     ReadCXXRecordDefinition(D, /*Update*/false);
   else
@@ -1769,7 +1759,7 @@
 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
   VisitFunctionDecl(D);
 
-  unsigned NumOverridenMethods = Record[Idx++];
+  unsigned NumOverridenMethods = *Record++;
   if (D->isCanonicalDecl()) {
     while (NumOverridenMethods--) {
       // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
@@ -1780,7 +1770,7 @@
   } else {
     // We don't care about which declarations this used to override; we get
     // the relevant information from the canonical declaration.
-    Idx += NumOverridenMethods;
+    Record += NumOverridenMethods;
   }
 }
 
@@ -1796,7 +1786,7 @@
 
   VisitCXXMethodDecl(D);
 
-  D->IsExplicitSpecified = Record[Idx++];
+  D->IsExplicitSpecified = *Record++;
 }
 
 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
@@ -1812,17 +1802,17 @@
 
 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
   VisitCXXMethodDecl(D);
-  D->IsExplicitSpecified = Record[Idx++];
+  D->IsExplicitSpecified = *Record++;
 }
 
 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
   VisitDecl(D);
   D->ImportedAndComplete.setPointer(readModule());
-  D->ImportedAndComplete.setInt(Record[Idx++]);
+  D->ImportedAndComplete.setInt(*Record++);
   SourceLocation *StoredLocs = D->getTrailingObjects<SourceLocation>();
   for (unsigned I = 0, N = Record.back(); I != N; ++I)
     StoredLocs[I] = ReadSourceLocation();
-  ++Idx; // The number of stored source locations.
+  ++Record; // The number of stored source locations.
 }
 
 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
@@ -1832,26 +1822,26 @@
 
 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
   VisitDecl(D);
-  if (Record[Idx++]) // hasFriendDecl
+  if (*Record++) // hasFriendDecl
     D->Friend = ReadDeclAs<NamedDecl>();
   else
     D->Friend = GetTypeSourceInfo();
   for (unsigned i = 0; i != D->NumTPLists; ++i)
     D->getTrailingObjects<TemplateParameterList *>()[i] =
-        Record.ReadTemplateParameterList(Idx);
+        Record.ReadTemplateParameterList();
   D->NextFriend = ReadDeclID();
-  D->UnsupportedFriend = (Record[Idx++] != 0);
+  D->UnsupportedFriend = (*Record++ != 0);
   D->FriendLoc = ReadSourceLocation();
 }
 
 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
   VisitDecl(D);
-  unsigned NumParams = Record[Idx++];
+  unsigned NumParams = *Record++;
   D->NumParams = NumParams;
   D->Params = new TemplateParameterList*[NumParams];
   for (unsigned i = 0; i != NumParams; ++i)
-    D->Params[i] = Record.ReadTemplateParameterList(Idx);
-  if (Record[Idx++]) // HasFriendDecl
+    D->Params[i] = Record.ReadTemplateParameterList();
+  if (*Record++) // HasFriendDecl
     D->Friend = ReadDeclAs<NamedDecl>();
   else
     D->Friend = GetTypeSourceInfo();
@@ -1863,8 +1853,7 @@
 
   DeclID PatternID = ReadDeclID();
   NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
-  TemplateParameterList* TemplateParams
-      = Record.ReadTemplateParameterList(Idx);
+  TemplateParameterList *TemplateParams = Record.ReadTemplateParameterList();
   D->init(TemplatedDecl, TemplateParams);
 
   return PatternID;
@@ -1891,13 +1880,13 @@
       assert(RTD->getKind() == D->getKind() &&
              "InstantiatedFromMemberTemplate kind mismatch");
       D->setInstantiatedFromMemberTemplate(RTD);
-      if (Record[Idx++])
+      if (*Record++)
         D->setMemberSpecialization();
     }
   }
 
   DeclID PatternID = VisitTemplateDecl(D);
-  D->IdentifierNamespace = Record[Idx++];
+  D->IdentifierNamespace = *Record++;
 
   mergeRedeclarable(D, Redecl, PatternID);
 
@@ -1984,7 +1973,7 @@
       D->SpecializedTemplate = CTD;
     } else {
       SmallVector<TemplateArgument, 8> TemplArgs;
-      Record.ReadTemplateArgumentList(TemplArgs, Idx);
+      Record.ReadTemplateArgumentList(TemplArgs);
       TemplateArgumentList *ArgList
         = TemplateArgumentList::CreateCopy(C, TemplArgs);
       ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
@@ -1998,13 +1987,12 @@
   }
 
   SmallVector<TemplateArgument, 8> TemplArgs;
-  Record.ReadTemplateArgumentList(TemplArgs, Idx,
-                                  /*Canonicalize*/ true);
+  Record.ReadTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
   D->PointOfInstantiation = ReadSourceLocation();
-  D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
+  D->SpecializationKind = (TemplateSpecializationKind)*Record++;
 
-  bool writtenAsCanonicalDecl = Record[Idx++];
+  bool writtenAsCanonicalDecl = *Record++;
   if (writtenAsCanonicalDecl) {
     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>();
     if (D->isCanonicalDecl()) { // It's kept in the folding set.
@@ -2052,14 +2040,14 @@
                                     ClassTemplatePartialSpecializationDecl *D) {
   RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
 
-  D->TemplateParams = Record.ReadTemplateParameterList(Idx);
-  D->ArgsAsWritten = Record.ReadASTTemplateArgumentListInfo(Idx);
+  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[Idx++]);
+    D->InstantiatedFromMember.setInt(*Record++);
   }
 }
 
@@ -2101,7 +2089,7 @@
       D->SpecializedTemplate = VTD;
     } else {
       SmallVector<TemplateArgument, 8> TemplArgs;
-      Record.ReadTemplateArgumentList(TemplArgs, Idx);
+      Record.ReadTemplateArgumentList(TemplArgs);
       TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
           C, TemplArgs);
       VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
@@ -2125,13 +2113,12 @@
   }
 
   SmallVector<TemplateArgument, 8> TemplArgs;
-  Record.ReadTemplateArgumentList(TemplArgs, Idx,
-                                  /*Canonicalize*/ true);
+  Record.ReadTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
   D->PointOfInstantiation = ReadSourceLocation();
-  D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
+  D->SpecializationKind = (TemplateSpecializationKind)*Record++;
 
-  bool writtenAsCanonicalDecl = Record[Idx++];
+  bool writtenAsCanonicalDecl = *Record++;
   if (writtenAsCanonicalDecl) {
     VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>();
     if (D->isCanonicalDecl()) { // It's kept in the folding set.
@@ -2158,42 +2145,42 @@
     VarTemplatePartialSpecializationDecl *D) {
   RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
 
-  D->TemplateParams = Record.ReadTemplateParameterList(Idx);
-  D->ArgsAsWritten = Record.ReadASTTemplateArgumentListInfo(Idx);
+  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[Idx++]);
+    D->InstantiatedFromMember.setInt(*Record++);
   }
 }
 
 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   VisitTypeDecl(D);
 
-  D->setDeclaredWithTypename(Record[Idx++]);
+  D->setDeclaredWithTypename(*Record++);
 
-  if (Record[Idx++])
+  if (*Record++)
     D->setDefaultArgument(GetTypeSourceInfo());
 }
 
 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   VisitDeclaratorDecl(D);
   // TemplateParmPosition.
-  D->setDepth(Record[Idx++]);
-  D->setPosition(Record[Idx++]);
+  D->setDepth(*Record++);
+  D->setPosition(*Record++);
   if (D->isExpandedParameterPack()) {
     auto TypesAndInfos =
         D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
-      new (&TypesAndInfos[I].first) QualType(Record.readType(Idx));
+      new (&TypesAndInfos[I].first) QualType(Record.readType());
       TypesAndInfos[I].second = GetTypeSourceInfo();
     }
   } else {
     // Rest of NonTypeTemplateParmDecl.
-    D->ParameterPack = Record[Idx++];
-    if (Record[Idx++])
+    D->ParameterPack = *Record++;
+    if (*Record++)
       D->setDefaultArgument(Record.ReadExpr());
   }
 }
@@ -2201,20 +2188,20 @@
 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   VisitTemplateDecl(D);
   // TemplateParmPosition.
-  D->setDepth(Record[Idx++]);
-  D->setPosition(Record[Idx++]);
+  D->setDepth(*Record++);
+  D->setPosition(*Record++);
   if (D->isExpandedParameterPack()) {
     TemplateParameterList **Data =
         D->getTrailingObjects<TemplateParameterList *>();
     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
          I != N; ++I)
-      Data[I] = Record.ReadTemplateParameterList(Idx);
+      Data[I] = Record.ReadTemplateParameterList();
   } else {
     // Rest of TemplateTemplateParmDecl.
-    D->ParameterPack = Record[Idx++];
-    if (Record[Idx++])
+    D->ParameterPack = *Record++;
+    if (*Record++)
       D->setDefaultArgument(Reader.getContext(),
-                            Record.ReadTemplateArgumentLoc(Idx));
+                            Record.ReadTemplateArgumentLoc());
   }
 }
 
@@ -2225,7 +2212,7 @@
 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
   VisitDecl(D);
   D->AssertExprAndFailed.setPointer(Record.ReadExpr());
-  D->AssertExprAndFailed.setInt(Record[Idx++]);
+  D->AssertExprAndFailed.setInt(*Record++);
   D->Message = cast_or_null<StringLiteral>(Record.ReadExpr());
   D->RParenLoc = ReadSourceLocation();
 }
@@ -2258,7 +2245,7 @@
     FirstDeclID = ThisDeclID;
     IsKeyDecl = true;
     IsFirstLocalDecl = true;
-  } else if (unsigned N = Record[Idx++]) {
+  } else if (unsigned N = *Record++) {
     // This declaration was the first local declaration, but may have imported
     // other declarations.
     IsKeyDecl = N == 1;
@@ -3251,13 +3238,12 @@
   Deserializing ADecl(this);
 
   DeclsCursor.JumpToBit(Loc.Offset);
-  RecordData Record;
+  ASTRecordReader Record(*this, *Loc.F);
+  ASTDeclReader Reader(*this, Record, Loc, ID, DeclLoc);
   unsigned Code = DeclsCursor.ReadCode();
-  unsigned Idx = 0;
-  ASTDeclReader Reader(*this, Loc, ID, DeclLoc, Record,Idx);
 
   Decl *D = nullptr;
-  switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
+  switch ((DeclCode)Record.readRecord(DeclsCursor, Code)) {
   case DECL_CONTEXT_LEXICAL:
   case DECL_CONTEXT_VISIBLE:
     llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
@@ -3334,7 +3320,7 @@
     D = AccessSpecDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_FRIEND:
-    D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
+    D = FriendDecl::CreateDeserialized(Context, ID, *Record++);
     break;
   case DECL_FRIEND_TEMPLATE:
     D = FriendTemplateDecl::CreateDeserialized(Context, ID);
@@ -3370,14 +3356,14 @@
     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
-    D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
+    D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, *Record++);
     break;
   case DECL_TEMPLATE_TEMPLATE_PARM:
     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
-                                                     Record[Idx++]);
+                                                     *Record++);
     break;
   case DECL_TYPE_ALIAS_TEMPLATE:
     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
@@ -3434,7 +3420,7 @@
     D = ParmVarDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_DECOMPOSITION:
-    D = DecompositionDecl::CreateDeserialized(Context, ID, Record[Idx++]);
+    D = DecompositionDecl::CreateDeserialized(Context, ID, *Record++);
     break;
   case DECL_BINDING:
     D = BindingDecl::CreateDeserialized(Context, ID);
@@ -3449,7 +3435,7 @@
     D = MSPropertyDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CAPTURED:
-    D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
+    D = CapturedDecl::CreateDeserialized(Context, ID, *Record++);
     break;
   case DECL_CXX_BASE_SPECIFIERS:
     Error("attempt to read a C++ base-specifier record as a declaration");
@@ -3463,7 +3449,7 @@
     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
     break;
   case DECL_OMP_THREADPRIVATE:
-    D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
+    D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, *Record++);
     break;
   case DECL_OMP_DECLARE_REDUCTION:
     D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);
@@ -3472,11 +3458,11 @@
     D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_PRAGMA_COMMENT:
-    D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record[Idx++]);
+    D = PragmaCommentDecl::CreateDeserialized(Context, ID, *Record++);
     break;
   case DECL_PRAGMA_DETECT_MISMATCH:
     D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,
-                                                     Record[Idx++]);
+                                                     *Record++);
     break;
   case DECL_EMPTY:
     D = EmptyDecl::CreateDeserialized(Context, ID);
@@ -3505,7 +3491,7 @@
         ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, Offsets.second, ID))
       return nullptr;
   }
-  assert(Idx == Record.size());
+  assert(Record == Record.end());
 
   // Load any relevant update records.
   PendingUpdateRecords.push_back(std::make_pair(ID, D));
@@ -3545,15 +3531,14 @@
       llvm::BitstreamCursor &Cursor = F->DeclsCursor;
       SavedStreamPosition SavedPosition(Cursor);
       Cursor.JumpToBit(Offset);
-      RecordData Record;
       unsigned Code = Cursor.ReadCode();
-      unsigned RecCode = Cursor.readRecord(Code, Record);
+      ASTRecordReader Record(*this, *F);
+      unsigned RecCode = Record.readRecord(Cursor, Code);
       (void)RecCode;
       assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
 
-      unsigned Idx = 0;
-      ASTDeclReader Reader(*this, RecordLocation(F, Offset), ID,
-                           SourceLocation(), Record, Idx);
+      ASTDeclReader Reader(*this, Record, RecordLocation(F, Offset), ID,
+                           SourceLocation());
       Reader.UpdateDecl(D);
 
       // We might have made this declaration interesting. If so, remember that
@@ -3762,13 +3747,13 @@
 }
 
 void ASTDeclReader::UpdateDecl(Decl *D) {
-  while (Idx < Record.size()) {
-    switch ((DeclUpdateKind)Record[Idx++]) {
+  while (Record != Record.end()) {
+    switch ((DeclUpdateKind)*Record++) {
     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(Idx);
+      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.
@@ -3778,7 +3763,7 @@
 
     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
       // It will be added to the template's specializations set when loaded.
-      (void)Record.ReadDecl(Idx);
+      (void)Record.ReadDecl();
       break;
 
     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
@@ -3841,7 +3826,7 @@
         return;
       }
 
-      if (Record[Idx++]) {
+      if (*Record++) {
         // Maintain AST consistency: any later redeclarations of this function
         // are inline if this one is. (We might have merged another declaration
         // into this one.)
@@ -3851,14 +3836,14 @@
       }
       FD->setInnerLocStart(ReadSourceLocation());
       if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
-        CD->NumCtorInitializers = Record[Idx++];
+        CD->NumCtorInitializers = *Record++;
         if (CD->NumCtorInitializers)
           CD->CtorInitializers = ReadGlobalOffset();
       }
       // Store the offset of the body so we can lazily load it later.
       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
       HasPendingBody = true;
-      assert(Idx == Record.size() && "lazy body must be last");
+      assert(Record == Record.end() && "lazy body must be last");
       break;
     }
 
@@ -3877,7 +3862,7 @@
         Reader.PendingFakeDefinitionData.erase(OldDD);
       }
 
-      auto TSK = (TemplateSpecializationKind)Record[Idx++];
+      auto TSK = (TemplateSpecializationKind)*Record++;
       SourceLocation POI = ReadSourceLocation();
       if (MemberSpecializationInfo *MSInfo =
               RD->getMemberSpecializationInfo()) {
@@ -3889,11 +3874,11 @@
         Spec->setTemplateSpecializationKind(TSK);
         Spec->setPointOfInstantiation(POI);
 
-        if (Record[Idx++]) {
+        if (*Record++) {
           auto PartialSpec =
               ReadDeclAs<ClassTemplatePartialSpecializationDecl>();
           SmallVector<TemplateArgument, 8> TemplArgs;
-          Record.ReadTemplateArgumentList(TemplArgs, Idx);
+          Record.ReadTemplateArgumentList(TemplArgs);
           auto *TemplArgList = TemplateArgumentList::CreateCopy(
               Reader.getContext(), TemplArgs);
 
@@ -3905,14 +3890,14 @@
         }
       }
 
-      RD->setTagKind((TagTypeKind)Record[Idx++]);
+      RD->setTagKind((TagTypeKind)*Record++);
       RD->setLocation(ReadSourceLocation());
       RD->setLocStart(ReadSourceLocation());
       RD->setBraceRange(ReadSourceRange());
 
-      if (Record[Idx++]) {
+      if (*Record++) {
         AttrVec Attrs;
-        Record.ReadAttributes(Attrs, Idx);
+        Record.ReadAttributes(Attrs);
         // If the declaration already has attributes, we assume that some other
         // AST file already loaded them.
         if (!D->hasAttrs())
@@ -3935,7 +3920,7 @@
     case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
       FunctionProtoType::ExceptionSpecInfo ESI;
       SmallVector<QualType, 8> ExceptionStorage;
-      Record.readExceptionSpec(ExceptionStorage, ESI, Idx);
+      Record.readExceptionSpec(ExceptionStorage, ESI);
 
       // Update this declaration's exception specification, if needed.
       auto *FD = cast<FunctionDecl>(D);
@@ -3957,7 +3942,7 @@
 
     case UPD_CXX_DEDUCED_RETURN_TYPE: {
       // FIXME: Also do this when merging redecls.
-      QualType DeducedResultType = Record.readType(Idx);
+      QualType DeducedResultType = Record.readType();
       for (auto *Redecl : merged_redecls(D)) {
         // FIXME: If the return type is already deduced, check that it matches.
         FunctionDecl *FD = cast<FunctionDecl>(Redecl);
@@ -3973,11 +3958,11 @@
     }
 
     case UPD_MANGLING_NUMBER:
-      Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
+      Reader.Context.setManglingNumber(cast<NamedDecl>(D), *Record++);
       break;
 
     case UPD_STATIC_LOCAL_NUMBER:
-      Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
+      Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), *Record++);
       break;
 
     case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
@@ -4010,7 +3995,7 @@
     case UPD_DECL_MARKED_OPENMP_DECLARETARGET:
     case UPD_ADDED_ATTR_TO_RECORD:
       AttrVec Attrs;
-      Record.ReadAttributes(Attrs, Idx);
+      Record.ReadAttributes(Attrs);
       assert(Attrs.size() == 1);
       D->addAttr(Attrs[0]);
       break;
Index: lib/Serialization/ASTReaderStmt.cpp
===================================================================
--- lib/Serialization/ASTReaderStmt.cpp
+++ lib/Serialization/ASTReaderStmt.cpp
@@ -27,49 +27,46 @@
   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
     friend class OMPClauseReader;
 
-    ASTRecordReader Record;
+    ASTRecordReader &Record;
     llvm::BitstreamCursor &DeclsCursor;
-    unsigned &Idx;
 
     SourceLocation ReadSourceLocation() {
-      return Record.ReadSourceLocation(Idx);
+      return Record.ReadSourceLocation();
     }
 
     SourceRange ReadSourceRange() {
-      return Record.ReadSourceRange(Idx);
+      return Record.ReadSourceRange();
     }
 
     std::string ReadString() {
-      return Record.ReadString(Idx);
+      return Record.ReadString();
     }
 
     TypeSourceInfo *GetTypeSourceInfo() {
-      return Record.GetTypeSourceInfo(Idx);
+      return Record.GetTypeSourceInfo();
     }
 
     Decl *ReadDecl() {
-      return Record.ReadDecl(Idx);
+      return Record.ReadDecl();
     }
 
     template<typename T>
     T *ReadDeclAs() {
-      return Record.ReadDeclAs<T>(Idx);
+      return Record.ReadDeclAs<T>();
     }
 
     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc,
                                 DeclarationName Name) {
-      Record.ReadDeclarationNameLoc(DNLoc, Name, Idx);
+      Record.ReadDeclarationNameLoc(DNLoc, Name);
     }
 
     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
-      Record.ReadDeclarationNameInfo(NameInfo, Idx);
+      Record.ReadDeclarationNameInfo(NameInfo);
     }
 
   public:
-    ASTStmtReader(ASTReader &Reader, ModuleFile &F,
-                  llvm::BitstreamCursor &Cursor,
-                  const ASTReader::RecordData &Record, unsigned &Idx)
-        : Record(Reader, Record, F), DeclsCursor(Cursor), Idx(Idx) { }
+    ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
+        : Record(Record), DeclsCursor(Cursor) {}
 
     /// \brief The number of record fields required for the Stmt class
     /// itself.
@@ -102,24 +99,24 @@
   ArgInfo.setLAngleLoc(ReadSourceLocation());
   ArgInfo.setRAngleLoc(ReadSourceLocation());
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
-    ArgInfo.addArgument(Record.ReadTemplateArgumentLoc(Idx));
+    ArgInfo.addArgument(Record.ReadTemplateArgumentLoc());
   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
 }
 
 void ASTStmtReader::VisitStmt(Stmt *S) {
-  assert(Idx == NumStmtFields && "Incorrect statement field count");
+  assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
 }
 
 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
   VisitStmt(S);
   S->setSemiLoc(ReadSourceLocation());
-  S->HasLeadingEmptyMacro = Record[Idx++];
+  S->HasLeadingEmptyMacro = *Record++;
 }
 
 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
   VisitStmt(S);
   SmallVector<Stmt *, 16> Stmts;
-  unsigned NumStmts = Record[Idx++];
+  unsigned NumStmts = *Record++;
   while (NumStmts--)
     Stmts.push_back(Record.ReadSubStmt());
   S->setStmts(Record.getContext(), Stmts);
@@ -129,7 +126,7 @@
 
 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
   VisitStmt(S);
-  Record.RecordSwitchCaseID(S, Record[Idx++]);
+  Record.RecordSwitchCaseID(S, *Record++);
   S->setKeywordLoc(ReadSourceLocation());
   S->setColonLoc(ReadSourceLocation());
 }
@@ -158,9 +155,9 @@
 
 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
   VisitStmt(S);
-  uint64_t NumAttrs = Record[Idx++];
+  uint64_t NumAttrs = *Record++;
   AttrVec Attrs;
-  Record.ReadAttributes(Attrs, Idx);
+  Record.ReadAttributes(Attrs);
   (void)NumAttrs;
   assert(NumAttrs == S->NumAttrs);
   assert(NumAttrs == Attrs.size());
@@ -171,7 +168,7 @@
 
 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
-  S->setConstexpr(Record[Idx++]);
+  S->setConstexpr(*Record++);
   S->setInit(Record.ReadSubStmt());
   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
   S->setCond(Record.ReadSubExpr());
@@ -188,12 +185,12 @@
   S->setCond(Record.ReadSubExpr());
   S->setBody(Record.ReadSubStmt());
   S->setSwitchLoc(ReadSourceLocation());
-  if (Record[Idx++])
+  if (*Record++)
     S->setAllEnumCasesCovered();
 
   SwitchCase *PrevSC = nullptr;
-  for (unsigned N = Record.size(); Idx != N; ++Idx) {
-    SwitchCase *SC = Record.getSwitchCaseWithID(Record[Idx]);
+  for (auto E = Record.end(); Record != E; ++Record) {
+    SwitchCase *SC = Record.getSwitchCaseWithID(*Record);
     if (PrevSC)
       PrevSC->setNextSwitchCase(SC);
     else
@@ -269,13 +266,13 @@
   S->setStartLoc(ReadSourceLocation());
   S->setEndLoc(ReadSourceLocation());
 
-  if (Idx + 1 == Record.size()) {
+  if (Record.end() - Record == 1) {
     // Single declaration
     S->setDeclGroup(DeclGroupRef(ReadDecl()));
   } else {
     SmallVector<Decl *, 16> Decls;
-    Decls.reserve(Record.size() - Idx);
-    for (unsigned N = Record.size(); Idx != N; )
+    Decls.reserve(Record.end() - Record);
+    for (auto E = Record.end(); Record != E; )
       Decls.push_back(ReadDecl());
     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
                                                    Decls.data(),
@@ -285,12 +282,12 @@
 
 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
   VisitStmt(S);
-  S->NumOutputs = Record[Idx++];
-  S->NumInputs = Record[Idx++];
-  S->NumClobbers = Record[Idx++];
+  S->NumOutputs = *Record++;
+  S->NumInputs = *Record++;
+  S->NumClobbers = *Record++;
   S->setAsmLoc(ReadSourceLocation());
-  S->setVolatile(Record[Idx++]);
-  S->setSimple(Record[Idx++]);
+  S->setVolatile(*Record++);
+  S->setSimple(*Record++);
 }
 
 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
@@ -307,7 +304,7 @@
   SmallVector<StringLiteral*, 16> Constraints;
   SmallVector<Stmt*, 16> Exprs;
   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
-    Names.push_back(Record.GetIdentifierInfo(Idx));
+    Names.push_back(Record.GetIdentifierInfo());
     Constraints.push_back(cast_or_null<StringLiteral>(Record.ReadSubStmt()));
     Exprs.push_back(Record.ReadSubStmt());
   }
@@ -327,14 +324,14 @@
   VisitAsmStmt(S);
   S->LBraceLoc = ReadSourceLocation();
   S->EndLoc = ReadSourceLocation();
-  S->NumAsmToks = Record[Idx++];
+  S->NumAsmToks = *Record++;
   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(Idx));
+    AsmToks.push_back(Record.ReadToken());
   }
 
   // The calls to reserve() for the FooData vectors are mandatory to
@@ -390,9 +387,9 @@
 
 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);
-  ++Idx;
+  ++Record;
   S->setCapturedDecl(ReadDeclAs<CapturedDecl>());
-  S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));
+  S->setCapturedRegionKind(static_cast<CapturedRegionKind>(*Record++));
   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>());
 
   // Capture inits
@@ -409,45 +406,46 @@
   for (auto &I : S->captures()) {
     I.VarAndKind.setPointer(ReadDeclAs<VarDecl>());
     I.VarAndKind
-        .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++]));
+        .setInt(static_cast<CapturedStmt::VariableCaptureKind>(*Record++));
     I.Loc = ReadSourceLocation();
   }
 }
 
 void ASTStmtReader::VisitExpr(Expr *E) {
   VisitStmt(E);
-  E->setType(Record.readType(Idx));
-  E->setTypeDependent(Record[Idx++]);
-  E->setValueDependent(Record[Idx++]);
-  E->setInstantiationDependent(Record[Idx++]);
-  E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
-  E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
-  E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
-  assert(Idx == NumExprFields && "Incorrect expression field count");
+  E->setType(Record.readType());
+  E->setTypeDependent(*Record++);
+  E->setValueDependent(*Record++);
+  E->setInstantiationDependent(*Record++);
+  E->ExprBits.ContainsUnexpandedParameterPack = *Record++;
+  E->setValueKind(static_cast<ExprValueKind>(*Record++));
+  E->setObjectKind(static_cast<ExprObjectKind>(*Record++));
+  assert(Record.getIdx() == NumExprFields &&
+         "Incorrect expression field count");
 }
 
 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
-  E->Type = (PredefinedExpr::IdentType)Record[Idx++];
+  E->Type = (PredefinedExpr::IdentType)*Record++;
   E->FnName = cast_or_null<StringLiteral>(Record.ReadSubExpr());
 }
 
 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
   VisitExpr(E);
 
-  E->DeclRefExprBits.HasQualifier = Record[Idx++];
-  E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
-  E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];
-  E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++];
-  E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record[Idx++];
+  E->DeclRefExprBits.HasQualifier = *Record++;
+  E->DeclRefExprBits.HasFoundDecl = *Record++;
+  E->DeclRefExprBits.HasTemplateKWAndArgsInfo = *Record++;
+  E->DeclRefExprBits.HadMultipleCandidates = *Record++;
+  E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = *Record++;
   unsigned NumTemplateArgs = 0;
   if (E->hasTemplateKWAndArgsInfo())
-    NumTemplateArgs = Record[Idx++];
+    NumTemplateArgs = *Record++;
 
   if (E->hasQualifier())
     new (E->getTrailingObjects<NestedNameSpecifierLoc>())
-        NestedNameSpecifierLoc(Record.ReadNestedNameSpecifierLoc(Idx));
+        NestedNameSpecifierLoc(Record.ReadNestedNameSpecifierLoc());
 
   if (E->hasFoundDecl())
     *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();
@@ -465,14 +463,14 @@
 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
-  E->setValue(Record.getContext(), Record.ReadAPInt(Idx));
+  E->setValue(Record.getContext(), Record.ReadAPInt());
 }
 
 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
   VisitExpr(E);
-  E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++]));
-  E->setExact(Record[Idx++]);
-  E->setValue(Record.getContext(), Record.ReadAPFloat(E->getSemantics(), Idx));
+  E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(*Record++));
+  E->setExact(*Record++);
+  E->setValue(Record.getContext(), Record.ReadAPFloat(E->getSemantics()));
   E->setLocation(ReadSourceLocation());
 }
 
@@ -483,18 +481,18 @@
 
 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
   VisitExpr(E);
-  unsigned Len = Record[Idx++];
-  assert(Record[Idx] == E->getNumConcatenated() &&
+  unsigned Len = *Record++;
+  assert(*Record == E->getNumConcatenated() &&
          "Wrong number of concatenated tokens!");
-  ++Idx;
+  ++Record;
   StringLiteral::StringKind kind =
-        static_cast<StringLiteral::StringKind>(Record[Idx++]);
-  bool isPascal = Record[Idx++];
+        static_cast<StringLiteral::StringKind>(*Record++);
+  bool isPascal = *Record++;
 
   // Read string data
-  SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
+  SmallString<16> Str(&*Record, Record + Len);
   E->setString(Record.getContext(), Str, kind, isPascal);
-  Idx += Len;
+  Record += Len;
 
   // Read source locations
   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
@@ -503,9 +501,9 @@
 
 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
   VisitExpr(E);
-  E->setValue(Record[Idx++]);
+  E->setValue(*Record++);
   E->setLocation(ReadSourceLocation());
-  E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));
+  E->setKind(static_cast<CharacterLiteral::CharacterKind>(*Record++));
 }
 
 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
@@ -517,7 +515,7 @@
 
 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
   VisitExpr(E);
-  unsigned NumExprs = Record[Idx++];
+  unsigned NumExprs = *Record++;
   E->Exprs = new (Record.getContext()) Stmt*[NumExprs];
   for (unsigned i = 0; i != NumExprs; ++i)
     E->Exprs[i] = Record.ReadSubStmt();
@@ -529,26 +527,26 @@
 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
   E->setSubExpr(Record.ReadSubExpr());
-  E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
+  E->setOpcode((UnaryOperator::Opcode)*Record++);
   E->setOperatorLoc(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
   VisitExpr(E);
-  assert(E->getNumComponents() == Record[Idx]);
-  ++Idx;
-  assert(E->getNumExpressions() == Record[Idx]);
-  ++Idx;
+  assert(E->getNumComponents() == *Record);
+  ++Record;
+  assert(E->getNumExpressions() == *Record);
+  ++Record;
   E->setOperatorLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
   E->setTypeSourceInfo(GetTypeSourceInfo());
   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
-    OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(Record[Idx++]);
+    OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(*Record++);
     SourceLocation Start = ReadSourceLocation();
     SourceLocation End = ReadSourceLocation();
     switch (Kind) {
     case OffsetOfNode::Array:
-      E->setComponent(I, OffsetOfNode(Start, Record[Idx++], End));
+      E->setComponent(I, OffsetOfNode(Start, *Record++, End));
       break;
 
     case OffsetOfNode::Field:
@@ -559,12 +557,12 @@
     case OffsetOfNode::Identifier:
       E->setComponent(
           I,
-          OffsetOfNode(Start, Record.GetIdentifierInfo(Idx), End));
+          OffsetOfNode(Start, Record.GetIdentifierInfo(), End));
       break;
 
     case OffsetOfNode::Base: {
       CXXBaseSpecifier *Base = new (Record.getContext()) CXXBaseSpecifier();
-      *Base = Record.ReadCXXBaseSpecifier(Idx);
+      *Base = Record.ReadCXXBaseSpecifier();
       E->setComponent(I, OffsetOfNode(Base));
       break;
     }
@@ -577,10 +575,10 @@
 
 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
   VisitExpr(E);
-  E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
-  if (Record[Idx] == 0) {
+  E->setKind(static_cast<UnaryExprOrTypeTrait>(*Record++));
+  if (*Record == 0) {
     E->setArgument(Record.ReadSubExpr());
-    ++Idx;
+    ++Record;
   } else {
     E->setArgument(GetTypeSourceInfo());
   }
@@ -606,7 +604,7 @@
 
 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
-  E->setNumArgs(Record.getContext(), Record[Idx++]);
+  E->setNumArgs(Record.getContext(), *Record++);
   E->setRParenLoc(ReadSourceLocation());
   E->setCallee(Record.ReadSubExpr());
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
@@ -628,33 +626,33 @@
   E->setBase(Record.ReadSubExpr());
   E->setIsaMemberLoc(ReadSourceLocation());
   E->setOpLoc(ReadSourceLocation());
-  E->setArrow(Record[Idx++]);
+  E->setArrow(*Record++);
 }
 
 void ASTStmtReader::
 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
   VisitExpr(E);
   E->Operand = Record.ReadSubExpr();
-  E->setShouldCopy(Record[Idx++]);
+  E->setShouldCopy(*Record++);
 }
 
 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
   VisitExplicitCastExpr(E);
   E->LParenLoc = ReadSourceLocation();
   E->BridgeKeywordLoc = ReadSourceLocation();
-  E->Kind = Record[Idx++];
+  E->Kind = *Record++;
 }
 
 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
   VisitExpr(E);
-  unsigned NumBaseSpecs = Record[Idx++];
+  unsigned NumBaseSpecs = *Record++;
   assert(NumBaseSpecs == E->path_size());
   E->setSubExpr(Record.ReadSubExpr());
-  E->setCastKind((CastKind)Record[Idx++]);
+  E->setCastKind((CastKind)*Record++);
   CastExpr::path_iterator BaseI = E->path_begin();
   while (NumBaseSpecs--) {
     CXXBaseSpecifier *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
-    *BaseSpec = Record.ReadCXXBaseSpecifier(Idx);
+    *BaseSpec = Record.ReadCXXBaseSpecifier();
     *BaseI++ = BaseSpec;
   }
 }
@@ -663,15 +661,15 @@
   VisitExpr(E);
   E->setLHS(Record.ReadSubExpr());
   E->setRHS(Record.ReadSubExpr());
-  E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
+  E->setOpcode((BinaryOperator::Opcode)*Record++);
   E->setOperatorLoc(ReadSourceLocation());
-  E->setFPContractable((bool)Record[Idx++]);
+  E->setFPContractable((bool)*Record++);
 }
 
 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
   VisitBinaryOperator(E);
-  E->setComputationLHSType(Record.readType(Idx));
-  E->setComputationResultType(Record.readType(Idx));
+  E->setComputationLHSType(Record.readType());
+  E->setComputationResultType(Record.readType());
 }
 
 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
@@ -715,13 +713,13 @@
   E->setLParenLoc(ReadSourceLocation());
   E->setTypeSourceInfo(GetTypeSourceInfo());
   E->setInitializer(Record.ReadSubExpr());
-  E->setFileScope(Record[Idx++]);
+  E->setFileScope(*Record++);
 }
 
 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   VisitExpr(E);
   E->setBase(Record.ReadSubExpr());
-  E->setAccessor(Record.GetIdentifierInfo(Idx));
+  E->setAccessor(Record.GetIdentifierInfo());
   E->setAccessorLoc(ReadSourceLocation());
 }
 
@@ -731,15 +729,15 @@
     E->setSyntacticForm(SyntForm);
   E->setLBraceLoc(ReadSourceLocation());
   E->setRBraceLoc(ReadSourceLocation());
-  bool isArrayFiller = Record[Idx++];
+  bool isArrayFiller = *Record++;
   Expr *filler = nullptr;
   if (isArrayFiller) {
     filler = Record.ReadSubExpr();
     E->ArrayFillerOrUnionFieldInit = filler;
   } else
     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>();
-  E->sawArrayRangeDesignator(Record[Idx++]);
-  unsigned NumInits = Record[Idx++];
+  E->sawArrayRangeDesignator(*Record++);
+  unsigned NumInits = *Record++;
   E->reserveInits(Record.getContext(), NumInits);
   if (isArrayFiller) {
     for (unsigned I = 0; I != NumInits; ++I) {
@@ -756,16 +754,16 @@
   typedef DesignatedInitExpr::Designator Designator;
 
   VisitExpr(E);
-  unsigned NumSubExprs = Record[Idx++];
+  unsigned NumSubExprs = *Record++;
   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
   for (unsigned I = 0; I != NumSubExprs; ++I)
     E->setSubExpr(I, Record.ReadSubExpr());
   E->setEqualOrColonLoc(ReadSourceLocation());
-  E->setGNUSyntax(Record[Idx++]);
+  E->setGNUSyntax(*Record++);
 
   SmallVector<Designator, 4> Designators;
-  while (Idx < Record.size()) {
-    switch ((DesignatorTypes)Record[Idx++]) {
+  while (Record < Record.end()) {
+    switch ((DesignatorTypes)*Record++) {
     case DESIG_FIELD_DECL: {
       FieldDecl *Field = ReadDeclAs<FieldDecl>();
       SourceLocation DotLoc = ReadSourceLocation();
@@ -777,7 +775,7 @@
     }
 
     case DESIG_FIELD_NAME: {
-      const IdentifierInfo *Name = Record.GetIdentifierInfo(Idx);
+      const IdentifierInfo *Name = Record.GetIdentifierInfo();
       SourceLocation DotLoc = ReadSourceLocation();
       SourceLocation FieldLoc = ReadSourceLocation();
       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
@@ -785,7 +783,7 @@
     }
 
     case DESIG_ARRAY: {
-      unsigned Index = Record[Idx++];
+      unsigned Index = *Record++;
       SourceLocation LBracketLoc = ReadSourceLocation();
       SourceLocation RBracketLoc = ReadSourceLocation();
       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
@@ -793,7 +791,7 @@
     }
 
     case DESIG_ARRAY_RANGE: {
-      unsigned Index = Record[Idx++];
+      unsigned Index = *Record++;
       SourceLocation LBracketLoc = ReadSourceLocation();
       SourceLocation EllipsisLoc = ReadSourceLocation();
       SourceLocation RBracketLoc = ReadSourceLocation();
@@ -837,7 +835,7 @@
   E->setWrittenTypeInfo(GetTypeSourceInfo());
   E->setBuiltinLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
-  E->setIsMicrosoftABI(Record[Idx++]);
+  E->setIsMicrosoftABI(*Record++);
 }
 
 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
@@ -861,7 +859,7 @@
   E->setRHS(Record.ReadSubExpr());
   E->setBuiltinLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
-  E->setIsConditionTrue(Record[Idx++]);
+  E->setIsConditionTrue(*Record++);
 }
 
 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
@@ -872,7 +870,7 @@
 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   SmallVector<Expr *, 16> Exprs;
-  unsigned NumExprs = Record[Idx++];
+  unsigned NumExprs = *Record++;
   while (NumExprs--)
     Exprs.push_back(Record.ReadSubExpr());
   E->setExprs(Record.getContext(), Exprs);
@@ -895,7 +893,7 @@
 
 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
   VisitExpr(E);
-  E->NumAssocs = Record[Idx++];
+  E->NumAssocs = *Record++;
   E->AssocTypes = new (Record.getContext()) TypeSourceInfo*[E->NumAssocs];
   E->SubExprs =
    new(Record.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
@@ -905,7 +903,7 @@
     E->AssocTypes[I] = GetTypeSourceInfo();
     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.ReadSubExpr();
   }
-  E->ResultIndex = Record[Idx++];
+  E->ResultIndex = *Record++;
 
   E->GenericLoc = ReadSourceLocation();
   E->DefaultLoc = ReadSourceLocation();
@@ -914,9 +912,9 @@
 
 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
   VisitExpr(E);
-  unsigned numSemanticExprs = Record[Idx++];
+  unsigned numSemanticExprs = *Record++;
   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
-  E->PseudoObjectExprBits.ResultIndex = Record[Idx++];
+  E->PseudoObjectExprBits.ResultIndex = *Record++;
 
   // Read the syntactic expression.
   E->getSubExprsBuffer()[0] = Record.ReadSubExpr();
@@ -930,7 +928,7 @@
 
 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
   VisitExpr(E);
-  E->Op = AtomicExpr::AtomicOp(Record[Idx++]);
+  E->Op = AtomicExpr::AtomicOp(*Record++);
   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
   for (unsigned I = 0; I != E->NumSubExprs; ++I)
     E->SubExprs[I] = Record.ReadSubExpr();
@@ -957,7 +955,7 @@
 
 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
   VisitExpr(E);
-  unsigned NumElements = Record[Idx++];
+  unsigned NumElements = *Record++;
   assert(NumElements == E->getNumElements() && "Wrong number of elements");
   Expr **Elements = E->getElements();
   for (unsigned I = 0, N = NumElements; I != N; ++I)
@@ -968,9 +966,9 @@
 
 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
   VisitExpr(E);
-  unsigned NumElements = Record[Idx++];
+  unsigned NumElements = *Record++;
   assert(NumElements == E->getNumElements() && "Wrong number of elements");
-  bool HasPackExpansions = Record[Idx++];
+  bool HasPackExpansions = *Record++;
   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
   ObjCDictionaryLiteral::KeyValuePair *KeyValues =
       E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
@@ -981,7 +979,7 @@
     KeyValues[I].Value = Record.ReadSubExpr();
     if (HasPackExpansions) {
       Expansions[I].EllipsisLoc = ReadSourceLocation();
-      Expansions[I].NumExpansionsPlusOne = Record[Idx++];
+      Expansions[I].NumExpansionsPlusOne = *Record++;
     }
   }
   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
@@ -997,7 +995,7 @@
 
 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
   VisitExpr(E);
-  E->setSelector(Record.ReadSelector(Idx));
+  E->setSelector(Record.ReadSelector());
   E->setAtLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
@@ -1016,14 +1014,14 @@
   E->setLocation(ReadSourceLocation());
   E->setOpLoc(ReadSourceLocation());
   E->setBase(Record.ReadSubExpr());
-  E->setIsArrow(Record[Idx++]);
-  E->setIsFreeIvar(Record[Idx++]);
+  E->setIsArrow(*Record++);
+  E->setIsFreeIvar(*Record++);
 }
 
 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
   VisitExpr(E);
-  unsigned MethodRefFlags = Record[Idx++];
-  bool Implicit = Record[Idx++] != 0;
+  unsigned MethodRefFlags = *Record++;
+  bool Implicit = *Record++ != 0;
   if (Implicit) {
     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>();
     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>();
@@ -1033,12 +1031,12 @@
   }
   E->setLocation(ReadSourceLocation());
   E->setReceiverLocation(ReadSourceLocation());
-  switch (Record[Idx++]) {
+  switch (*Record++) {
   case 0:
     E->setBase(Record.ReadSubExpr());
     break;
   case 1:
-    E->setSuperReceiver(Record.readType(Idx));
+    E->setSuperReceiver(Record.readType());
     break;
   case 2:
     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>());
@@ -1057,14 +1055,14 @@
 
 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
   VisitExpr(E);
-  assert(Record[Idx] == E->getNumArgs());
-  ++Idx;
-  unsigned NumStoredSelLocs = Record[Idx++];
-  E->SelLocsKind = Record[Idx++];
-  E->setDelegateInitCall(Record[Idx++]);
-  E->IsImplicit = Record[Idx++];
+  assert(*Record == E->getNumArgs());
+  ++Record;
+  unsigned NumStoredSelLocs = *Record++;
+  E->SelLocsKind = *Record++;
+  E->setDelegateInitCall(*Record++);
+  E->IsImplicit = *Record++;
   ObjCMessageExpr::ReceiverKind Kind
-    = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
+    = static_cast<ObjCMessageExpr::ReceiverKind>(*Record++);
   switch (Kind) {
   case ObjCMessageExpr::Instance:
     E->setInstanceReceiver(Record.ReadSubExpr());
@@ -1076,7 +1074,7 @@
 
   case ObjCMessageExpr::SuperClass:
   case ObjCMessageExpr::SuperInstance: {
-    QualType T = Record.readType(Idx);
+    QualType T = Record.readType();
     SourceLocation SuperLoc = ReadSourceLocation();
     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
     break;
@@ -1085,10 +1083,10 @@
 
   assert(Kind == E->getReceiverKind());
 
-  if (Record[Idx++])
+  if (*Record++)
     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>());
   else
-    E->setSelector(Record.ReadSelector(Idx));
+    E->setSelector(Record.ReadSelector());
 
   E->LBracLoc = ReadSourceLocation();
   E->RBracLoc = ReadSourceLocation();
@@ -1132,9 +1130,9 @@
 
 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
   VisitStmt(S);
-  assert(Record[Idx] == S->getNumCatchStmts());
-  ++Idx;
-  bool HasFinally = Record[Idx++];
+  assert(*Record == S->getNumCatchStmts());
+  ++Record;
+  bool HasFinally = *Record++;
   S->setTryBody(Record.ReadSubStmt());
   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.ReadSubStmt()));
@@ -1159,16 +1157,16 @@
 
 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
   VisitExpr(E);
-  E->setValue(Record[Idx++]);
+  E->setValue(*Record++);
   E->setLocation(ReadSourceLocation());
 }
 
 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
   VisitExpr(E);
-  SourceRange R = Record.ReadSourceRange(Idx);
+  SourceRange R = Record.ReadSourceRange();
   E->AtLoc = R.getBegin();
   E->RParen = R.getEnd();
-  E->VersionToCheck = Record.ReadVersionTuple(Idx);
+  E->VersionToCheck = Record.ReadVersionTuple();
 }
 
 //===----------------------------------------------------------------------===//
@@ -1184,8 +1182,8 @@
 
 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
   VisitStmt(S);
-  assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
-  ++Idx;
+  assert(*Record == S->getNumHandlers() && "NumStmtFields is wrong ?");
+  ++Record;
   S->TryLoc = ReadSourceLocation();
   S->getStmts()[0] = Record.ReadSubStmt();
   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
@@ -1210,34 +1208,34 @@
 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
   VisitStmt(S);
   S->KeywordLoc = ReadSourceLocation();
-  S->IsIfExists = Record[Idx++];
-  S->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  S->IsIfExists = *Record++;
+  S->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   ReadDeclarationNameInfo(S->NameInfo);
   S->SubStmt = Record.ReadSubStmt();
 }
 
 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
   VisitCallExpr(E);
-  E->Operator = (OverloadedOperatorKind)Record[Idx++];
-  E->Range = Record.ReadSourceRange(Idx);
-  E->setFPContractable((bool)Record[Idx++]);
+  E->Operator = (OverloadedOperatorKind)*Record++;
+  E->Range = Record.ReadSourceRange();
+  E->setFPContractable((bool)*Record++);
 }
 
 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
   VisitExpr(E);
-  E->NumArgs = Record[Idx++];
+  E->NumArgs = *Record++;
   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->setConstructor(ReadDeclAs<CXXConstructorDecl>());
   E->setLocation(ReadSourceLocation());
-  E->setElidable(Record[Idx++]);
-  E->setHadMultipleCandidates(Record[Idx++]);
-  E->setListInitialization(Record[Idx++]);
-  E->setStdInitListInitialization(Record[Idx++]);
-  E->setRequiresZeroInitialization(Record[Idx++]);
-  E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
+  E->setElidable(*Record++);
+  E->setHadMultipleCandidates(*Record++);
+  E->setListInitialization(*Record++);
+  E->setStdInitListInitialization(*Record++);
+  E->setRequiresZeroInitialization(*Record++);
+  E->setConstructionKind((CXXConstructExpr::ConstructionKind)*Record++);
   E->ParenOrBraceRange = ReadSourceRange();
 }
 
@@ -1245,8 +1243,8 @@
   VisitExpr(E);
   E->Constructor = ReadDeclAs<CXXConstructorDecl>();
   E->Loc = ReadSourceLocation();
-  E->ConstructsVirtualBase = Record[Idx++];
-  E->InheritedFromVirtualBase = Record[Idx++];
+  E->ConstructsVirtualBase = *Record++;
+  E->InheritedFromVirtualBase = *Record++;
 }
 
 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
@@ -1256,13 +1254,13 @@
 
 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
   VisitExpr(E);
-  unsigned NumCaptures = Record[Idx++];
+  unsigned NumCaptures = *Record++;
   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
   E->IntroducerRange = ReadSourceRange();
-  E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);
+  E->CaptureDefault = static_cast<LambdaCaptureDefault>(*Record++);
   E->CaptureDefaultLoc = ReadSourceLocation();
-  E->ExplicitParams = Record[Idx++];
-  E->ExplicitResultType = Record[Idx++];
+  E->ExplicitParams = *Record++;
+  E->ExplicitResultType = *Record++;
   E->ClosingBrace = ReadSourceLocation();
 
   // Read capture initializers.
@@ -1316,7 +1314,7 @@
 
 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
   VisitExpr(E);
-  E->setValue(Record[Idx++]);
+  E->setValue(*Record++);
   E->setLocation(ReadSourceLocation());
 }
 
@@ -1341,14 +1339,14 @@
 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
   VisitExpr(E);
   E->setLocation(ReadSourceLocation());
-  E->setImplicit(Record[Idx++]);
+  E->setImplicit(*Record++);
 }
 
 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
   VisitExpr(E);
   E->ThrowLoc = ReadSourceLocation();
   E->Op = Record.ReadSubExpr();
-  E->IsThrownVariableInScope = Record[Idx++];
+  E->IsThrownVariableInScope = *Record++;
 }
 
 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
@@ -1365,7 +1363,7 @@
 
 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   VisitExpr(E);
-  E->setTemporary(Record.ReadCXXTemporary(Idx));
+  E->setTemporary(Record.ReadCXXTemporary());
   E->setSubExpr(Record.ReadSubExpr());
 }
 
@@ -1377,12 +1375,12 @@
 
 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
   VisitExpr(E);
-  E->GlobalNew = Record[Idx++];
-  bool isArray = Record[Idx++];
-  E->PassAlignment = Record[Idx++];
-  E->UsualArrayDeleteWantsSize = Record[Idx++];
-  unsigned NumPlacementArgs = Record[Idx++];
-  E->StoredInitializationStyle = Record[Idx++];
+  E->GlobalNew = *Record++;
+  bool isArray = *Record++;
+  E->PassAlignment = *Record++;
+  E->UsualArrayDeleteWantsSize = *Record++;
+  unsigned NumPlacementArgs = *Record++;
+  E->StoredInitializationStyle = *Record++;
   E->setOperatorNew(ReadDeclAs<FunctionDecl>());
   E->setOperatorDelete(ReadDeclAs<FunctionDecl>());
   E->AllocatedTypeInfo = GetTypeSourceInfo();
@@ -1401,10 +1399,10 @@
 
 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   VisitExpr(E);
-  E->GlobalDelete = Record[Idx++];
-  E->ArrayForm = Record[Idx++];
-  E->ArrayFormAsWritten = Record[Idx++];
-  E->UsualArrayDeleteWantsSize = Record[Idx++];
+  E->GlobalDelete = *Record++;
+  E->ArrayForm = *Record++;
+  E->ArrayFormAsWritten = *Record++;
+  E->UsualArrayDeleteWantsSize = *Record++;
   E->OperatorDelete = ReadDeclAs<FunctionDecl>();
   E->Argument = Record.ReadSubExpr();
   E->Loc = ReadSourceLocation();
@@ -1414,14 +1412,14 @@
   VisitExpr(E);
 
   E->Base = Record.ReadSubExpr();
-  E->IsArrow = Record[Idx++];
+  E->IsArrow = *Record++;
   E->OperatorLoc = ReadSourceLocation();
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   E->ScopeType = GetTypeSourceInfo();
   E->ColonColonLoc = ReadSourceLocation();
   E->TildeLoc = ReadSourceLocation();
 
-  IdentifierInfo *II = Record.GetIdentifierInfo(Idx);
+  IdentifierInfo *II = Record.GetIdentifierInfo();
   if (II)
     E->setDestroyedType(II, ReadSourceLocation());
   else
@@ -1431,13 +1429,13 @@
 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
   VisitExpr(E);
 
-  unsigned NumObjects = Record[Idx++];
+  unsigned NumObjects = *Record++;
   assert(NumObjects == E->getNumObjects());
   for (unsigned i = 0; i != NumObjects; ++i)
     E->getTrailingObjects<BlockDecl *>()[i] =
         ReadDeclAs<BlockDecl>();
 
-  E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record[Idx++];
+  E->ExprWithCleanupsBits.CleanupsHaveSideEffects = *Record++;
   E->SubExpr = Record.ReadSubExpr();
 }
 
@@ -1445,17 +1443,17 @@
 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
   VisitExpr(E);
 
-  if (Record[Idx++]) // HasTemplateKWAndArgsInfo
+  if (*Record++) // HasTemplateKWAndArgsInfo
     ReadTemplateKWAndArgsInfo(
         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
         E->getTrailingObjects<TemplateArgumentLoc>(),
-        /*NumTemplateArgs=*/Record[Idx++]);
+        /*NumTemplateArgs=*/*Record++);
 
   E->Base = Record.ReadSubExpr();
-  E->BaseType = Record.readType(Idx);
-  E->IsArrow = Record[Idx++];
+  E->BaseType = Record.readType();
+  E->IsArrow = *Record++;
   E->OperatorLoc = ReadSourceLocation();
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>();
   ReadDeclarationNameInfo(E->MemberNameInfo);
 }
@@ -1464,21 +1462,21 @@
 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
   VisitExpr(E);
 
-  if (Record[Idx++]) // HasTemplateKWAndArgsInfo
+  if (*Record++) // HasTemplateKWAndArgsInfo
     ReadTemplateKWAndArgsInfo(
         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
         E->getTrailingObjects<TemplateArgumentLoc>(),
-        /*NumTemplateArgs=*/Record[Idx++]);
+        /*NumTemplateArgs=*/*Record++);
 
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   ReadDeclarationNameInfo(E->NameInfo);
 }
 
 void
 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
   VisitExpr(E);
-  assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
-  ++Idx; // NumArgs;
+  assert(*Record == E->arg_size() && "Read wrong record during creation ?");
+  ++Record;
   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
     E->setArg(I, Record.ReadSubExpr());
   E->Type = GetTypeSourceInfo();
@@ -1489,45 +1487,45 @@
 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
   VisitExpr(E);
 
-  if (Record[Idx++]) // HasTemplateKWAndArgsInfo
+  if (*Record++) // HasTemplateKWAndArgsInfo
     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
                               E->getTrailingTemplateArgumentLoc(),
-                              /*NumTemplateArgs=*/Record[Idx++]);
+                              /*NumTemplateArgs=*/*Record++);
 
-  unsigned NumDecls = Record[Idx++];
+  unsigned NumDecls = *Record++;
   UnresolvedSet<8> Decls;
   for (unsigned i = 0; i != NumDecls; ++i) {
     NamedDecl *D = ReadDeclAs<NamedDecl>();
-    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
+    AccessSpecifier AS = (AccessSpecifier)*Record++;
     Decls.addDecl(D, AS);
   }
   E->initializeResults(Record.getContext(), Decls.begin(), Decls.end());
 
   ReadDeclarationNameInfo(E->NameInfo);
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
 }
 
 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
   VisitOverloadExpr(E);
-  E->IsArrow = Record[Idx++];
-  E->HasUnresolvedUsing = Record[Idx++];
+  E->IsArrow = *Record++;
+  E->HasUnresolvedUsing = *Record++;
   E->Base = Record.ReadSubExpr();
-  E->BaseType = Record.readType(Idx);
+  E->BaseType = Record.readType();
   E->OperatorLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
   VisitOverloadExpr(E);
-  E->RequiresADL = Record[Idx++];
-  E->Overloaded = Record[Idx++];
+  E->RequiresADL = *Record++;
+  E->Overloaded = *Record++;
   E->NamingClass = ReadDeclAs<CXXRecordDecl>();
 }
 
 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
   VisitExpr(E);
-  E->TypeTraitExprBits.NumArgs = Record[Idx++];
-  E->TypeTraitExprBits.Kind = Record[Idx++];
-  E->TypeTraitExprBits.Value = Record[Idx++];
+  E->TypeTraitExprBits.NumArgs = *Record++;
+  E->TypeTraitExprBits.Kind = *Record++;
+  E->TypeTraitExprBits.Value = *Record++;
   SourceRange Range = ReadSourceRange();
   E->Loc = Range.getBegin();
   E->RParenLoc = Range.getEnd();
@@ -1539,8 +1537,8 @@
 
 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
   VisitExpr(E);
-  E->ATT = (ArrayTypeTrait)Record[Idx++];
-  E->Value = (unsigned int)Record[Idx++];
+  E->ATT = (ArrayTypeTrait)*Record++;
+  E->Value = (unsigned int)*Record++;
   SourceRange Range = ReadSourceRange();
   E->Loc = Range.getBegin();
   E->RParen = Range.getEnd();
@@ -1550,8 +1548,8 @@
 
 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
   VisitExpr(E);
-  E->ET = (ExpressionTrait)Record[Idx++];
-  E->Value = (bool)Record[Idx++];
+  E->ET = (ExpressionTrait)*Record++;
+  E->Value = (bool)*Record++;
   SourceRange Range = ReadSourceRange();
   E->QueriedExpression = Record.ReadSubExpr();
   E->Loc = Range.getBegin();
@@ -1560,7 +1558,7 @@
 
 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
   VisitExpr(E);
-  E->Value = (bool)Record[Idx++];
+  E->Value = (bool)*Record++;
   E->Range = ReadSourceRange();
   E->Operand = Record.ReadSubExpr();
 }
@@ -1568,25 +1566,25 @@
 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
   VisitExpr(E);
   E->EllipsisLoc = ReadSourceLocation();
-  E->NumExpansions = Record[Idx++];
+  E->NumExpansions = *Record++;
   E->Pattern = Record.ReadSubExpr();
 }
 
 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
   VisitExpr(E);
-  unsigned NumPartialArgs = Record[Idx++];
+  unsigned NumPartialArgs = *Record++;
   E->OperatorLoc = ReadSourceLocation();
   E->PackLoc = ReadSourceLocation();
   E->RParenLoc = ReadSourceLocation();
-  E->Pack = Record.ReadDeclAs<NamedDecl>(Idx);
+  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(Idx));
+      new (I) TemplateArgument(Record.ReadTemplateArgument());
   } else if (!E->isValueDependent()) {
-    E->Length = Record[Idx++];
+    E->Length = *Record++;
   }
 }
 
@@ -1602,7 +1600,7 @@
                                           SubstNonTypeTemplateParmPackExpr *E) {
   VisitExpr(E);
   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
-  TemplateArgument ArgPack = Record.ReadTemplateArgument(Idx);
+  TemplateArgument ArgPack = Record.ReadTemplateArgument();
   if (ArgPack.getKind() != TemplateArgument::Pack)
     return;
 
@@ -1613,7 +1611,7 @@
 
 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
   VisitExpr(E);
-  E->NumParameters = Record[Idx++];
+  E->NumParameters = *Record++;
   E->ParamPack = ReadDeclAs<ParmVarDecl>();
   E->NameLoc = ReadSourceLocation();
   ParmVarDecl **Parms = E->getTrailingObjects<ParmVarDecl *>();
@@ -1625,7 +1623,7 @@
   VisitExpr(E);
   E->State = Record.ReadSubExpr();
   auto VD = ReadDeclAs<ValueDecl>();
-  unsigned ManglingNumber = Record[Idx++];
+  unsigned ManglingNumber = *Record++;
   E->setExtendingDecl(VD, ManglingNumber);
 }
 
@@ -1636,7 +1634,7 @@
   E->RParenLoc = ReadSourceLocation();
   E->SubExprs[0] = Record.ReadSubExpr();
   E->SubExprs[1] = Record.ReadSubExpr();
-  E->Opcode = (BinaryOperatorKind)Record[Idx++];
+  E->Opcode = (BinaryOperatorKind)*Record++;
 }
 
 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
@@ -1654,9 +1652,9 @@
 //===----------------------------------------------------------------------===//
 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
   VisitExpr(E);
-  E->IsArrow = (Record[Idx++] != 0);
+  E->IsArrow = (*Record++ != 0);
   E->BaseExpr = Record.ReadSubExpr();
-  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc(Idx);
+  E->QualifierLoc = Record.ReadNestedNameSpecifierLoc();
   E->MemberLoc = ReadSourceLocation();
   E->TheDecl = ReadDeclAs<MSPropertyDecl>();
 }
@@ -1703,7 +1701,7 @@
 
 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
   VisitStmt(S);
-  S->IsCXXTry = Record[Idx++];
+  S->IsCXXTry = *Record++;
   S->TryLoc = ReadSourceLocation();
   S->Children[SEHTryStmt::TRY] = Record.ReadSubStmt();
   S->Children[SEHTryStmt::HANDLER] = Record.ReadSubStmt();
@@ -1736,10 +1734,9 @@
 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
   ASTStmtReader *Reader;
   ASTContext &Context;
-  unsigned &Idx;
 public:
-  OMPClauseReader(ASTStmtReader *R, ASTRecordReader &Record, unsigned &Idx)
-      : Reader(R), Context(Record.getContext()), Idx(Idx) {}
+  OMPClauseReader(ASTStmtReader *R, ASTRecordReader &Record)
+      : Reader(R), Context(Record.getContext()) {}
 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *C);
 #include "clang/Basic/OpenMPKinds.def"
   OMPClause *readClause();
@@ -1750,7 +1747,7 @@
 
 OMPClause *OMPClauseReader::readClause() {
   OMPClause *C;
-  switch (Reader->Record[Idx++]) {
+  switch (*Reader->Record++) {
   case OMPC_if:
     C = new (Context) OMPIfClause();
     break;
@@ -1815,46 +1812,46 @@
     C = new (Context) OMPNogroupClause();
     break;
   case OMPC_private:
-    C = OMPPrivateClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPPrivateClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_firstprivate:
-    C = OMPFirstprivateClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPFirstprivateClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_lastprivate:
-    C = OMPLastprivateClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPLastprivateClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_shared:
-    C = OMPSharedClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPSharedClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_reduction:
-    C = OMPReductionClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPReductionClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_linear:
-    C = OMPLinearClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPLinearClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_aligned:
-    C = OMPAlignedClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPAlignedClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_copyin:
-    C = OMPCopyinClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPCopyinClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_copyprivate:
-    C = OMPCopyprivateClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPCopyprivateClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_flush:
-    C = OMPFlushClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPFlushClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_depend:
-    C = OMPDependClause::CreateEmpty(Context, Reader->Record[Idx++]);
+    C = OMPDependClause::CreateEmpty(Context, *Reader->Record++);
     break;
   case OMPC_device:
     C = new (Context) OMPDeviceClause();
     break;
   case OMPC_map: {
-    unsigned NumVars = Reader->Record[Idx++];
-    unsigned NumDeclarations = Reader->Record[Idx++];
-    unsigned NumLists = Reader->Record[Idx++];
-    unsigned NumComponents = Reader->Record[Idx++];
+    unsigned NumVars = *Reader->Record++;
+    unsigned NumDeclarations = *Reader->Record++;
+    unsigned NumLists = *Reader->Record++;
+    unsigned NumComponents = *Reader->Record++;
     C = OMPMapClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
                                   NumComponents);
     break;
@@ -1884,37 +1881,37 @@
     C = new (Context) OMPDefaultmapClause();
     break;
   case OMPC_to: {
-    unsigned NumVars = Reader->Record[Idx++];
-    unsigned NumDeclarations = Reader->Record[Idx++];
-    unsigned NumLists = Reader->Record[Idx++];
-    unsigned NumComponents = Reader->Record[Idx++];
+    unsigned NumVars = *Reader->Record++;
+    unsigned NumDeclarations = *Reader->Record++;
+    unsigned NumLists = *Reader->Record++;
+    unsigned NumComponents = *Reader->Record++;
     C = OMPToClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
                                  NumComponents);
     break;
   }
   case OMPC_from: {
-    unsigned NumVars = Reader->Record[Idx++];
-    unsigned NumDeclarations = Reader->Record[Idx++];
-    unsigned NumLists = Reader->Record[Idx++];
-    unsigned NumComponents = Reader->Record[Idx++];
+    unsigned NumVars = *Reader->Record++;
+    unsigned NumDeclarations = *Reader->Record++;
+    unsigned NumLists = *Reader->Record++;
+    unsigned NumComponents = *Reader->Record++;
     C = OMPFromClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
                                    NumComponents);
     break;
   }
   case OMPC_use_device_ptr: {
-    unsigned NumVars = Reader->Record[Idx++];
-    unsigned NumDeclarations = Reader->Record[Idx++];
-    unsigned NumLists = Reader->Record[Idx++];
-    unsigned NumComponents = Reader->Record[Idx++];
+    unsigned NumVars = *Reader->Record++;
+    unsigned NumDeclarations = *Reader->Record++;
+    unsigned NumLists = *Reader->Record++;
+    unsigned NumComponents = *Reader->Record++;
     C = OMPUseDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
                                            NumLists, NumComponents);
     break;
   }
   case OMPC_is_device_ptr: {
-    unsigned NumVars = Reader->Record[Idx++];
-    unsigned NumDeclarations = Reader->Record[Idx++];
-    unsigned NumLists = Reader->Record[Idx++];
-    unsigned NumComponents = Reader->Record[Idx++];
+    unsigned NumVars = *Reader->Record++;
+    unsigned NumDeclarations = *Reader->Record++;
+    unsigned NumLists = *Reader->Record++;
+    unsigned NumComponents = *Reader->Record++;
     C = OMPIsDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
                                           NumLists, NumComponents);
     break;
@@ -1937,7 +1934,7 @@
 }
 
 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
-  C->setNameModifier(static_cast<OpenMPDirectiveKind>(Reader->Record[Idx++]));
+  C->setNameModifier(static_cast<OpenMPDirectiveKind>(*Reader->Record++));
   C->setNameModifierLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   C->setCondition(Reader->Record.ReadSubExpr());
@@ -1971,14 +1968,14 @@
 
 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
   C->setDefaultKind(
-       static_cast<OpenMPDefaultClauseKind>(Reader->Record[Idx++]));
+       static_cast<OpenMPDefaultClauseKind>(*Reader->Record++));
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDefaultKindKwLoc(Reader->ReadSourceLocation());
 }
 
 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
   C->setProcBindKind(
-       static_cast<OpenMPProcBindClauseKind>(Reader->Record[Idx++]));
+       static_cast<OpenMPProcBindClauseKind>(*Reader->Record++));
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setProcBindKindKwLoc(Reader->ReadSourceLocation());
 }
@@ -1986,11 +1983,11 @@
 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
   VisitOMPClauseWithPreInit(C);
   C->setScheduleKind(
-       static_cast<OpenMPScheduleClauseKind>(Reader->Record[Idx++]));
+       static_cast<OpenMPScheduleClauseKind>(*Reader->Record++));
   C->setFirstScheduleModifier(
-      static_cast<OpenMPScheduleClauseModifier>(Reader->Record[Idx++]));
+      static_cast<OpenMPScheduleClauseModifier>(*Reader->Record++));
   C->setSecondScheduleModifier(
-      static_cast<OpenMPScheduleClauseModifier>(Reader->Record[Idx++]));
+      static_cast<OpenMPScheduleClauseModifier>(*Reader->Record++));
   C->setChunkSize(Reader->Record.ReadSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation());
@@ -2100,7 +2097,7 @@
   VisitOMPClauseWithPostUpdate(C);
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
-  NestedNameSpecifierLoc NNSL = Reader->Record.ReadNestedNameSpecifierLoc(Idx);
+  NestedNameSpecifierLoc NNSL = Reader->Record.ReadNestedNameSpecifierLoc();
   DeclarationNameInfo DNI;
   Reader->ReadDeclarationNameInfo(DNI);
   C->setQualifierLoc(NNSL);
@@ -2134,7 +2131,7 @@
   VisitOMPClauseWithPostUpdate(C);
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
-  C->setModifier(static_cast<OpenMPLinearClauseKind>(Reader->Record[Idx++]));
+  C->setModifier(static_cast<OpenMPLinearClauseKind>(*Reader->Record++));
   C->setModifierLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
   SmallVector<Expr *, 16> Vars;
@@ -2231,7 +2228,7 @@
 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDependencyKind(
-      static_cast<OpenMPDependClauseKind>(Reader->Record[Idx++]));
+      static_cast<OpenMPDependClauseKind>(*Reader->Record++));
   C->setDependencyLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   unsigned NumVars = C->varlist_size();
@@ -2251,9 +2248,9 @@
 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setMapTypeModifier(
-     static_cast<OpenMPMapClauseKind>(Reader->Record[Idx++]));
+     static_cast<OpenMPMapClauseKind>(*Reader->Record++));
   C->setMapType(
-     static_cast<OpenMPMapClauseKind>(Reader->Record[Idx++]));
+     static_cast<OpenMPMapClauseKind>(*Reader->Record++));
   C->setMapLoc(Reader->ReadSourceLocation());
   C->setColonLoc(Reader->ReadSourceLocation());
   auto NumVars = C->varlist_size();
@@ -2270,26 +2267,26 @@
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>(Idx));
+    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[Idx++]);
+    ListsPerDecl.push_back(*Reader->Record++);
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
-    ListSizes.push_back(Reader->Record[Idx++]);
+    ListSizes.push_back(*Reader->Record++);
   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>(Idx);
+    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
@@ -2329,7 +2326,7 @@
 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
   VisitOMPClauseWithPreInit(C);
   C->setDistScheduleKind(
-      static_cast<OpenMPDistScheduleClauseKind>(Reader->Record[Idx++]));
+      static_cast<OpenMPDistScheduleClauseKind>(*Reader->Record++));
   C->setChunkSize(Reader->Record.ReadSubExpr());
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDistScheduleKindLoc(Reader->ReadSourceLocation());
@@ -2338,9 +2335,9 @@
 
 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
   C->setDefaultmapKind(
-       static_cast<OpenMPDefaultmapClauseKind>(Reader->Record[Idx++]));
+       static_cast<OpenMPDefaultmapClauseKind>(*Reader->Record++));
   C->setDefaultmapModifier(
-      static_cast<OpenMPDefaultmapClauseModifier>(Reader->Record[Idx++]));
+      static_cast<OpenMPDefaultmapClauseModifier>(*Reader->Record++));
   C->setLParenLoc(Reader->ReadSourceLocation());
   C->setDefaultmapModifierLoc(Reader->ReadSourceLocation());
   C->setDefaultmapKindLoc(Reader->ReadSourceLocation());
@@ -2362,26 +2359,26 @@
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>(Idx));
+    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[Idx++]);
+    ListsPerDecl.push_back(*Reader->Record++);
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
-    ListSizes.push_back(Reader->Record[Idx++]);
+    ListSizes.push_back(*Reader->Record++);
   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>(Idx);
+    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
@@ -2404,26 +2401,26 @@
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>(Idx));
+    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[Idx++]);
+    ListsPerDecl.push_back(*Reader->Record++);
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
-    ListSizes.push_back(Reader->Record[Idx++]);
+    ListSizes.push_back(*Reader->Record++);
   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>(Idx);
+    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
@@ -2454,26 +2451,26 @@
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>(Idx));
+    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[Idx++]);
+    ListsPerDecl.push_back(*Reader->Record++);
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
-    ListSizes.push_back(Reader->Record[Idx++]);
+    ListSizes.push_back(*Reader->Record++);
   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>(Idx);
+    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
@@ -2497,26 +2494,26 @@
   SmallVector<ValueDecl *, 16> Decls;
   Decls.reserve(UniqueDecls);
   for (unsigned i = 0; i < UniqueDecls; ++i)
-    Decls.push_back(Reader->Record.ReadDeclAs<ValueDecl>(Idx));
+    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[Idx++]);
+    ListsPerDecl.push_back(*Reader->Record++);
   C->setDeclNumLists(ListsPerDecl);
 
   SmallVector<unsigned, 32> ListSizes;
   ListSizes.reserve(TotalLists);
   for (unsigned i = 0; i < TotalLists; ++i)
-    ListSizes.push_back(Reader->Record[Idx++]);
+    ListSizes.push_back(*Reader->Record++);
   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>(Idx);
+    ValueDecl *AssociatedDecl = Reader->Record.ReadDeclAs<ValueDecl>();
     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
         AssociatedExpr, AssociatedDecl));
   }
@@ -2529,7 +2526,7 @@
 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   E->setLocStart(ReadSourceLocation());
   E->setLocEnd(ReadSourceLocation());
-  OMPClauseReader ClauseReader(this, Record, Idx);
+  OMPClauseReader ClauseReader(this, Record);
   SmallVector<OMPClause *, 5> Clauses;
   for (unsigned i = 0; i < E->getNumClauses(); ++i)
     Clauses.push_back(ClauseReader.readClause());
@@ -2541,7 +2538,7 @@
 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
   VisitStmt(D);
   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
-  Idx += 2;
+  Record += 2;
   VisitOMPExecutableDirective(D);
   D->setIterationVariable(Record.ReadSubExpr());
   D->setLastIteration(Record.ReadSubExpr());
@@ -2594,9 +2591,9 @@
 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
@@ -2605,7 +2602,7 @@
 
 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
@@ -2615,21 +2612,21 @@
 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
@@ -2641,14 +2638,14 @@
 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
   ReadDeclarationNameInfo(D->DirName);
 }
 
 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPParallelForSimdDirective(
@@ -2660,17 +2657,17 @@
     OMPParallelSectionsDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
@@ -2696,74 +2693,74 @@
 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
   D->setX(Record.ReadSubExpr());
   D->setV(Record.ReadSubExpr());
   D->setExpr(Record.ReadSubExpr());
   D->setUpdateExpr(Record.ReadSubExpr());
-  D->IsXLHSInRHSPart = Record[Idx++] != 0;
-  D->IsPostfixUpdate = Record[Idx++] != 0;
+  D->IsXLHSInRHSPart = *Record++ != 0;
+  D->IsPostfixUpdate = *Record++ != 0;
 }
 
 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
   VisitStmt(D);
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
     OMPTargetEnterDataDirective *D) {
   VisitStmt(D);
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetExitDataDirective(
     OMPTargetExitDataDirective *D) {
   VisitStmt(D);
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetParallelDirective(
     OMPTargetParallelDirective *D) {
   VisitStmt(D);
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetParallelForDirective(
     OMPTargetParallelForDirective *D) {
   VisitOMPLoopDirective(D);
-  D->setHasCancel(Record[Idx++]);
+  D->setHasCancel(*Record++);
 }
 
 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 
@@ -2771,15 +2768,15 @@
     OMPCancellationPointDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
-  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
+  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(*Record++));
 }
 
 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
   VisitStmt(D);
   // The NumClauses field was read in ReadStmtFromStream.
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
-  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record[Idx++]));
+  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(*Record++));
 }
 
 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
@@ -2796,7 +2793,7 @@
 
 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
   VisitStmt(D);
-  ++Idx;
+  ++Record;
   VisitOMPExecutableDirective(D);
 }
 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
@@ -2889,9 +2886,8 @@
   unsigned PrevNumStmts = StmtStack.size();
 #endif
 
-  RecordData Record;
-  unsigned Idx;
-  ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
+  ASTRecordReader Record(*this, F);
+  ASTStmtReader Reader(Record, Cursor);
   Stmt::EmptyShell Empty;
 
   while (true) {
@@ -2910,11 +2906,9 @@
     }
 
     Stmt *S = nullptr;
-    Idx = 0;
-    Record.clear();
     bool Finished = false;
     bool IsStmtReference = false;
-    switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {
+    switch ((StmtCode)Record.readRecord(Cursor, Entry.ID)) {
     case STMT_STOP:
       Finished = true;
       break;
@@ -2923,7 +2917,7 @@
       IsStmtReference = true;
       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
              "No stmt was recorded for this offset reference!");
-      S = StmtEntries[Record[Idx++]];
+      S = StmtEntries[*Record++];
       break;
 
     case STMT_NULL_PTR:
@@ -3087,46 +3081,46 @@
       // That way we can use MemberExpr::Create and don't have to duplicate its
       // logic with a MemberExpr::CreateEmpty.
 
-      assert(Idx == 0);
+      assert(Record.getIdx() == 0);
       NestedNameSpecifierLoc QualifierLoc;
-      if (Record[Idx++]) { // HasQualifier.
-        QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
+      if (*Record++) { // HasQualifier.
+        QualifierLoc = Record.ReadNestedNameSpecifierLoc();
       }
 
       SourceLocation TemplateKWLoc;
       TemplateArgumentListInfo ArgInfo;
-      bool HasTemplateKWAndArgsInfo = Record[Idx++];
+      bool HasTemplateKWAndArgsInfo = *Record++;
       if (HasTemplateKWAndArgsInfo) {
-        TemplateKWLoc = ReadSourceLocation(F, Record, Idx);
-        unsigned NumTemplateArgs = Record[Idx++];
-        ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
-        ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
+        TemplateKWLoc = Record.ReadSourceLocation();
+        unsigned NumTemplateArgs = *Record++;
+        ArgInfo.setLAngleLoc(Record.ReadSourceLocation());
+        ArgInfo.setRAngleLoc(Record.ReadSourceLocation());
         for (unsigned i = 0; i != NumTemplateArgs; ++i)
-          ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
+          ArgInfo.addArgument(Record.ReadTemplateArgumentLoc());
       }
 
-      bool HadMultipleCandidates = Record[Idx++];
+      bool HadMultipleCandidates = *Record++;
 
-      NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
-      AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
+      NamedDecl *FoundD = Record.ReadDeclAs<NamedDecl>();
+      AccessSpecifier AS = (AccessSpecifier)*Record++;
       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
 
-      QualType T = readType(F, Record, Idx);
-      ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
-      ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
+      QualType T = Record.readType();
+      ExprValueKind VK = static_cast<ExprValueKind>(*Record++);
+      ExprObjectKind OK = static_cast<ExprObjectKind>(*Record++);
       Expr *Base = ReadSubExpr();
-      ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
-      SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
+      ValueDecl *MemberD = Record.ReadDeclAs<ValueDecl>();
+      SourceLocation MemberLoc = Record.ReadSourceLocation();
       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
-      bool IsArrow = Record[Idx++];
-      SourceLocation OperatorLoc = ReadSourceLocation(F, Record, Idx);
+      bool IsArrow = *Record++;
+      SourceLocation OperatorLoc = Record.ReadSourceLocation();
 
       S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
                              HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
                              VK, OK);
-      ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
-                             MemberD->getDeclName(), Record, Idx);
+      Record.ReadDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
+                                    MemberD->getDeclName());
       if (HadMultipleCandidates)
         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
       break;
@@ -3838,8 +3832,8 @@
       StmtEntries[Cursor.GetCurrentBitNo()] = S;
     }
 
-
-    assert(Idx == Record.size() && "Invalid deserialization of statement");
+    assert(Record.getIdx() == Record.size() &&
+           "Invalid deserialization of statement");
     StmtStack.push_back(S);
   }
 Done: