[Serialization] Improve encoding of small SourceRanges.

[sammccall]

Summary

Instead of encoding as (start, end), encode as (start, end-start).
This is smaller in the common case when:

• we store the values as VBR
• start and end are in the same file ID and nearby

This reduces clangd/AST.cpp PCH size by ~0.75%.

[sammccall]

Bad news: this isn't ready, there are places where ASTWriter calls AddSourceLocation() twice and ASTReader calls ReadSourceRange().
After this change, those are no longer compatible so we have to make them match, and have to audit them all.

Good news, there's a bunch of potential places where we can replace AddSourceLocation() pairs with AddSourceRange for further savings.
Maybe even replacing other "chains" of source locations with delta-encoding, though I might be getting carried away...

[sammccall]

Switch reader/writer to use sourcerange encoding for all "obvious" ranges.

Gain is now 1.75% in my test PCH.

[ilya-biryukov]

Overall LGTM, but I didn't look closely if there are cases that break now.
Do we have any tests to check this?

[sammccall]

In D124422#3474003, @ilya-biryukov wrote:

Overall LGTM, but I didn't look closely if there are cases that break now.
Do we have any tests to check this?

Serialization tests do exist, though I think coverage isn't amazing.
I'd have a reasonable level of confidence through:

• the fact that I made the changes systematically rather than finding them through test failures
• I'll go through and audit all the changes myself again (the failures I did have after finishing this were mostly typos)
• using it locally for a while (though this will only cover usual C++ nodes)

---

There is a limited & self-defeating nature of this patch.
To have a clear idiom, we only encode SourceRange when begin/end pair are directly stored.
Not all SourceLocations are paired, e.g. ForStmt has [KW, LParen, RParen] and we benefit from delta-encoding only once.
In the most common types of nodes, there tends to be more complexity around exactly which SourceLocations need to be stored for size reasons. (Probably size of memory representation, but this is 1:1 with serialized). So I suspect the opportunities missed are disproportionately valuable as well.

Before landing this, I'd like to try an approach of compressing all SourceLocations within a record as a sequence.
Something with a state machine like:

• at the start of each record, Current = 0
• for each Loc:
  • if Loc is far from current, encode as 33-bit integer Loc<<1 | 1
  • if Loc is close to current, encode as abs(Loc) << 2 | sign(Loc) << 1 | 0
  • if Loc is nonzero, Current = Loc

This would guarantee efficient representations of nearby and null sourcelocations, while regressing random locations by 1 bit only.

This can be done explicitly with an API like: SrcLocSeq Locs(Stream); Locs.Add(Loc1); Locs.Add(Loc2);, or implicitly by changing the behavior of AddSourceLocation. The latter seems easier to try, and would require more machinery but fewer local changes than this patch.

Let me try to put something together to see what the gains are...

[ilya-biryukov]

Yeah, that sounds promising. Various source locations inside the same nodes are probably very close. Probably even across nodes.
If we are willing to take on a bit more complexity, we could probably get even bigger wins by storing all source locations in a single array having indices into that array in the actual positions where we need the source locations. That way we can have:

• get the benefits of delta-encoding in the source locations array, probably even across nodes,
• probably still get quite good encoding for indices inside this array inside the actual AST nodes. Will definitely get those if we delta-encode the indices inside the same node.

I suspect there are requirements that will force us to store the array in chunks and allow searching for a particular chunk.

However, that's really adding quite a bit of complexity and I'm not sure preamble sizes are such a big deal outside our environment. E.g. even 10% savings are borderline for that kind of complexity.

[sammccall]

In D124422#3474110, @ilya-biryukov wrote:

Yeah, that sounds promising. Various source locations inside the same nodes are probably very close. Probably even across nodes.

Yeah. The reason to avoid compressing across nodes is it breaks lazy-loading. (Also I'm not sure whether related decls end up proximate in the output). Maybe there's a way around it, but this is much lower-hanging I think.

If we are willing to take on a bit more complexity, we could probably get even bigger wins by storing all source locations in a single array having indices into that array in the actual positions where we need the source locations.

This is an interesting idea, I wonder whether it will be a win.

The delta-encodings are efficient as you note, but we have to represent SourceLocations twice. (value + index).
I think the #bits we save storing indices vs SourceLocations is similar to the #bits we need to encode the deltas.
If these cancel out then the savings we get are from deduplicating SourceLocations in the array - I suspect there aren't actually that many duplicates, we'd be lucky to halve the array size.

Rough example with made-up numbers:

• today we store raw SourceLocations, N * ~28 bits
• maybe simple delta-encoding maybe reduces this by 8 to N * 20 bits average
• sorted SourceLocation array (no delta-encoding, no deduplication) is N * 28, indices maybe N * 23 (assuming distance of 2^5 between sourcelocations)
• delta-encoding the array means it takes conservatively N * 7 bits (5 bits average delta + VBR overhead + variance)
• delta-encoding the indices yields the same 8 bits as before => N * 15
• deduplcating the halves the entries and reduces the size of indices by 1 bit
• this yields N/2*7 for the array + N * 14 for indices = N * 17.5

So we come out ahead (20->17.5) if deduplication halves #locations. If it reduces by a third, it's 20->19 instead.
This seems likely to be an improvement, over simple delta, but much smaller than delta vs status quo.

I suspect there are requirements that will force us to store the array in chunks and allow searching for a particular chunk.

However, that's really adding quite a bit of complexity and I'm not sure preamble sizes are such a big deal outside our environment. E.g. even 10% savings are borderline for that kind of complexity.

Yeah, I don't plan to pursue this for now because the complexity/reward scares me, but if we get really squeezed for size we could revisit.

clang/lib/Serialization/ASTReader.cpp

while (true) {
     case PP_MACRO_FUNCTION_LIKE: {
       // If we already have a macro, that means that we've hit the end
       // of the definition of the macro we were looking for. We're
       // done.
       if (Macro)
         return Macro;
 
       unsigned NextIndex = 1; // Skip identifier ID.
-      SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
-      MacroInfo *MI = PP.AllocateMacroInfo(Loc);
-      MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
+      SourceRange Range = ReadSourceRange(F, Record, NextIndex);
+      MacroInfo *MI = PP.AllocateMacroInfo(Range.getBegin());
+      MI->setDefinitionEndLoc(Range.getEnd());
       MI->setIsUsed(Record[NextIndex++]);
       MI->setUsedForHeaderGuard(Record[NextIndex++]);
       MacroTokens = MI->allocateTokens(Record[NextIndex++],
                                        PP.getPreprocessorAllocator());
       if (RecType == PP_MACRO_FUNCTION_LIKE) {
         // Decode function-like macro info.
         bool isC99VarArgs = Record[NextIndex++];
         bool isGNUVarArgs = Record[NextIndex++];

 }
 
 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
   TL.setStarLoc(readSourceLocation());
   TL.setClassTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
-  TL.setLBracketLoc(readSourceLocation());
-  TL.setRBracketLoc(readSourceLocation());
+  SourceRange BracketRange = Reader.readSourceRange();
+  TL.setLBracketLoc(BracketRange.getBegin());
+  TL.setRBracketLoc(BracketRange.getEnd());
   if (Reader.readBool())
     TL.setSizeExpr(Reader.readExpr());
   else
     TL.setSizeExpr(nullptr);
 }
 
 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
     DependentSizedMatrixTypeLoc TL) {
   TL.setAttrNameLoc(readSourceLocation());
   TL.setAttrOperandParensRange(Reader.readSourceRange());
   TL.setAttrRowOperand(Reader.readExpr());
   TL.setAttrColumnOperand(Reader.readExpr());
 }
 
 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
-  TL.setLocalRangeBegin(readSourceLocation());
-  TL.setLParenLoc(readSourceLocation());
-  TL.setRParenLoc(readSourceLocation());
+  SourceRange LocalRange = Reader.readSourceRange();
+  TL.setLocalRangeBegin(LocalRange.getBegin());
+  TL.setLocalRangeEnd(LocalRange.getBegin());
+  SourceRange ParensRange = Reader.readSourceRange();
+  TL.setLParenLoc(ParensRange.getBegin());
+  TL.setRParenLoc(ParensRange.getEnd());
   TL.setExceptionSpecRange(Reader.readSourceRange());
-  TL.setLocalRangeEnd(readSourceLocation());
   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
     TL.setParam(i, Reader.readDeclAs<ParmVarDecl>());
   }
 }
 
 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }

 }
 
 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
   TL.setTypeofLoc(readSourceLocation());
-  TL.setLParenLoc(readSourceLocation());
-  TL.setRParenLoc(readSourceLocation());
+  TL.setParensRange(Reader.readSourceRange());
 }
 
 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
   TL.setTypeofLoc(readSourceLocation());
-  TL.setLParenLoc(readSourceLocation());
-  TL.setRParenLoc(readSourceLocation());
+  TL.setParensRange(Reader.readSourceRange());
   TL.setUnderlyingTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
   TL.setDecltypeLoc(readSourceLocation());
   TL.setRParenLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
   TL.setKWLoc(readSourceLocation());
-  TL.setLParenLoc(readSourceLocation());
-  TL.setRParenLoc(readSourceLocation());
+  TL.setParensRange(Reader.readSourceRange());
   TL.setUnderlyingTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
   if (Reader.readBool()) {
     TL.setNestedNameSpecifierLoc(ReadNestedNameSpecifierLoc());
     TL.setTemplateKWLoc(readSourceLocation());
     TL.setConceptNameLoc(readSourceLocation());
     TL.setFoundDecl(Reader.readDeclAs<NamedDecl>());
-    TL.setLAngleLoc(readSourceLocation());
-    TL.setRAngleLoc(readSourceLocation());
+    SourceRange AngleRange = Reader.readSourceRange();
+    TL.setLAngleLoc(AngleRange.getBegin());
+    TL.setRAngleLoc(AngleRange.getEnd());
     for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
       TL.setArgLocInfo(i, Reader.readTemplateArgumentLocInfo(
                               TL.getTypePtr()->getArg(i).getKind()));
   }
   if (Reader.readBool())
     TL.setRParenLoc(readSourceLocation());
 }
 
void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
                                           SubstTemplateTypeParmPackTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
                                            TemplateSpecializationTypeLoc TL) {
   TL.setTemplateKeywordLoc(readSourceLocation());
   TL.setTemplateNameLoc(readSourceLocation());
-  TL.setLAngleLoc(readSourceLocation());
-  TL.setRAngleLoc(readSourceLocation());
+  SourceRange AngleRange = Reader.readSourceRange();
+  TL.setLAngleLoc(AngleRange.getBegin());
+  TL.setRAngleLoc(AngleRange.getEnd());
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
     TL.setArgLocInfo(
         i,
         Reader.readTemplateArgumentLocInfo(
           TL.getTypePtr()->getArg(i).getKind()));
 }
 
 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
-  TL.setLParenLoc(readSourceLocation());
-  TL.setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = Reader.readSourceRange();
+  TL.setLParenLoc(ParenRange.getBegin());
+  TL.setRParenLoc(ParenRange.getEnd());
 }
 
 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
   TL.setElaboratedKeywordLoc(readSourceLocation());
   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
 }
 
 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
   TL.setElaboratedKeywordLoc(readSourceLocation());
   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
        DependentTemplateSpecializationTypeLoc TL) {
   TL.setElaboratedKeywordLoc(readSourceLocation());
   TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
   TL.setTemplateKeywordLoc(readSourceLocation());
   TL.setTemplateNameLoc(readSourceLocation());
-  TL.setLAngleLoc(readSourceLocation());
-  TL.setRAngleLoc(readSourceLocation());
+  SourceRange AngleRange = Reader.readSourceRange();
+  TL.setLAngleLoc(AngleRange.getBegin());
+  TL.setRAngleLoc(AngleRange.getEnd());
   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
     TL.setArgLocInfo(
         I,
         Reader.readTemplateArgumentLocInfo(
             TL.getTypePtr()->getArg(I).getKind()));
 }
 
 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
   TL.setEllipsisLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
   if (TL.getNumProtocols()) {
-    TL.setProtocolLAngleLoc(readSourceLocation());
-    TL.setProtocolRAngleLoc(readSourceLocation());
+    SourceRange ProtocolAngleRange = Reader.readSourceRange();
+    TL.setProtocolLAngleLoc(ProtocolAngleRange.getBegin());
+    TL.setProtocolRAngleLoc(ProtocolAngleRange.getEnd());
   }
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
     TL.setProtocolLoc(i, readSourceLocation());
 }
 
 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
   TL.setHasBaseTypeAsWritten(Reader.readBool());
-  TL.setTypeArgsLAngleLoc(readSourceLocation());
-  TL.setTypeArgsRAngleLoc(readSourceLocation());
+  SourceRange TypeArgsAngleRange = Reader.readSourceRange();
+  TL.setTypeArgsLAngleLoc(TypeArgsAngleRange.getBegin());
+  TL.setTypeArgsRAngleLoc(TypeArgsAngleRange.getEnd());
   for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
     TL.setTypeArgTInfo(i, GetTypeSourceInfo());
-  TL.setProtocolLAngleLoc(readSourceLocation());
-  TL.setProtocolRAngleLoc(readSourceLocation());
+  SourceRange ProtocolAngleRange = Reader.readSourceRange();
+  TL.setProtocolLAngleLoc(ProtocolAngleRange.getBegin());
+  TL.setProtocolRAngleLoc(ProtocolAngleRange.getEnd());
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
     TL.setProtocolLoc(i, readSourceLocation());
 }
 
 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
   TL.setStarLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
   TL.setKWLoc(readSourceLocation());
-  TL.setLParenLoc(readSourceLocation());
-  TL.setRParenLoc(readSourceLocation());
+  TL.setParensRange(Reader.readSourceRange());
 }
 
 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
   TL.setKWLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitBitIntTypeLoc(clang::BitIntTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
if (Arg.getKind() == TemplateArgument::Expression) {
     if (readBool()) // bool InfoHasSameExpr.
       return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
   }
   return TemplateArgumentLoc(Arg, readTemplateArgumentLocInfo(Arg.getKind()));
 }
 
 const ASTTemplateArgumentListInfo *
 ASTRecordReader::readASTTemplateArgumentListInfo() {
-  SourceLocation LAngleLoc = readSourceLocation();
-  SourceLocation RAngleLoc = readSourceLocation();
+  SourceRange AngleRange = readSourceRange();
   unsigned NumArgsAsWritten = readInt();
-  TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
+  TemplateArgumentListInfo TemplArgsInfo(AngleRange.getBegin(),
+                                         AngleRange.getEnd());
   for (unsigned i = 0; i != NumArgsAsWritten; ++i)
     TemplArgsInfo.addArgument(readTemplateArgumentLoc());
   return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
 }
 
 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
   return GetDecl(ID);
 }
if (NumTPLists) {
     for (unsigned i = 0; i != NumTPLists; ++i)
       Info.TemplParamLists[i] = readTemplateParameterList();
   }
 }
 
 TemplateParameterList *
 ASTRecordReader::readTemplateParameterList() {
   SourceLocation TemplateLoc = readSourceLocation();
-  SourceLocation LAngleLoc = readSourceLocation();
-  SourceLocation RAngleLoc = readSourceLocation();
+  SourceRange AngleRange = readSourceRange();
 
   unsigned NumParams = readInt();
   SmallVector<NamedDecl *, 16> Params;
   Params.reserve(NumParams);
   while (NumParams--)
     Params.push_back(readDeclAs<NamedDecl>());
 
   bool HasRequiresClause = readBool();
   Expr *RequiresClause = HasRequiresClause ? readExpr() : nullptr;
 
   TemplateParameterList *TemplateParams = TemplateParameterList::Create(
-      getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
+      getContext(), TemplateLoc, AngleRange.getBegin(), Params,
+      AngleRange.getEnd(), RequiresClause);
   return TemplateParams;
 }
 
 void ASTRecordReader::readTemplateArgumentList(
                         SmallVectorImpl<TemplateArgument> &TemplArgs,
                         bool Canonicalize) {
   unsigned NumTemplateArgs = readInt();
   TemplArgs.reserve(NumTemplateArgs);
for (unsigned i = 0; i != NumInitializers; ++i) {
 
      case CTOR_INITIALIZER_INDIRECT_MEMBER:
       IndirectMember = readDeclAs<IndirectFieldDecl>();
       break;
     }
 
     SourceLocation MemberOrEllipsisLoc = readSourceLocation();
     Expr *Init = readExpr();
-    SourceLocation LParenLoc = readSourceLocation();
-    SourceLocation RParenLoc = readSourceLocation();
+    SourceRange ParenRange = readSourceRange();
 
     CXXCtorInitializer *BOMInit;
     if (Type == CTOR_INITIALIZER_BASE)
-      BOMInit = new (Context)
-          CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
-                             RParenLoc, MemberOrEllipsisLoc);
+      BOMInit = new (Context) CXXCtorInitializer(
+          Context, TInfo, IsBaseVirtual, ParenRange.getBegin(), Init,
+          ParenRange.getEnd(), MemberOrEllipsisLoc);
     else if (Type == CTOR_INITIALIZER_DELEGATING)
-      BOMInit = new (Context)
-          CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
+      BOMInit = new (Context) CXXCtorInitializer(
+          Context, TInfo, ParenRange.getBegin(), Init, ParenRange.getEnd());
     else if (Member)
       BOMInit = new (Context)
-          CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
-                             Init, RParenLoc);
+          CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
+                             ParenRange.getBegin(), Init, ParenRange.getEnd());
     else
       BOMInit = new (Context)
           CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
-                             LParenLoc, Init, RParenLoc);
+                             ParenRange.getBegin(), Init, ParenRange.getEnd());
 
     if (/*IsWritten*/readBool()) {
       unsigned SourceOrder = readInt();
       BOMInit->setSourceOrder(SourceOrder);
     }
 
     CtorInitializers[i] = BOMInit;
   }
ASTRecordReader::readNestedNameSpecifierLoc() {
   }
 
   return Builder.getWithLocInContext(Context);
 }
 
 SourceRange
 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
                            unsigned &Idx) {
-  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
-  SourceLocation end = ReadSourceLocation(F, Record, Idx);
-  return SourceRange(beg, end);
+  SourceLocation::UIntTy Begin = Record[Idx++];
+  SourceLocation::UIntTy Delta = Record[Idx++];
+  return SourceRange(
+      TranslateSourceLocation(F, ReadUntranslatedSourceLocation(Begin)),
+      TranslateSourceLocation(F,
+                              ReadUntranslatedSourceLocation(Begin + Delta)));
 }
 
 /// Read a floating-point value
 llvm::APFloat ASTRecordReader::readAPFloat(const llvm::fltSemantics &Sem) {
   return llvm::APFloat(Sem, readAPInt());
 }
 
 // Read a string
case llvm::omp::Enum:                                                        \
     break;
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
   default:
     break;
   }
   assert(C && "Unknown OMPClause type");
 
   Visit(C);
-  C->setLocStart(Record.readSourceLocation());
-  C->setLocEnd(Record.readSourceLocation());
+  SourceRange Range = Record.readSourceRange();
+  C->setLocStart(Range.getBegin());
+  C->setLocEnd(Range.getEnd());
 
   return C;
 }
 
 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
   C->setPreInitStmt(Record.readSubStmt(),
                     static_cast<OpenMPDirectiveKind>(Record.readInt()));
 }

clang/lib/Serialization/ASTReaderDecl.cpp

case FunctionDecl::TK_FunctionTemplateSpecialization: {
     auto TSK = (TemplateSpecializationKind)Record.readInt();
 
     // Template arguments.
     SmallVector<TemplateArgument, 8> TemplArgs;
     Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
 
     // Template args as written.
     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
-    SourceLocation LAngleLoc, RAngleLoc;
+    SourceRange AngleRange;
     bool HasTemplateArgumentsAsWritten = Record.readInt();
     if (HasTemplateArgumentsAsWritten) {
       unsigned NumTemplateArgLocs = Record.readInt();
       TemplArgLocs.reserve(NumTemplateArgLocs);
       for (unsigned i = 0; i != NumTemplateArgLocs; ++i)
         TemplArgLocs.push_back(Record.readTemplateArgumentLoc());
 
-      LAngleLoc = readSourceLocation();
-      RAngleLoc = readSourceLocation();
+      AngleRange = readSourceRange();
     }
 
     SourceLocation POI = readSourceLocation();
 
     ASTContext &C = Reader.getContext();
     TemplateArgumentList *TemplArgList
       = TemplateArgumentList::CreateCopy(C, TemplArgs);
-    TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
+    TemplateArgumentListInfo TemplArgsInfo(AngleRange.getBegin(),
+                                           AngleRange.getEnd());
     for (unsigned i = 0, e = TemplArgLocs.size(); i != e; ++i)
       TemplArgsInfo.addArgument(TemplArgLocs[i]);
 
     MemberSpecializationInfo *MSInfo = nullptr;
     if (Record.readInt()) {
       auto *FD = readDeclAs<FunctionDecl>();
       auto TSK = (TemplateSpecializationKind)Record.readInt();
       SourceLocation POI = readSourceLocation();
case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     while (NumTemplates--)
       TemplDecls.addDecl(readDeclAs<NamedDecl>());
 
     // Templates args.
     TemplateArgumentListInfo TemplArgs;
     unsigned NumArgs = Record.readInt();
     while (NumArgs--)
       TemplArgs.addArgument(Record.readTemplateArgumentLoc());
-    TemplArgs.setLAngleLoc(readSourceLocation());
-    TemplArgs.setRAngleLoc(readSourceLocation());
+    SourceRange AngleRange = readSourceRange();
+    TemplArgs.setLAngleLoc(AngleRange.getBegin());
+    TemplArgs.setRAngleLoc(AngleRange.getEnd());
 
     FD->setDependentTemplateSpecialization(Reader.getContext(),
                                            TemplDecls, TemplArgs);
     // These are not merged; we don't need to merge redeclarations of dependent
     // template friends.
     break;
   }
   }
ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {
   for (unsigned i = 0; i != numParams; ++i) {
     auto *typeParam = readDeclAs<ObjCTypeParamDecl>();
     if (!typeParam)
       return nullptr;
 
     typeParams.push_back(typeParam);
   }
 
-  SourceLocation lAngleLoc = readSourceLocation();
-  SourceLocation rAngleLoc = readSourceLocation();
+  SourceRange angleRange = readSourceRange();
 
-  return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,
-                                   typeParams, rAngleLoc);
+  return ObjCTypeParamList::create(Reader.getContext(), angleRange.getBegin(),
+                                   typeParams, angleRange.getEnd());
 }
 
 void ASTDeclReader::ReadObjCDefinitionData(
          struct ObjCInterfaceDecl::DefinitionData &Data) {
   // Read the superclass.
   Data.SuperClassTInfo = readTypeSourceInfo();
 
   Data.EndLoc = readSourceLocation();

 
 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
   VisitFieldDecl(FD);
 }
 
 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
   VisitObjCContainerDecl(CD);
   CD->setCategoryNameLoc(readSourceLocation());
-  CD->setIvarLBraceLoc(readSourceLocation());
-  CD->setIvarRBraceLoc(readSourceLocation());
+  SourceRange IvarBraceRange = readSourceRange();
+  CD->setIvarLBraceLoc(IvarBraceRange.getBegin());
+  CD->setIvarRBraceLoc(IvarBraceRange.getEnd());
 
   // Note that this category has been deserialized. We do this before
   // deserializing the interface declaration, so that it will consider this
   /// category.
   Reader.CategoriesDeserialized.insert(CD);
 
   CD->ClassInterface = readDeclAs<ObjCInterfaceDecl>();
   CD->TypeParamList = ReadObjCTypeParamList();
void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
   VisitObjCImplDecl(D);
   D->CategoryNameLoc = readSourceLocation();
 }
 
 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
   VisitObjCImplDecl(D);
   D->setSuperClass(readDeclAs<ObjCInterfaceDecl>());
   D->SuperLoc = readSourceLocation();
-  D->setIvarLBraceLoc(readSourceLocation());
-  D->setIvarRBraceLoc(readSourceLocation());
+  SourceRange IvarBraceRange = readSourceRange();
+  D->setIvarLBraceLoc(IvarBraceRange.getBegin());
+  D->setIvarRBraceLoc(IvarBraceRange.getEnd());
   D->setHasNonZeroConstructors(Record.readInt());
   D->setHasDestructors(Record.readInt());
   D->NumIvarInitializers = Record.readInt();
   if (D->NumIvarInitializers)
     D->IvarInitializers = ReadGlobalOffset();
 }
 
 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {

clang/lib/Serialization/ASTReaderStmt.cpp

 
 } // namespace clang
 
 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
                                               TemplateArgumentLoc *ArgsLocArray,
                                               unsigned NumTemplateArgs) {
   SourceLocation TemplateKWLoc = readSourceLocation();
   TemplateArgumentListInfo ArgInfo;
-  ArgInfo.setLAngleLoc(readSourceLocation());
-  ArgInfo.setRAngleLoc(readSourceLocation());
+  SourceRange AngleRange = readSourceRange();
+  ArgInfo.setLAngleLoc(AngleRange.getBegin());
+  ArgInfo.setRAngleLoc(AngleRange.getEnd());
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
     ArgInfo.addArgument(Record.readTemplateArgumentLoc());
   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
 }
 
 void ASTStmtReader::VisitStmt(Stmt *S) {
   assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
 }
 
 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
   VisitStmt(S);
   S->setSemiLoc(readSourceLocation());
   S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
 }
 
 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
   VisitStmt(S);
   SmallVector<Stmt *, 16> Stmts;
   unsigned NumStmts = Record.readInt();
   while (NumStmts--)
     Stmts.push_back(Record.readSubStmt());
   S->setStmts(Stmts);
-  S->CompoundStmtBits.LBraceLoc = readSourceLocation();
-  S->RBraceLoc = readSourceLocation();
+  SourceRange BraceRange = readSourceRange();
+  S->CompoundStmtBits.LBraceLoc = BraceRange.getBegin();
+  S->RBraceLoc = BraceRange.getEnd();
 }
 
 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
   VisitStmt(S);
   Record.recordSwitchCaseID(S, Record.readInt());
   S->setKeywordLoc(readSourceLocation());
   S->setColonLoc(readSourceLocation());
 }
void ASTStmtReader::VisitIfStmt(IfStmt *S) {
   if (HasElse)
     S->setElse(Record.readSubStmt());
   if (HasVar)
     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
   if (HasInit)
     S->setInit(Record.readSubStmt());
 
   S->setIfLoc(readSourceLocation());
-  S->setLParenLoc(readSourceLocation());
-  S->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  S->setLParenLoc(ParenRange.getBegin());
+  S->setRParenLoc(ParenRange.getEnd());
   if (HasElse)
     S->setElseLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
   VisitStmt(S);
 
   bool HasInit = Record.readInt();
   bool HasVar = Record.readInt();
   bool AllEnumCasesCovered = Record.readInt();
   if (AllEnumCasesCovered)
     S->setAllEnumCasesCovered();
 
   S->setCond(Record.readSubExpr());
   S->setBody(Record.readSubStmt());
   if (HasInit)
     S->setInit(Record.readSubStmt());
   if (HasVar)
     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
 
   S->setSwitchLoc(readSourceLocation());
-  S->setLParenLoc(readSourceLocation());
-  S->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  S->setLParenLoc(ParenRange.getBegin());
+  S->setRParenLoc(ParenRange.getEnd());
 
   SwitchCase *PrevSC = nullptr;
   for (auto E = Record.size(); Record.getIdx() != E; ) {
     SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
     if (PrevSC)
       PrevSC->setNextSwitchCase(SC);
     else
       S->setSwitchCaseList(SC);
 
     PrevSC = SC;
   }
 }
 
 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
   VisitStmt(S);
 
   bool HasVar = Record.readInt();
 
   S->setCond(Record.readSubExpr());
   S->setBody(Record.readSubStmt());
   if (HasVar)
     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
 
   S->setWhileLoc(readSourceLocation());
-  S->setLParenLoc(readSourceLocation());
-  S->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  S->setLParenLoc(ParenRange.getBegin());
+  S->setRParenLoc(ParenRange.getEnd());
 }
 
 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
   VisitStmt(S);
   S->setCond(Record.readSubExpr());
   S->setBody(Record.readSubStmt());
   S->setDoLoc(readSourceLocation());
   S->setWhileLoc(readSourceLocation());
   S->setRParenLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitForStmt(ForStmt *S) {
   VisitStmt(S);
   S->setInit(Record.readSubStmt());
   S->setCond(Record.readSubExpr());
   S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
   S->setInc(Record.readSubExpr());
   S->setBody(Record.readSubStmt());
   S->setForLoc(readSourceLocation());
-  S->setLParenLoc(readSourceLocation());
-  S->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  S->setLParenLoc(ParenRange.getBegin());
+  S->setRParenLoc(ParenRange.getEnd());
 }
 
 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
   VisitStmt(S);
   S->setLabel(readDeclAs<LabelDecl>());
   S->setGotoLoc(readSourceLocation());
   S->setLabelLoc(readSourceLocation());
 }
void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
   if (HasNRVOCandidate)
     S->setNRVOCandidate(readDeclAs<VarDecl>());
 
   S->setReturnLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
   VisitStmt(S);
-  S->setStartLoc(readSourceLocation());
-  S->setEndLoc(readSourceLocation());
+  SourceRange Range = readSourceRange();
+  S->setStartLoc(Range.getBegin());
+  S->setEndLoc(Range.getEnd());
 
   if (Record.size() - Record.getIdx() == 1) {
     // Single declaration
     S->setDeclGroup(DeclGroupRef(readDecl()));
   } else {
     SmallVector<Decl *, 16> Decls;
     int N = Record.size() - Record.getIdx();
     Decls.reserve(N);
void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
 
   E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
   VisitExpr(E);
 
   E->setLocation(readSourceLocation());
-  E->setLParenLocation(readSourceLocation());
-  E->setRParenLocation(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLocation(ParenRange.getBegin());
+  E->setRParenLocation(ParenRange.getEnd());
 
   E->setTypeSourceInfo(Record.readTypeSourceInfo());
 }
 
 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
   bool HasFunctionName = Record.readInt();
   E->PredefinedExprBits.HasFunctionName = HasFunctionName;
void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
   VisitExpr(E);
   E->setValue(Record.readInt());
   E->setLocation(readSourceLocation());
   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
 }
 
 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
   VisitExpr(E);
-  E->setLParen(readSourceLocation());
-  E->setRParen(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParen(ParenRange.getBegin());
+  E->setRParen(ParenRange.getEnd());
   E->setSubExpr(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
   VisitExpr(E);
   unsigned NumExprs = Record.readInt();
   assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
   for (unsigned I = 0; I != NumExprs; ++I)
     E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
-  E->LParenLoc = readSourceLocation();
-  E->RParenLoc = readSourceLocation();
+  SourceRange ParenRange = readSourceRange();
+  E->LParenLoc = ParenRange.getBegin();
+  E->RParenLoc = ParenRange.getEnd();
 }
 
 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
   bool hasFP_Features = Record.readInt();
   assert(hasFP_Features == E->hasStoredFPFeatures());
   E->setSubExpr(Record.readSubExpr());
   E->setOpcode((UnaryOperator::Opcode)Record.readInt());
void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
   Record.skipInts(1);
   assert(E->getNumExpressions() == Record.peekInt());
   Record.skipInts(1);
   E->setOperatorLoc(readSourceLocation());
   E->setRParenLoc(readSourceLocation());
   E->setTypeSourceInfo(readTypeSourceInfo());
   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
     auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
-    SourceLocation Start = readSourceLocation();
-    SourceLocation End = readSourceLocation();
+    SourceRange Range = readSourceRange();
     switch (Kind) {
     case OffsetOfNode::Array:
-      E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
+      E->setComponent(
+          I, OffsetOfNode(Range.getBegin(), Record.readInt(), Range.getEnd()));
       break;
 
     case OffsetOfNode::Field:
-      E->setComponent(
-          I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
+      E->setComponent(I, OffsetOfNode(Range.getBegin(), readDeclAs<FieldDecl>(),
+                                      Range.getEnd()));
       break;
 
     case OffsetOfNode::Identifier:
-      E->setComponent(
-          I,
-          OffsetOfNode(Start, Record.readIdentifier(), End));
+      E->setComponent(I, OffsetOfNode(Range.getBegin(), Record.readIdentifier(),
+                                      Range.getEnd()));
       break;
 
     case OffsetOfNode::Base: {
       auto *Base = new (Record.getContext()) CXXBaseSpecifier();
       *Base = Record.readCXXBaseSpecifier();
       E->setComponent(I, OffsetOfNode(Base));
       break;
     }
void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
   SmallVector<Expr *, 4> Dims(NumDims);
   for (unsigned I = 0; I < NumDims; ++I)
     Dims[I] = Record.readSubExpr();
   E->setDimensions(Dims);
   SmallVector<SourceRange, 4> SRs(NumDims);
   for (unsigned I = 0; I < NumDims; ++I)
     SRs[I] = readSourceRange();
   E->setBracketsRanges(SRs);
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLoc(ParenRange.getBegin());
+  E->setRParenLoc(ParenRange.getEnd());
 }
 
 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
   VisitExpr(E);
   unsigned NumIters = Record.readInt();
   E->setIteratorKwLoc(readSourceLocation());
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLoc(ParenRange.getBegin());
+  E->setRParenLoc(ParenRange.getEnd());
   for (unsigned I = 0; I < NumIters; ++I) {
     E->setIteratorDeclaration(I, Record.readDeclRef());
     E->setAssignmentLoc(I, readSourceLocation());
     Expr *Begin = Record.readSubExpr();
     Expr *End = Record.readSubExpr();
     Expr *Step = Record.readSubExpr();
     SourceLocation ColonLoc = readSourceLocation();
     SourceLocation SecColonLoc;

 
 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   VisitCastExpr(E);
   E->setTypeInfoAsWritten(readTypeSourceInfo());
 }
 
 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
   VisitExplicitCastExpr(E);
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLoc(ParenRange.getBegin());
+  E->setRParenLoc(ParenRange.getEnd());
 }
 
 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   E->setLParenLoc(readSourceLocation());
   E->setTypeSourceInfo(readTypeSourceInfo());
   E->setInitializer(Record.readSubExpr());
   E->setFileScope(Record.readInt());
 }
 
 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   VisitExpr(E);
   E->setBase(Record.readSubExpr());
   E->setAccessor(Record.readIdentifier());
   E->setAccessorLoc(readSourceLocation());
 }
 
 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
   VisitExpr(E);
   if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
     E->setSyntacticForm(SyntForm);
-  E->setLBraceLoc(readSourceLocation());
-  E->setRBraceLoc(readSourceLocation());
+  SourceRange BraceRange = readSourceRange();
+  E->setLBraceLoc(BraceRange.getBegin());
+  E->setRBraceLoc(BraceRange.getEnd());
   bool isArrayFiller = Record.readInt();
   Expr *filler = nullptr;
   if (isArrayFiller) {
     filler = Record.readSubExpr();
     E->ArrayFillerOrUnionFieldInit = filler;
   } else
     E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
   E->sawArrayRangeDesignator(Record.readInt());
case DESIG_FIELD_NAME: {
       SourceLocation DotLoc = readSourceLocation();
       SourceLocation FieldLoc = readSourceLocation();
       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
       break;
     }
 
     case DESIG_ARRAY: {
       unsigned Index = Record.readInt();
-      SourceLocation LBracketLoc = readSourceLocation();
-      SourceLocation RBracketLoc = readSourceLocation();
-      Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
+      SourceRange BracketRange = readSourceRange();
+      Designators.push_back(
+          Designator(Index, BracketRange.getBegin(), BracketRange.getEnd()));
       break;
     }
 
     case DESIG_ARRAY_RANGE: {
       unsigned Index = Record.readInt();
-      SourceLocation LBracketLoc = readSourceLocation();
+      SourceRange BracketRange = readSourceRange();
       SourceLocation EllipsisLoc = readSourceLocation();
-      SourceLocation RBracketLoc = readSourceLocation();
-      Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
-                                       RBracketLoc));
+      Designators.push_back(Designator(Index, BracketRange.getBegin(),
+                                       EllipsisLoc, BracketRange.getEnd()));
       break;
     }
     }
   }
   E->setDesignators(Record.getContext(),
                     Designators.data(), Designators.size());
 }
 
void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
   VisitExpr(E);
   E->setAmpAmpLoc(readSourceLocation());
   E->setLabelLoc(readSourceLocation());
   E->setLabel(readDeclAs<LabelDecl>());
 }
 
 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
   VisitExpr(E);
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLoc(ParenRange.getBegin());
+  E->setRParenLoc(ParenRange.getEnd());
   E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
   E->StmtExprBits.TemplateDepth = Record.readInt();
 }
 
 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
   VisitExpr(E);
   E->setCond(Record.readSubExpr());
   E->setLHS(Record.readSubExpr());
void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 
   assert(Kind == E->getReceiverKind());
 
   if (Record.readInt())
     E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
   else
     E->setSelector(Record.readSelector());
 
-  E->LBracLoc = readSourceLocation();
-  E->RBracLoc = readSourceLocation();
+  SourceRange BracketRange = readSourceRange();
+  E->LBracLoc = BracketRange.getBegin();
+  E->RBracLoc = BracketRange.getEnd();
 
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
     E->setArg(I, Record.readSubExpr());
 
   SourceLocation *Locs = E->getStoredSelLocs();
   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
     Locs[I] = readSourceLocation();
 }

 }
 
 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
   return VisitCXXNamedCastExpr(E);
 }
 
 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
   VisitExplicitCastExpr(E);
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLoc(ParenRange.getBegin());
+  E->setRParenLoc(ParenRange.getEnd());
 }
 
 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
   VisitExplicitCastExpr(E);
   E->KWLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
 }
 

 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
   VisitExpr(E);
   assert(Record.peekInt() == E->getNumArgs() &&
          "Read wrong record during creation ?");
   Record.skipInts(1);
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
     E->setArg(I, Record.readSubExpr());
   E->TSI = readTypeSourceInfo();
-  E->setLParenLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
+  SourceRange ParenRange = readSourceRange();
+  E->setLParenLoc(ParenRange.getBegin());
+  E->setRParenLoc(ParenRange.getEnd());
 }
 
 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
   VisitExpr(E);
 
   unsigned NumResults = Record.readInt();
   bool HasTemplateKWAndArgsInfo = Record.readInt();
   assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");

 
 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
   llvm_unreachable("Cannot read TypoExpr nodes");
 }
 
 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
   VisitExpr(E);
   unsigned NumArgs = Record.readInt();
-  E->BeginLoc = readSourceLocation();
-  E->EndLoc = readSourceLocation();
+  SourceRange Range = readSourceRange();
+  E->BeginLoc = Range.getBegin();
+  E->EndLoc = Range.getEnd();
   assert((NumArgs + 0LL ==
           std::distance(E->children().begin(), E->children().end())) &&
          "Wrong NumArgs!");
   (void)NumArgs;
   for (Stmt *&Child : E->children())
     Child = Record.readSubStmt();
 }
 

 void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
   VisitStmt(S);
   for (Stmt *&SubStmt : S->SubStmts)
     SubStmt = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   Record.readOMPChildren(E->Data);
-  E->setLocStart(readSourceLocation());
-  E->setLocEnd(readSourceLocation());
+  SourceRange Range = readSourceRange();
+  E->setLocStart(Range.getBegin());
+  E->setLocEnd(Range.getEnd());
 }
 
 void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
   VisitStmt(D);
   // Field CollapsedNum was read in ReadStmtFromStream.
   Record.skipInts(1);
   VisitOMPExecutableDirective(D);
 }

clang/lib/Serialization/ASTWriter.cpp

 }
 
 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
   Record.AddSourceLocation(TL.getStarLoc());
   Record.AddTypeSourceInfo(TL.getClassTInfo());
 }
 
 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
-  Record.AddSourceLocation(TL.getLBracketLoc());
-  Record.AddSourceLocation(TL.getRBracketLoc());
+  Record.AddSourceRange(TL.getBracketsRange());
   Record.push_back(TL.getSizeExpr() ? 1 : 0);
   if (TL.getSizeExpr())
     Record.AddStmt(TL.getSizeExpr());
 }
 
 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }

 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
                                             DependentSizedArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
 
 void TypeLocWriter::VisitDependentAddressSpaceTypeLoc(
     DependentAddressSpaceTypeLoc TL) {
   Record.AddSourceLocation(TL.getAttrNameLoc());
-  SourceRange range = TL.getAttrOperandParensRange();
-  Record.AddSourceLocation(range.getBegin());
-  Record.AddSourceLocation(range.getEnd());
+  Record.AddSourceRange(TL.getAttrOperandParensRange());
   Record.AddStmt(TL.getAttrExprOperand());
 }
 
 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
                                         DependentSizedExtVectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitDependentVectorTypeLoc(
     DependentVectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) {
   Record.AddSourceLocation(TL.getAttrNameLoc());
-  SourceRange range = TL.getAttrOperandParensRange();
-  Record.AddSourceLocation(range.getBegin());
-  Record.AddSourceLocation(range.getEnd());
+  Record.AddSourceRange(TL.getAttrOperandParensRange());
   Record.AddStmt(TL.getAttrRowOperand());
   Record.AddStmt(TL.getAttrColumnOperand());
 }
 
 void TypeLocWriter::VisitDependentSizedMatrixTypeLoc(
     DependentSizedMatrixTypeLoc TL) {
   Record.AddSourceLocation(TL.getAttrNameLoc());
-  SourceRange range = TL.getAttrOperandParensRange();
-  Record.AddSourceLocation(range.getBegin());
-  Record.AddSourceLocation(range.getEnd());
+  Record.AddSourceRange(TL.getAttrOperandParensRange());
   Record.AddStmt(TL.getAttrRowOperand());
   Record.AddStmt(TL.getAttrColumnOperand());
 }
 
 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
-  Record.AddSourceLocation(TL.getLocalRangeBegin());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  Record.AddSourceRange(TL.getLocalSourceRange());
+  Record.AddSourceRange(TL.getParensRange());
   Record.AddSourceRange(TL.getExceptionSpecRange());
-  Record.AddSourceLocation(TL.getLocalRangeEnd());
   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
     Record.AddDeclRef(TL.getParam(i));
 }
 
 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
 
void TypeLocWriter::VisitUsingTypeLoc(UsingTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
-  if (TL.getNumProtocols()) {
-    Record.AddSourceLocation(TL.getProtocolLAngleLoc());
-    Record.AddSourceLocation(TL.getProtocolRAngleLoc());
-  }
+  if (TL.getNumProtocols())
+    Record.AddSourceRange(
+        {TL.getProtocolLAngleLoc(), TL.getProtocolRAngleLoc()});
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
     Record.AddSourceLocation(TL.getProtocolLoc(i));
 }
 
 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
   Record.AddSourceLocation(TL.getTypeofLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  Record.AddSourceRange(TL.getParensRange());
 }
 
 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
   Record.AddSourceLocation(TL.getTypeofLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  Record.AddSourceRange(TL.getParensRange());
   Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
 }
 
 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
   Record.AddSourceLocation(TL.getDecltypeLoc());
   Record.AddSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
   Record.AddSourceLocation(TL.getKWLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  Record.AddSourceRange(TL.getParensRange());
   Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
 }
 
 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
   Record.push_back(TL.isConstrained());
   if (TL.isConstrained()) {
     Record.AddNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc());
     Record.AddSourceLocation(TL.getTemplateKWLoc());
     Record.AddSourceLocation(TL.getConceptNameLoc());
     Record.AddDeclRef(TL.getFoundDecl());
-    Record.AddSourceLocation(TL.getLAngleLoc());
-    Record.AddSourceLocation(TL.getRAngleLoc());
+    Record.AddSourceRange({TL.getLAngleLoc(), TL.getRAngleLoc()});
     for (unsigned I = 0; I < TL.getNumArgs(); ++I)
       Record.AddTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(),
                                         TL.getArgLocInfo(I));
   }
   Record.push_back(TL.isDecltypeAuto());
   if (TL.isDecltypeAuto())
     Record.AddSourceLocation(TL.getRParenLoc());
 }
void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
                                           SubstTemplateTypeParmPackTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
                                            TemplateSpecializationTypeLoc TL) {
   Record.AddSourceLocation(TL.getTemplateKeywordLoc());
   Record.AddSourceLocation(TL.getTemplateNameLoc());
-  Record.AddSourceLocation(TL.getLAngleLoc());
-  Record.AddSourceLocation(TL.getRAngleLoc());
+  Record.AddSourceRange({TL.getLAngleLoc(), TL.getRAngleLoc()});
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
     Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
                                       TL.getArgLoc(i).getLocInfo());
 }
 
 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  Record.AddSourceRange({TL.getLParenLoc(), TL.getRParenLoc()});
 }
 
 void TypeLocWriter::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
   Record.AddSourceLocation(TL.getExpansionLoc());
 }
 
 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
   Record.AddSourceLocation(TL.getElaboratedKeywordLoc());

 }
 
 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
        DependentTemplateSpecializationTypeLoc TL) {
   Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
   Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
   Record.AddSourceLocation(TL.getTemplateKeywordLoc());
   Record.AddSourceLocation(TL.getTemplateNameLoc());
-  Record.AddSourceLocation(TL.getLAngleLoc());
-  Record.AddSourceLocation(TL.getRAngleLoc());
+  Record.AddSourceRange({TL.getLAngleLoc(), TL.getRAngleLoc()});
   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
     Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
                                       TL.getArgLoc(I).getLocInfo());
 }
 
 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
   Record.AddSourceLocation(TL.getEllipsisLoc());
 }
 
 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
   Record.push_back(TL.hasBaseTypeAsWritten());
-  Record.AddSourceLocation(TL.getTypeArgsLAngleLoc());
-  Record.AddSourceLocation(TL.getTypeArgsRAngleLoc());
+  Record.AddSourceRange({TL.getTypeArgsLAngleLoc(), TL.getTypeArgsRAngleLoc()});
   for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
     Record.AddTypeSourceInfo(TL.getTypeArgTInfo(i));
-  Record.AddSourceLocation(TL.getProtocolLAngleLoc());
-  Record.AddSourceLocation(TL.getProtocolRAngleLoc());
+  Record.AddSourceRange({TL.getProtocolLAngleLoc(), TL.getProtocolRAngleLoc()});
   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
     Record.AddSourceLocation(TL.getProtocolLoc(i));
 }
 
 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
   Record.AddSourceLocation(TL.getStarLoc());
 }
 
 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
   Record.AddSourceLocation(TL.getKWLoc());
-  Record.AddSourceLocation(TL.getLParenLoc());
-  Record.AddSourceLocation(TL.getRParenLoc());
+  Record.AddSourceRange(TL.getParensRange());
 }
 
 void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) {
   Record.AddSourceLocation(TL.getKWLoc());
 }
 
 void TypeLocWriter::VisitBitIntTypeLoc(clang::BitIntTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
     if (Index >= MacroOffsets.size())
       MacroOffsets.resize(Index + 1);
 
     uint64_t Offset = Stream.GetCurrentBitNo() - MacroOffsetsBase;
     assert((Offset >> 32) == 0 && "Macro offset too large");
     MacroOffsets[Index] = Offset;
 
     AddIdentifierRef(Name, Record);
-    AddSourceLocation(MI->getDefinitionLoc(), Record);
-    AddSourceLocation(MI->getDefinitionEndLoc(), Record);
+    AddSourceRange({MI->getDefinitionLoc(), MI->getDefinitionEndLoc()}, Record);
     Record.push_back(MI->isUsed());
     Record.push_back(MI->isUsedForHeaderGuard());
     Record.push_back(MI->getNumTokens());
     unsigned Code;
     if (MI->isObjectLike()) {
       Code = PP_MACRO_OBJECT_LIKE;
     } else {
       Code = PP_MACRO_FUNCTION_LIKE;

 }
 
 void ASTWriter::AddAlignPackInfo(const Sema::AlignPackInfo &Info,
                                  RecordDataImpl &Record) {
   uint32_t Raw = Sema::AlignPackInfo::getRawEncoding(Info);
   Record.push_back(Raw);
 }
 
-void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
+static SourceLocation::UIntTy encodeForWrite(SourceLocation Loc) {
   SourceLocation::UIntTy Raw = Loc.getRawEncoding();
-  Record.push_back((Raw << 1) | (Raw >> (8 * sizeof(Raw) - 1)));
+  return SourceLocation::UIntTy{(Raw << 1) | (Raw >> (8 * sizeof(Raw) - 1))};
+}
+
+void ASTWriter::AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record) {
+  Record.push_back(encodeForWrite(Loc));
 }
 
 void ASTWriter::AddSourceRange(SourceRange Range, RecordDataImpl &Record) {
   AddSourceLocation(Range.getBegin(), Record);
-  AddSourceLocation(Range.getEnd(), Record);
+  Record.push_back(encodeForWrite(Range.getEnd()) -
+                   encodeForWrite(Range.getBegin()));
 }
 
 void ASTRecordWriter::AddAPFloat(const llvm::APFloat &Value) {
   AddAPInt(Value.bitcastToAPInt());
 }
 
 void ASTWriter::AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record) {
   Record.push_back(getIdentifierRef(II));
while(!NestedNames.empty()) {
     }
   }
 }
 
 void ASTRecordWriter::AddTemplateParameterList(
     const TemplateParameterList *TemplateParams) {
   assert(TemplateParams && "No TemplateParams!");
   AddSourceLocation(TemplateParams->getTemplateLoc());
-  AddSourceLocation(TemplateParams->getLAngleLoc());
-  AddSourceLocation(TemplateParams->getRAngleLoc());
+  AddSourceRange(
+      {TemplateParams->getLAngleLoc(), TemplateParams->getRAngleLoc()});
 
   Record->push_back(TemplateParams->size());
   for (const auto &P : *TemplateParams)
     AddDeclRef(P);
   if (const Expr *RequiresClause = TemplateParams->getRequiresClause()) {
     Record->push_back(true);
     AddStmt(const_cast<Expr*>(RequiresClause));
   } else {
     Record->push_back(false);
   }
 }
 
 /// Emit a template argument list.
 void ASTRecordWriter::AddTemplateArgumentList(
     const TemplateArgumentList *TemplateArgs) {
   assert(TemplateArgs && "No TemplateArgs!");
   Record->push_back(TemplateArgs->size());
   for (int i = 0, e = TemplateArgs->size(); i != e; ++i)
     AddTemplateArgument(TemplateArgs->get(i));
 }
 
 void ASTRecordWriter::AddASTTemplateArgumentListInfo(
     const ASTTemplateArgumentListInfo *ASTTemplArgList) {
   assert(ASTTemplArgList && "No ASTTemplArgList!");
-  AddSourceLocation(ASTTemplArgList->LAngleLoc);
-  AddSourceLocation(ASTTemplArgList->RAngleLoc);
+  AddSourceRange(
+      {ASTTemplArgList->getLAngleLoc(), ASTTemplArgList->getRAngleLoc()});
   Record->push_back(ASTTemplArgList->NumTemplateArgs);
   const TemplateArgumentLoc *TemplArgs = ASTTemplArgList->getTemplateArgs();
   for (int i = 0, e = ASTTemplArgList->NumTemplateArgs; i != e; ++i)
     AddTemplateArgumentLoc(TemplArgs[i]);
 }
 
 void ASTRecordWriter::AddUnresolvedSet(const ASTUnresolvedSet &Set) {
   Record->push_back(Set.size());
if (Init->isBaseInitializer()) {
       Writer.AddDeclRef(Init->getMember());
     } else {
       Writer.push_back(CTOR_INITIALIZER_INDIRECT_MEMBER);
       Writer.AddDeclRef(Init->getIndirectMember());
     }
 
     Writer.AddSourceLocation(Init->getMemberLocation());
     Writer.AddStmt(Init->getInit());
-    Writer.AddSourceLocation(Init->getLParenLoc());
-    Writer.AddSourceLocation(Init->getRParenLoc());
+    Writer.AddSourceRange({Init->getLParenLoc(), Init->getRParenLoc()});
     Writer.push_back(Init->isWritten());
     if (Init->isWritten())
       Writer.push_back(Init->getSourceOrder());
   }
 
   return Writer.Emit(serialization::DECL_CXX_CTOR_INITIALIZERS);
 }
 

 
 void ASTRecordWriter::writeOMPClause(OMPClause *C) {
   OMPClauseWriter(*this).writeClause(C);
 }
 
 void OMPClauseWriter::writeClause(OMPClause *C) {
   Record.push_back(unsigned(C->getClauseKind()));
   Visit(C);
-  Record.AddSourceLocation(C->getBeginLoc());
-  Record.AddSourceLocation(C->getEndLoc());
+  Record.AddSourceRange({C->getBeginLoc(), C->getEndLoc()});
 }
 
 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
   Record.push_back(uint64_t(C->getCaptureRegion()));
   Record.AddStmt(C->getPreInitStmt());
 }
 
 void OMPClauseWriter::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {

clang/lib/Serialization/ASTWriterDecl.cpp

void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
         Record.push_back(0);
         return;
       }
 
       Record.push_back(typeParams->size());
       for (auto typeParam : *typeParams) {
         Record.AddDeclRef(typeParam);
       }
-      Record.AddSourceLocation(typeParams->getLAngleLoc());
-      Record.AddSourceLocation(typeParams->getRAngleLoc());
+      Record.AddSourceRange(
+          {typeParams->getLAngleLoc(), typeParams->getRAngleLoc()});
     }
 
     /// Add to the record the first declaration from each module file that
     /// provides a declaration of D. The intent is to provide a sufficient
     /// set such that reloading this set will load all current redeclarations.
     void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
       llvm::MapVector<ModuleFile*, const Decl*> Firsts;
       // FIXME: We can skip entries that we know are implied by others.
case FunctionDecl::TK_FunctionTemplateSpecialization: {
     // Template args as written.
     Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
     if (FTSInfo->TemplateArgumentsAsWritten) {
       Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
       for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
              i!=e; ++i)
         Record.AddTemplateArgumentLoc(
             (*FTSInfo->TemplateArgumentsAsWritten)[i]);
-      Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
-      Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
+      Record.AddSourceRange(
+          {FTSInfo->TemplateArgumentsAsWritten->getLAngleLoc(),
+           FTSInfo->TemplateArgumentsAsWritten->getRAngleLoc()});
     }
 
     Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
 
     if (MemberSpecializationInfo *MemberInfo =
         FTSInfo->getMemberSpecializationInfo()) {
       Record.push_back(1);
       Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     Record.push_back(DFTSInfo->getNumTemplates());
     for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
       Record.AddDeclRef(DFTSInfo->getTemplate(i));
 
     // Templates args.
     Record.push_back(DFTSInfo->getNumTemplateArgs());
     for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
       Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
-    Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
-    Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
+    Record.AddSourceRange({DFTSInfo->getLAngleLoc(), DFTSInfo->getRAngleLoc()});
     break;
   }
   }
 
   Record.push_back(D->param_size());
   for (auto P : D->parameters())
     Record.AddDeclRef(P);
   Code = serialization::DECL_FUNCTION;

 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
   VisitFieldDecl(D);
   Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
 }
 
 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
   VisitObjCContainerDecl(D);
   Record.AddSourceLocation(D->getCategoryNameLoc());
-  Record.AddSourceLocation(D->getIvarLBraceLoc());
-  Record.AddSourceLocation(D->getIvarRBraceLoc());
+  Record.AddSourceRange({D->getIvarLBraceLoc(), D->getIvarRBraceLoc()});
   Record.AddDeclRef(D->getClassInterface());
   AddObjCTypeParamList(D->TypeParamList);
   Record.push_back(D->protocol_size());
   for (const auto *I : D->protocols())
     Record.AddDeclRef(I);
   for (const auto &PL : D->protocol_locs())
     Record.AddSourceLocation(PL);
   Code = serialization::DECL_OBJC_CATEGORY;
void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
   Record.AddSourceLocation(D->getCategoryNameLoc());
   Code = serialization::DECL_OBJC_CATEGORY_IMPL;
 }
 
 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
   VisitObjCImplDecl(D);
   Record.AddDeclRef(D->getSuperClass());
   Record.AddSourceLocation(D->getSuperClassLoc());
-  Record.AddSourceLocation(D->getIvarLBraceLoc());
-  Record.AddSourceLocation(D->getIvarRBraceLoc());
+  Record.AddSourceRange({D->getIvarLBraceLoc(), D->getIvarRBraceLoc()});
   Record.push_back(D->hasNonZeroConstructors());
   Record.push_back(D->hasDestructors());
   Record.push_back(D->NumIvarInitializers);
   if (D->NumIvarInitializers)
     Record.AddCXXCtorInitializers(
         llvm::makeArrayRef(D->init_begin(), D->init_end()));
   Code = serialization::DECL_OBJC_IMPLEMENTATION;
 }

clang/lib/Serialization/ASTWriterStmt.cpp

#define STMT(Type, Base) \
     void Visit##Type(Type *);
 #include "clang/AST/StmtNodes.inc"
   };
 }
 
 void ASTStmtWriter::AddTemplateKWAndArgsInfo(
     const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
   Record.AddSourceLocation(ArgInfo.TemplateKWLoc);
-  Record.AddSourceLocation(ArgInfo.LAngleLoc);
-  Record.AddSourceLocation(ArgInfo.RAngleLoc);
+  Record.AddSourceRange({ArgInfo.LAngleLoc, ArgInfo.RAngleLoc});
   for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
     Record.AddTemplateArgumentLoc(Args[i]);
 }
 
 void ASTStmtWriter::VisitStmt(Stmt *S) {
 }
 
 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getSemiLoc());
   Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);
   Code = serialization::STMT_NULL;
 }
 
 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
   VisitStmt(S);
   Record.push_back(S->size());
   for (auto *CS : S->body())
     Record.AddStmt(CS);
-  Record.AddSourceLocation(S->getLBracLoc());
-  Record.AddSourceLocation(S->getRBracLoc());
+  Record.AddSourceRange({S->getLBracLoc(), S->getRBracLoc()});
   Code = serialization::STMT_COMPOUND;
 }
 
 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
   VisitStmt(S);
   Record.push_back(Writer.getSwitchCaseID(S));
   Record.AddSourceLocation(S->getKeywordLoc());
   Record.AddSourceLocation(S->getColonLoc());
void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
   if (HasElse)
     Record.AddStmt(S->getElse());
   if (HasVar)
     Record.AddDeclRef(S->getConditionVariable());
   if (HasInit)
     Record.AddStmt(S->getInit());
 
   Record.AddSourceLocation(S->getIfLoc());
-  Record.AddSourceLocation(S->getLParenLoc());
-  Record.AddSourceLocation(S->getRParenLoc());
+  Record.AddSourceRange({S->getLParenLoc(), S->getRParenLoc()});
   if (HasElse)
     Record.AddSourceLocation(S->getElseLoc());
 
   Code = serialization::STMT_IF;
 }
 
 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
   VisitStmt(S);
 
   bool HasInit = S->getInit() != nullptr;
   bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
   Record.push_back(HasInit);
   Record.push_back(HasVar);
   Record.push_back(S->isAllEnumCasesCovered());
 
   Record.AddStmt(S->getCond());
   Record.AddStmt(S->getBody());
   if (HasInit)
     Record.AddStmt(S->getInit());
   if (HasVar)
     Record.AddDeclRef(S->getConditionVariable());
 
   Record.AddSourceLocation(S->getSwitchLoc());
-  Record.AddSourceLocation(S->getLParenLoc());
-  Record.AddSourceLocation(S->getRParenLoc());
+  Record.AddSourceRange({S->getLParenLoc(), S->getRParenLoc()});
 
   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
        SC = SC->getNextSwitchCase())
     Record.push_back(Writer.RecordSwitchCaseID(SC));
   Code = serialization::STMT_SWITCH;
 }
 
 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
   VisitStmt(S);
 
   bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
   Record.push_back(HasVar);
 
   Record.AddStmt(S->getCond());
   Record.AddStmt(S->getBody());
   if (HasVar)
     Record.AddDeclRef(S->getConditionVariable());
 
   Record.AddSourceLocation(S->getWhileLoc());
-  Record.AddSourceLocation(S->getLParenLoc());
-  Record.AddSourceLocation(S->getRParenLoc());
+  Record.AddSourceRange({S->getLParenLoc(), S->getRParenLoc()});
   Code = serialization::STMT_WHILE;
 }
 
 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
   VisitStmt(S);
   Record.AddStmt(S->getCond());
   Record.AddStmt(S->getBody());
   Record.AddSourceLocation(S->getDoLoc());
   Record.AddSourceLocation(S->getWhileLoc());
   Record.AddSourceLocation(S->getRParenLoc());
   Code = serialization::STMT_DO;
 }
 
 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
   VisitStmt(S);
   Record.AddStmt(S->getInit());
   Record.AddStmt(S->getCond());
   Record.AddDeclRef(S->getConditionVariable());
   Record.AddStmt(S->getInc());
   Record.AddStmt(S->getBody());
   Record.AddSourceLocation(S->getForLoc());
-  Record.AddSourceLocation(S->getLParenLoc());
-  Record.AddSourceLocation(S->getRParenLoc());
+  Record.AddSourceRange({S->getLParenLoc(), S->getRParenLoc()});
   Code = serialization::STMT_FOR;
 }
 
 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
   VisitStmt(S);
   Record.AddDeclRef(S->getLabel());
   Record.AddSourceLocation(S->getGotoLoc());
   Record.AddSourceLocation(S->getLabelLoc());
if (HasNRVOCandidate)
     Record.AddDeclRef(S->getNRVOCandidate());
 
   Record.AddSourceLocation(S->getReturnLoc());
   Code = serialization::STMT_RETURN;
 }
 
 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
   VisitStmt(S);
-  Record.AddSourceLocation(S->getBeginLoc());
-  Record.AddSourceLocation(S->getEndLoc());
+  Record.AddSourceRange({S->getBeginLoc(), S->getEndLoc()});
   DeclGroupRef DG = S->getDeclGroup();
   for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
     Record.AddDeclRef(*D);
   Code = serialization::STMT_DECL;
 }
 
 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
   VisitStmt(S);
void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
   Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_CONSTANT;
 }
 
 void ASTStmtWriter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
   VisitExpr(E);
 
   Record.AddSourceLocation(E->getLocation());
-  Record.AddSourceLocation(E->getLParenLocation());
-  Record.AddSourceLocation(E->getRParenLocation());
+  Record.AddSourceRange({E->getLParenLocation(), E->getRParenLocation()});
   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
 
   Code = serialization::EXPR_SYCL_UNIQUE_STABLE_NAME;
 }
 
 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
   VisitExpr(E);
 
void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
 
   AbbrevToUse = Writer.getCharacterLiteralAbbrev();
 
   Code = serialization::EXPR_CHARACTER_LITERAL;
 }
 
 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
   VisitExpr(E);
-  Record.AddSourceLocation(E->getLParen());
-  Record.AddSourceLocation(E->getRParen());
+  Record.AddSourceRange({E->getLParen(), E->getRParen()});
   Record.AddStmt(E->getSubExpr());
   Code = serialization::EXPR_PAREN;
 }
 
 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumExprs());
   for (auto *SubStmt : E->exprs())
     Record.AddStmt(SubStmt);
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   Code = serialization::EXPR_PAREN_LIST;
 }
 
 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
   bool HasFPFeatures = E->hasStoredFPFeatures();
   // Write this first for easy access when deserializing, as they affect the
   // size of the UnaryOperator.
void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
   Record.push_back(E->getNumComponents());
   Record.push_back(E->getNumExpressions());
   Record.AddSourceLocation(E->getOperatorLoc());
   Record.AddSourceLocation(E->getRParenLoc());
   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
     const OffsetOfNode &ON = E->getComponent(I);
     Record.push_back(ON.getKind()); // FIXME: Stable encoding
-    Record.AddSourceLocation(ON.getSourceRange().getBegin());
-    Record.AddSourceLocation(ON.getSourceRange().getEnd());
+    Record.AddSourceRange(ON.getSourceRange());
     switch (ON.getKind()) {
     case OffsetOfNode::Array:
       Record.push_back(ON.getArrayExprIndex());
       break;
 
     case OffsetOfNode::Field:
       Record.AddDeclRef(ON.getField());
       break;

 void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getDimensions().size());
   Record.AddStmt(E->getBase());
   for (Expr *Dim : E->getDimensions())
     Record.AddStmt(Dim);
   for (SourceRange SR : E->getBracketsRanges())
     Record.AddSourceRange(SR);
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   Code = serialization::EXPR_OMP_ARRAY_SHAPING;
 }
 
 void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
   VisitExpr(E);
   Record.push_back(E->numOfIterators());
   Record.AddSourceLocation(E->getIteratorKwLoc());
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
     Record.AddDeclRef(E->getIteratorDecl(I));
     Record.AddSourceLocation(E->getAssignLoc(I));
     OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
     Record.AddStmt(Range.Begin);
     Record.AddStmt(Range.End);
     Record.AddStmt(Range.Step);
     Record.AddSourceLocation(E->getColonLoc(I));
void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
   if (E->hasStoredFPFeatures())
     Record.push_back(E->getFPFeatures().getAsOpaqueInt());
   Code = serialization::EXPR_CALL;
 }
 
 void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
   VisitExpr(E);
   Record.push_back(std::distance(E->children().begin(), E->children().end()));
-  Record.AddSourceLocation(E->getBeginLoc());
-  Record.AddSourceLocation(E->getEndLoc());
+  Record.AddSourceRange({E->getBeginLoc(), E->getEndLoc()});
   for (Stmt *Child : E->children())
     Record.AddStmt(Child);
   Code = serialization::EXPR_RECOVERY;
 }
 
 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
   VisitExpr(E);
 

 
 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
   VisitCastExpr(E);
   Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
 }
 
 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
   VisitExplicitCastExpr(E);
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   Code = serialization::EXPR_CSTYLE_CAST;
 }
 
 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
   VisitExpr(E);
   Record.AddSourceLocation(E->getLParenLoc());
   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
   Record.AddStmt(E->getInitializer());
void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
   Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
 }
 
 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
   VisitExpr(E);
   // NOTE: only add the (possibly null) syntactic form.
   // No need to serialize the isSemanticForm flag and the semantic form.
   Record.AddStmt(E->getSyntacticForm());
-  Record.AddSourceLocation(E->getLBraceLoc());
-  Record.AddSourceLocation(E->getRBraceLoc());
+  Record.AddSourceRange({E->getLBraceLoc(), E->getRBraceLoc()});
   bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
   Record.push_back(isArrayFiller);
   if (isArrayFiller)
     Record.AddStmt(E->getArrayFiller());
   else
     Record.AddDeclRef(E->getInitializedFieldInUnion());
   Record.push_back(E->hadArrayRangeDesignator());
   Record.push_back(E->getNumInits());
if (D.isFieldDesignator()) {
         Record.push_back(serialization::DESIG_FIELD_NAME);
         Record.AddIdentifierRef(D.getFieldName());
       }
       Record.AddSourceLocation(D.getDotLoc());
       Record.AddSourceLocation(D.getFieldLoc());
     } else if (D.isArrayDesignator()) {
       Record.push_back(serialization::DESIG_ARRAY);
       Record.push_back(D.getFirstExprIndex());
-      Record.AddSourceLocation(D.getLBracketLoc());
-      Record.AddSourceLocation(D.getRBracketLoc());
+      Record.AddSourceRange({D.getLBracketLoc(), D.getRBracketLoc()});
     } else {
       assert(D.isArrayRangeDesignator() && "Unknown designator");
       Record.push_back(serialization::DESIG_ARRAY_RANGE);
       Record.push_back(D.getFirstExprIndex());
-      Record.AddSourceLocation(D.getLBracketLoc());
+      Record.AddSourceRange({D.getLBracketLoc(), D.getRBracketLoc()});
       Record.AddSourceLocation(D.getEllipsisLoc());
-      Record.AddSourceLocation(D.getRBracketLoc());
     }
   }
   Code = serialization::EXPR_DESIGNATED_INIT;
 }
 
 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
   VisitExpr(E);
   Record.AddStmt(E->getBase());
void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
   Record.AddSourceLocation(E->getLabelLoc());
   Record.AddDeclRef(E->getLabel());
   Code = serialization::EXPR_ADDR_LABEL;
 }
 
 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
   VisitExpr(E);
   Record.AddStmt(E->getSubStmt());
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   Record.push_back(E->getTemplateDepth());
   Code = serialization::EXPR_STMT;
 }
 
 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
   VisitExpr(E);
   Record.AddStmt(E->getCond());
   Record.AddStmt(E->getLHS());
void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
   if (E->getMethodDecl()) {
     Record.push_back(1);
     Record.AddDeclRef(E->getMethodDecl());
   } else {
     Record.push_back(0);
     Record.AddSelectorRef(E->getSelector());
   }
 
-  Record.AddSourceLocation(E->getLeftLoc());
-  Record.AddSourceLocation(E->getRightLoc());
+  Record.AddSourceRange({E->getLeftLoc(), E->getRightLoc()});
 
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
     Record.AddStmt(*Arg);
 
   SourceLocation *Locs = E->getStoredSelLocs();
   for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
     Record.AddSourceLocation(Locs[i]);

 
 void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
   VisitCXXNamedCastExpr(E);
   Code = serialization::EXPR_CXX_ADDRSPACE_CAST;
 }
 
 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
   VisitExplicitCastExpr(E);
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
 }
 
 void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
   VisitExplicitCastExpr(E);
   Record.AddSourceLocation(E->getBeginLoc());
   Record.AddSourceLocation(E->getEndLoc());
   Code = serialization::EXPR_BUILTIN_BIT_CAST;

 void
 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   for (CXXUnresolvedConstructExpr::arg_iterator
          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
     Record.AddStmt(*ArgI);
   Record.AddTypeSourceInfo(E->getTypeSourceInfo());
-  Record.AddSourceLocation(E->getLParenLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
+  Record.AddSourceRange({E->getLParenLoc(), E->getRParenLoc()});
   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
 }
 
 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
   VisitExpr(E);
 
   Record.push_back(E->getNumDecls());
   Record.push_back(E->hasTemplateKWAndArgsInfo());
void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
   VisitStmt(S);
   for (Stmt *SubStmt : S->SubStmts)
     Record.AddStmt(SubStmt);
   Code = serialization::STMT_OMP_CANONICAL_LOOP;
 }
 
 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   Record.writeOMPChildren(E->Data);
-  Record.AddSourceLocation(E->getBeginLoc());
-  Record.AddSourceLocation(E->getEndLoc());
+  Record.AddSourceRange({E->getBeginLoc(), E->getEndLoc()});
 }
 
 void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
   VisitStmt(D);
   Record.writeUInt32(D->getLoopsNumber());
   VisitOMPExecutableDirective(D);
 }