[Basic] Introduce PODSourceLocation, NFCI

[miyuki]

Summary

The goal of this change is to further reduce the number of cases when
the internal representation of SourceLocation is accessed directly.

The change adds a new class PODSourceLocation and replaces 'unsigned'
with 'PODSourceLocation' where possible. The PODSourceLocation class
holds the same information as SourceLocation, but it is a POD type,
hence it can be used in contexts where SourceLocation cannot be used
(e.g. unions with implicit default constructors).

SourceLocation objects can be converted to PODSourceLocation and
constructed from PODSourceLocation using the corresponding helpers
getPOD and getFromPOD.

[miyuki]

Rebased

[dexonsmith]

An alternative would be to update the unions to an AlignedCharArrayUnion and use SourceLocation directly. WDYT?

clang/include/clang/AST/DeclObjC.h

639–642

IIRC, this will not be a POD, since the access of the members of PODSourceRange is public and the access of the members of PODSourceLocation is private.

[miyuki]

In D69903#2340020, @dexonsmith wrote:

An alternative would be to update the unions to an AlignedCharArrayUnion and use SourceLocation directly. WDYT?

So, say, in DeclarationNameLoc, I would add AlignedCharArrayUnion as follows:

union {
  llvm::AlignedCharArrayUnion<struct NT, struct CXXOpName, struct CXXLitOpName> UninitStorage;
  struct NT NamedType;
  struct CXXOpName CXXOperatorName;
  struct CXXLitOpName CXXLiteralOperatorName;
};

And change the constructor of DeclarationNameLoc to default-construct UninitStorage, i.e.:

DeclarationNameLoc() : UninitStorage() {
  memset(UninitStorage.buffer, 0, sizeof(UninitStorage.buffer));
}

After that, I can use SourceLocation in DeclarationNameLoc directly.

Do I understand your idea correctly?

[dexonsmith]

In D69903#2342011, @miyuki wrote:

In D69903#2340020, @dexonsmith wrote:

An alternative would be to update the unions to an AlignedCharArrayUnion and use SourceLocation directly. WDYT?

So, say, in DeclarationNameLoc, I would add AlignedCharArrayUnion as follows:

union {
  llvm::AlignedCharArrayUnion<struct NT, struct CXXOpName, struct CXXLitOpName> UninitStorage;
  struct NT NamedType;
  struct CXXOpName CXXOperatorName;
  struct CXXLitOpName CXXLiteralOperatorName;
};

And change the constructor of DeclarationNameLoc to default-construct UninitStorage, i.e.:

DeclarationNameLoc() : UninitStorage() {
  memset(UninitStorage.buffer, 0, sizeof(UninitStorage.buffer));
}

After that, I can use SourceLocation in DeclarationNameLoc directly.

Do I understand your idea correctly?

Not quite, I wasn't thinking of wrapping the AlignedCharArrayUnion in a union, I was thinking of using it *as* the union.

Here's one way you could do it. In the first commit, you can change:

union {
  struct NT NamedType;
  struct CXXOpName CXXOperatorName;
  struct CXXLitOpName CXXLiteralOperatorName;
};

to something like:

AlignedCharArrayUnion<NT, CXXOpName, CXXLitOpName> NameLoc;

This will mean updating users of NamedType, CXXOperatorName, and CXXLiteralOperatorName to go through the new NameLoc field. If there are a lot of them, you might want to start with a prep commit that adds:

NT &getNamedType() { return NamedType; }
CXXOpName &getCXXOperatorName() { return CXXOperatorName; }
CXXLitOpName &getCXXLiteralOperatorName() { return CXXLiteralOperatorName; }

and change all the users to go through the function, then when you land the change to AlignedCharArrayUnion you just have to update those three functions. But if there aren't many users it may not be worth it.

Once you've created NameLoc (using an AlignedCharArrayUnion), a follow-up commit can change CXXOpName and CXXLitOpName to use a SourceLocation instead of a PODSourceLocation, and then you can delete PODSourceLocation once you've handled all of its users.

[miyuki]

Abandoning in favor of D94237 and D94596.

clang/include/clang/AST/DeclObjC.h

 ///
 /// \code
 /// @interface NSArray<T> // stores the <T>
 /// @end
 /// \endcode
 class ObjCTypeParamList final
     : private llvm::TrailingObjects<ObjCTypeParamList, ObjCTypeParamDecl *> {
   /// Stores the components of a SourceRange as a POD.
   struct PODSourceRange {
-    unsigned Begin;
-    unsigned End;
+    PODSourceLocation Begin;
+    PODSourceLocation End;
   };
 
   union {
     /// Location of the left and right angle brackets.
     PODSourceRange Brackets;
 
     // Used only for alignment.
     ObjCTypeParamDecl *AlignmentHack;
   };
public:
   }
 
   ObjCTypeParamDecl *back() const {
     assert(size() > 0 && "empty Objective-C type parameter list");
     return *(end() - 1);
   }
 
   SourceLocation getLAngleLoc() const {
-    return SourceLocation::getFromRawEncoding(Brackets.Begin);
+    return SourceLocation::getFromPOD(Brackets.Begin);
   }
 
   SourceLocation getRAngleLoc() const {
-    return SourceLocation::getFromRawEncoding(Brackets.End);
+    return SourceLocation::getFromPOD(Brackets.End);
   }
 
   SourceRange getSourceRange() const {
     return SourceRange(getLAngleLoc(), getRAngleLoc());
   }
 
   /// Gather the default set of type arguments to be substituted for
   /// these type parameters when dealing with an unspecialized type.

clang/include/clang/AST/DeclarationName.h

struct DeclarationNameLoc {
   // Locations (if any) for the tilde (destructor) or operator keyword
   // (conversion) are stored elsewhere.
   struct NT {
     TypeSourceInfo *TInfo;
   };
 
   // The location (if any) of the operator keyword is stored elsewhere.
   struct CXXOpName {
-    unsigned BeginOpNameLoc;
-    unsigned EndOpNameLoc;
+    PODSourceLocation BeginOpNameLoc;
+    PODSourceLocation EndOpNameLoc;
   };
 
   // The location (if any) of the operator keyword is stored elsewhere.
   struct CXXLitOpName {
-    unsigned OpNameLoc;
+    PODSourceLocation OpNameLoc;
   };
 
   // struct {} CXXUsingDirective;
   // struct {} ObjCZeroArgSelector;
   // struct {} ObjCOneArgSelector;
   // struct {} ObjCMultiArgSelector;
   union {
     struct NT NamedType;
public:
   }
 
   /// getCXXOperatorNameRange - Gets the range of the operator name
   /// (without the operator keyword). Assumes it is a (non-literal) operator.
   SourceRange getCXXOperatorNameRange() const {
     if (Name.getNameKind() != DeclarationName::CXXOperatorName)
       return SourceRange();
     return SourceRange(
-     SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.BeginOpNameLoc),
-     SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.EndOpNameLoc)
+     SourceLocation::getFromPOD(LocInfo.CXXOperatorName.BeginOpNameLoc),
+     SourceLocation::getFromPOD(LocInfo.CXXOperatorName.EndOpNameLoc)
                        );
   }
 
   /// setCXXOperatorNameRange - Sets the range of the operator name
   /// (without the operator keyword). Assumes it is a C++ operator.
   void setCXXOperatorNameRange(SourceRange R) {
     assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
-    LocInfo.CXXOperatorName.BeginOpNameLoc = R.getBegin().getRawEncoding();
-    LocInfo.CXXOperatorName.EndOpNameLoc = R.getEnd().getRawEncoding();
+    LocInfo.CXXOperatorName.BeginOpNameLoc = R.getBegin().getPOD();
+    LocInfo.CXXOperatorName.EndOpNameLoc = R.getEnd().getPOD();
   }
 
   /// getCXXLiteralOperatorNameLoc - Returns the location of the literal
   /// operator name (not the operator keyword).
   /// Assumes it is a literal operator.
   SourceLocation getCXXLiteralOperatorNameLoc() const {
     if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName)
       return SourceLocation();
     return SourceLocation::
-      getFromRawEncoding(LocInfo.CXXLiteralOperatorName.OpNameLoc);
+      getFromPOD(LocInfo.CXXLiteralOperatorName.OpNameLoc);
   }
 
   /// setCXXLiteralOperatorNameLoc - Sets the location of the literal
   /// operator name (not the operator keyword).
   /// Assumes it is a literal operator.
   void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
     assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
-    LocInfo.CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
+    LocInfo.CXXLiteralOperatorName.OpNameLoc = Loc.getPOD();
   }
 
   /// Determine whether this name involves a template parameter.
   bool isInstantiationDependent() const;
 
   /// Determine whether this name contains an unexpanded
   /// parameter pack.
   bool containsUnexpandedParameterPack() const;

clang/include/clang/AST/DependentDiagnostic.h

static DependentDiagnostic *Create(ASTContext &Context,
                                      SourceLocation Loc,
                                      bool IsMemberAccess,
                                      AccessSpecifier AS,
                                      NamedDecl *TargetDecl,
                                      CXXRecordDecl *NamingClass,
                                      QualType BaseObjectType,
                                      const PartialDiagnostic &PDiag) {
     DependentDiagnostic *DD = Create(Context, Parent, PDiag);
-    DD->AccessData.Loc = Loc.getRawEncoding();
+    DD->AccessData.Loc = Loc.getPOD();
     DD->AccessData.IsMember = IsMemberAccess;
     DD->AccessData.Access = AS;
     DD->AccessData.TargetDecl = TargetDecl;
     DD->AccessData.NamingClass = NamingClass;
     DD->AccessData.BaseObjectType = BaseObjectType.getAsOpaquePtr();
     return DD;
   }
 
   unsigned getKind() const {
     return Access;
   }
 
   bool isAccessToMember() const {
     assert(getKind() == Access);
     return AccessData.IsMember;
   }
 
   AccessSpecifier getAccess() const {
     assert(getKind() == Access);
     return AccessSpecifier(AccessData.Access);
   }
 
   SourceLocation getAccessLoc() const {
     assert(getKind() == Access);
-    return SourceLocation::getFromRawEncoding(AccessData.Loc);
+    return SourceLocation::getFromPOD(AccessData.Loc);
   }
 
   NamedDecl *getAccessTarget() const {
     assert(getKind() == Access);
     return AccessData.TargetDecl;
   }
 
   NamedDecl *getAccessNamingClass() const {
static DependentDiagnostic *Create(ASTContext &Context,
                                      DeclContext *Parent,
                                      const PartialDiagnostic &PDiag);
 
   DependentDiagnostic *NextDiagnostic;
 
   PartialDiagnostic Diag;
 
   struct {
-    unsigned Loc;
+    PODSourceLocation Loc;
     unsigned Access : 2;
     unsigned IsMember : 1;
     NamedDecl *TargetDecl;
     CXXRecordDecl *NamingClass;
     void *BaseObjectType;
   } AccessData;
 };
 

clang/include/clang/AST/Expr.h

struct FieldDesignator {
     /// of this field determines whether this is actually a pointer
     /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
     /// initially constructed, a field designator will store an
     /// IdentifierInfo*. After semantic analysis has resolved that
     /// name, the field designator will instead store a FieldDecl*.
     uintptr_t NameOrField;
 
     /// The location of the '.' in the designated initializer.
-    unsigned DotLoc;
+    PODSourceLocation DotLoc;
 
     /// The location of the field name in the designated initializer.
-    unsigned FieldLoc;
+    PODSourceLocation FieldLoc;
   };
 
   /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
   struct ArrayOrRangeDesignator {
     /// Location of the first index expression within the designated
     /// initializer expression's list of subexpressions.
     unsigned Index;
     /// The location of the '[' starting the array range designator.
-    unsigned LBracketLoc;
+    PODSourceLocation LBracketLoc;
     /// The location of the ellipsis separating the start and end
     /// indices. Only valid for GNU array-range designators.
-    unsigned EllipsisLoc;
+    PODSourceLocation EllipsisLoc;
     /// The location of the ']' terminating the array range designator.
-    unsigned RBracketLoc;
+    PODSourceLocation RBracketLoc;
   };
 
   /// Represents a single C99 designator.
   ///
   /// @todo This class is infuriatingly similar to clang::Designator,
   /// but minor differences (storing indices vs. storing pointers)
   /// keep us from reusing it. Try harder, later, to rectify these
   /// differences.
public:
   public:
     Designator() {}
 
     /// Initializes a field designator.
     Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
                SourceLocation FieldLoc)
       : Kind(FieldDesignator) {
       Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
-      Field.DotLoc = DotLoc.getRawEncoding();
-      Field.FieldLoc = FieldLoc.getRawEncoding();
+      Field.DotLoc = DotLoc.getPOD();
+      Field.FieldLoc = FieldLoc.getPOD();
     }
 
     /// Initializes an array designator.
     Designator(unsigned Index, SourceLocation LBracketLoc,
                SourceLocation RBracketLoc)
       : Kind(ArrayDesignator) {
       ArrayOrRange.Index = Index;
-      ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
-      ArrayOrRange.EllipsisLoc = SourceLocation().getRawEncoding();
-      ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayOrRange.LBracketLoc = LBracketLoc.getPOD();
+      ArrayOrRange.EllipsisLoc = SourceLocation().getPOD();
+      ArrayOrRange.RBracketLoc = RBracketLoc.getPOD();
     }
 
     /// Initializes a GNU array-range designator.
     Designator(unsigned Index, SourceLocation LBracketLoc,
                SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
       : Kind(ArrayRangeDesignator) {
       ArrayOrRange.Index = Index;
-      ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
-      ArrayOrRange.EllipsisLoc = EllipsisLoc.getRawEncoding();
-      ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayOrRange.LBracketLoc = LBracketLoc.getPOD();
+      ArrayOrRange.EllipsisLoc = EllipsisLoc.getPOD();
+      ArrayOrRange.RBracketLoc = RBracketLoc.getPOD();
     }
 
     bool isFieldDesignator() const { return Kind == FieldDesignator; }
     bool isArrayDesignator() const { return Kind == ArrayDesignator; }
     bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
 
     IdentifierInfo *getFieldName() const;
 
     FieldDecl *getField() const {
       assert(Kind == FieldDesignator && "Only valid on a field designator");
       if (Field.NameOrField & 0x01)
         return nullptr;
       else
         return reinterpret_cast<FieldDecl *>(Field.NameOrField);
     }
 
     void setField(FieldDecl *FD) {
       assert(Kind == FieldDesignator && "Only valid on a field designator");
       Field.NameOrField = reinterpret_cast<uintptr_t>(FD);
     }
 
     SourceLocation getDotLoc() const {
       assert(Kind == FieldDesignator && "Only valid on a field designator");
-      return SourceLocation::getFromRawEncoding(Field.DotLoc);
+      return SourceLocation::getFromPOD(Field.DotLoc);
     }
 
     SourceLocation getFieldLoc() const {
       assert(Kind == FieldDesignator && "Only valid on a field designator");
-      return SourceLocation::getFromRawEncoding(Field.FieldLoc);
+      return SourceLocation::getFromPOD(Field.FieldLoc);
     }
 
     SourceLocation getLBracketLoc() const {
       assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
              "Only valid on an array or array-range designator");
-      return SourceLocation::getFromRawEncoding(ArrayOrRange.LBracketLoc);
+      return SourceLocation::getFromPOD(ArrayOrRange.LBracketLoc);
     }
 
     SourceLocation getRBracketLoc() const {
       assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
              "Only valid on an array or array-range designator");
-      return SourceLocation::getFromRawEncoding(ArrayOrRange.RBracketLoc);
+      return SourceLocation::getFromPOD(ArrayOrRange.RBracketLoc);
     }
 
     SourceLocation getEllipsisLoc() const {
       assert(Kind == ArrayRangeDesignator &&
              "Only valid on an array-range designator");
-      return SourceLocation::getFromRawEncoding(ArrayOrRange.EllipsisLoc);
+      return SourceLocation::getFromPOD(ArrayOrRange.EllipsisLoc);
     }
 
     unsigned getFirstExprIndex() const {
       assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
              "Only valid on an array or array-range designator");
       return ArrayOrRange.Index;
     }
 

clang/include/clang/AST/TemplateBase.h

 /// Location information for a TemplateArgument.
 struct TemplateArgumentLocInfo {
 private:
   struct T {
     // FIXME: We'd like to just use the qualifier in the TemplateName,
     // but template arguments get canonicalized too quickly.
     NestedNameSpecifier *Qualifier;
     void *QualifierLocData;
-    unsigned TemplateNameLoc;
-    unsigned EllipsisLoc;
+    PODSourceLocation TemplateNameLoc;
+    PODSourceLocation EllipsisLoc;
   };
 
   union {
     struct T Template;
     Expr *Expression;
     TypeSourceInfo *Declarator;
   };
 
 public:
-  constexpr TemplateArgumentLocInfo() : Template({nullptr, nullptr, 0, 0}) {}
+  constexpr TemplateArgumentLocInfo() : Template({nullptr, nullptr, {}, {}}) {}
 
   TemplateArgumentLocInfo(TypeSourceInfo *TInfo) : Declarator(TInfo) {}
 
   TemplateArgumentLocInfo(Expr *E) : Expression(E) {}
 
   TemplateArgumentLocInfo(NestedNameSpecifierLoc QualifierLoc,
                           SourceLocation TemplateNameLoc,
                           SourceLocation EllipsisLoc) {
     Template.Qualifier = QualifierLoc.getNestedNameSpecifier();
     Template.QualifierLocData = QualifierLoc.getOpaqueData();
-    Template.TemplateNameLoc = TemplateNameLoc.getRawEncoding();
-    Template.EllipsisLoc = EllipsisLoc.getRawEncoding();
+    Template.TemplateNameLoc = TemplateNameLoc.getPOD();
+    Template.EllipsisLoc = EllipsisLoc.getPOD();
   }
 
   TypeSourceInfo *getAsTypeSourceInfo() const {
     return Declarator;
   }
 
   Expr *getAsExpr() const {
     return Expression;
   }
 
   NestedNameSpecifierLoc getTemplateQualifierLoc() const {
     return NestedNameSpecifierLoc(Template.Qualifier,
                                   Template.QualifierLocData);
   }
 
   SourceLocation getTemplateNameLoc() const {
-    return SourceLocation::getFromRawEncoding(Template.TemplateNameLoc);
+    return SourceLocation::getFromPOD(Template.TemplateNameLoc);
   }
 
   SourceLocation getTemplateEllipsisLoc() const {
-    return SourceLocation::getFromRawEncoding(Template.EllipsisLoc);
+    return SourceLocation::getFromPOD(Template.EllipsisLoc);
   }
 };
 
 /// Location wrapper for a TemplateArgument.  TemplateArgument is to
 /// TemplateArgumentLoc as Type is to TypeLoc.
 class TemplateArgumentLoc {
   TemplateArgument Argument;
   TemplateArgumentLocInfo LocInfo;

clang/include/clang/Basic/SourceLocation.h

static FileID get(int V) {
     FileID F;
     F.ID = V;
     return F;
   }
 
   int getOpaqueValue() const { return ID; }
 };
 
+/// Encodes a location in the source. This class is used in cases when a POD
+/// type is required and SourceLocation cannot be used (e.g. in unions).
+///
+/// The default constructor of PODSourceLocation leaves it in an uninitialized
+/// state.
+///
+/// \see SourceLocation
+class PODSourceLocation {
+  friend class SourceLocation;
+  unsigned ID;
+public:
+  /// Set the value to "Invalid location"
+  void clear() { ID = 0; }
+
+  bool isValid() const { return ID != 0; }
+  bool isInvalid() const { return ID == 0; }
+
+  friend bool operator==(const PODSourceLocation &LHS,
+                         const PODSourceLocation &RHS) {
+    return LHS.ID == RHS.ID;
+  }
+
+  friend bool operator<(const PODSourceLocation &LHS,
+                        const PODSourceLocation &RHS) {
+    return LHS.ID < RHS.ID;
+  }
+
+  friend bool operator!=(const PODSourceLocation &LHS,
+                         const PODSourceLocation &RHS) {
+    return !(LHS == RHS);
+  }
+};
+
+static_assert(std::is_pod<PODSourceLocation>::value,
+              "PODSourceLocation must be a POD type");
+
 /// Encodes a location in the source. The SourceManager can decode this
 /// to get at the full include stack, line and column information.
 ///
 /// Technically, a source location is simply an offset into the manager's view
 /// of the input source, which is all input buffers (including macro
 /// expansions) concatenated in an effectively arbitrary order. The manager
 /// actually maintains two blocks of input buffers. One, starting at offset
 /// 0 and growing upwards, contains all buffers from this module. The other,
public:
   /// SourceLocation.
   SourceLocation getLocWithOffset(int Offset) const {
     assert(((getOffset()+Offset) & MacroIDBit) == 0 && "offset overflow");
     SourceLocation L;
     L.ID = ID+Offset;
     return L;
   }
 
+  /// Return a POD object containing the same information as SourceLocation
+  PODSourceLocation getPOD() const {
+    PODSourceLocation Loc;
+    Loc.ID = ID;
+    return Loc;
+  }
+
+  /// Turn a PODSourceLocation into a SourceLocation.
+  ///
+  /// \see getPOD.
+  static SourceLocation getFromPOD(PODSourceLocation Encoding) {
+    SourceLocation X;
+    X.ID = Encoding.ID;
+    return X;
+  }
+
   /// When a SourceLocation itself cannot be used, this returns
   /// an (opaque) 32-bit integer encoding for it.
   ///
-  /// This should only be passed to SourceLocation::getFromRawEncoding, it
-  /// should not be inspected directly.
+  /// This should only be used when PODSourceLocation cannot be used (e.g. C
+  /// API boundary). The return value should not be inspected directly, it
+  /// should be passed to SourceLocation::getFromRawEncoding.
   unsigned getRawEncoding() const { return ID; }
 
   /// Turn a raw encoding of a SourceLocation object into
   /// a real SourceLocation.
   ///
   /// \see getRawEncoding.
   static SourceLocation getFromRawEncoding(unsigned Encoding) {
     SourceLocation X;
public:
   void Profile(llvm::FoldingSetNodeID &Node) const;
 
   void print(raw_ostream &OS, const SourceManager &SM) const;
   std::string printToString(const SourceManager &SM) const;
   void dump(const SourceManager &SM) const;
 };
 
 inline bool operator==(const SourceLocation &LHS, const SourceLocation &RHS) {
-  return LHS.getRawEncoding() == RHS.getRawEncoding();
+  return LHS.getPOD() == RHS.getPOD();
 }
 
 inline bool operator!=(const SourceLocation &LHS, const SourceLocation &RHS) {
   return !(LHS == RHS);
 }
 
 inline bool operator<(const SourceLocation &LHS, const SourceLocation &RHS) {
-  return LHS.getRawEncoding() < RHS.getRawEncoding();
+  return LHS.getPOD() < RHS.getPOD();
 }
 
 /// A trivial tuple used to represent a source range.
 class SourceRange {
   SourceLocation B;
   SourceLocation E;
 
 public:
public:
 
   /// Prints information about this FullSourceLoc to stderr.
   ///
   /// This is useful for debugging.
   void dump() const;
 
   friend bool
   operator==(const FullSourceLoc &LHS, const FullSourceLoc &RHS) {
-    return LHS.getRawEncoding() == RHS.getRawEncoding() &&
+    return LHS.getPOD() == RHS.getPOD() &&
           LHS.SrcMgr == RHS.SrcMgr;
   }
 
   friend bool
   operator!=(const FullSourceLoc &LHS, const FullSourceLoc &RHS) {
     return !(LHS == RHS);
   }
 };
namespace llvm {
   struct PointerLikeTypeTraits<clang::SourceLocation> {
     enum { NumLowBitsAvailable = 0 };
 
     static void *getAsVoidPointer(clang::SourceLocation L) {
       return L.getPtrEncoding();
     }
 
     static clang::SourceLocation getFromVoidPointer(void *P) {
-      return clang::SourceLocation::getFromRawEncoding((unsigned)(uintptr_t)P);
+      return clang::SourceLocation::getFromPtrEncoding(P);
     }
   };
 
 } // namespace llvm
 
 #endif // LLVM_CLANG_BASIC_SOURCELOCATION_H

clang/include/clang/Basic/SourceManager.h

namespace SrcMgr {
   class FileInfo {
     friend class clang::SourceManager;
     friend class clang::ASTWriter;
     friend class clang::ASTReader;
 
     /// The location of the \#include that brought in this file.
     ///
     /// This is an invalid SLOC for the main file (top of the \#include chain).
-    unsigned IncludeLoc;  // Really a SourceLocation
+    PODSourceLocation IncludeLoc;
 
     /// Number of FileIDs (files and macros) that were created during
     /// preprocessing of this \#include, including this SLocEntry.
     ///
     /// Zero means the preprocessor didn't provide such info for this SLocEntry.
     unsigned NumCreatedFIDs : 31;
 
     /// Whether this FileInfo has any \#line directives.
     unsigned HasLineDirectives : 1;
 
     /// The content cache and the characteristic of the file.
     llvm::PointerIntPair<const ContentCache*, 3, CharacteristicKind>
         ContentAndKind;
 
     /// The filename that is used to access the file entry represented by the
     /// content cache.
     StringRef Filename;
 
   public:
     /// Return a FileInfo object.
     static FileInfo get(SourceLocation IL, const ContentCache *Con,
                         CharacteristicKind FileCharacter, StringRef Filename) {
       FileInfo X;
-      X.IncludeLoc = IL.getRawEncoding();
+      X.IncludeLoc = IL.getPOD();
       X.NumCreatedFIDs = 0;
       X.HasLineDirectives = false;
       X.ContentAndKind.setPointer(Con);
       X.ContentAndKind.setInt(FileCharacter);
       X.Filename = Filename;
       return X;
     }
 
     SourceLocation getIncludeLoc() const {
-      return SourceLocation::getFromRawEncoding(IncludeLoc);
+      return SourceLocation::getFromPOD(IncludeLoc);
     }
 
     const ContentCache *getContentCache() const {
       return ContentAndKind.getPointer();
     }
 
     /// Return whether this is a system header or not.
     CharacteristicKind getFileCharacteristic() const {
public:
     /// the underlying file system.
     StringRef getName() const { return Filename; }
   };
 
   /// Each ExpansionInfo encodes the expansion location - where
   /// the token was ultimately expanded, and the SpellingLoc - where the actual
   /// character data for the token came from.
   class ExpansionInfo {
-    // Really these are all SourceLocations.
-
     /// Where the spelling for the token can be found.
-    unsigned SpellingLoc;
+    PODSourceLocation SpellingLoc;
 
     /// In a macro expansion, ExpansionLocStart and ExpansionLocEnd
     /// indicate the start and end of the expansion. In object-like macros,
     /// they will be the same. In a function-like macro expansion, the start
     /// will be the identifier and the end will be the ')'. Finally, in
     /// macro-argument instantiations, the end will be 'SourceLocation()', an
     /// invalid location.
-    unsigned ExpansionLocStart, ExpansionLocEnd;
+    PODSourceLocation ExpansionLocStart, ExpansionLocEnd;
 
     /// Whether the expansion range is a token range.
     bool ExpansionIsTokenRange;
 
   public:
     SourceLocation getSpellingLoc() const {
-      SourceLocation SpellLoc = SourceLocation::getFromRawEncoding(SpellingLoc);
+      SourceLocation SpellLoc = SourceLocation::getFromPOD(SpellingLoc);
       return SpellLoc.isInvalid() ? getExpansionLocStart() : SpellLoc;
     }
 
     SourceLocation getExpansionLocStart() const {
-      return SourceLocation::getFromRawEncoding(ExpansionLocStart);
+      return SourceLocation::getFromPOD(ExpansionLocStart);
     }
 
     SourceLocation getExpansionLocEnd() const {
       SourceLocation EndLoc =
-        SourceLocation::getFromRawEncoding(ExpansionLocEnd);
+        SourceLocation::getFromPOD(ExpansionLocEnd);
       return EndLoc.isInvalid() ? getExpansionLocStart() : EndLoc;
     }
 
     bool isExpansionTokenRange() const {
       return ExpansionIsTokenRange;
     }
 
     CharSourceRange getExpansionLocRange() const {
       return CharSourceRange(
           SourceRange(getExpansionLocStart(), getExpansionLocEnd()),
           isExpansionTokenRange());
     }
 
     bool isMacroArgExpansion() const {
       // Note that this needs to return false for default constructed objects.
       return getExpansionLocStart().isValid() &&
-        SourceLocation::getFromRawEncoding(ExpansionLocEnd).isInvalid();
+        SourceLocation::getFromPOD(ExpansionLocEnd).isInvalid();
     }
 
     bool isMacroBodyExpansion() const {
       return getExpansionLocStart().isValid() &&
-        SourceLocation::getFromRawEncoding(ExpansionLocEnd).isValid();
+        SourceLocation::getFromPOD(ExpansionLocEnd).isValid();
     }
 
     bool isFunctionMacroExpansion() const {
       return getExpansionLocStart().isValid() &&
           getExpansionLocStart() != getExpansionLocEnd();
     }
 
     /// Return a ExpansionInfo for an expansion.
     ///
     /// Start and End specify the expansion range (where the macro is
     /// expanded), and SpellingLoc specifies the spelling location (where
     /// the characters from the token come from). All three can refer to
     /// normal File SLocs or expansion locations.
     static ExpansionInfo create(SourceLocation SpellingLoc,
                                 SourceLocation Start, SourceLocation End,
                                 bool ExpansionIsTokenRange = true) {
       ExpansionInfo X;
-      X.SpellingLoc = SpellingLoc.getRawEncoding();
-      X.ExpansionLocStart = Start.getRawEncoding();
-      X.ExpansionLocEnd = End.getRawEncoding();
+      X.SpellingLoc = SpellingLoc.getPOD();
+      X.ExpansionLocStart = Start.getPOD();
+      X.ExpansionLocEnd = End.getPOD();
       X.ExpansionIsTokenRange = ExpansionIsTokenRange;
       return X;
     }
 
     /// Return a special ExpansionInfo for the expansion of
     /// a macro argument into a function-like macro's body.
     ///
     /// ExpansionLoc specifies the expansion location (where the macro is

clang/include/clang/Lex/Token.h

 /// compressed into a smaller form if memory footprint is important.
 ///
 /// The parser can create a special "annotation token" representing a stream of
 /// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>"
 /// can be represented by a single typename annotation token that carries
 /// information about the SourceRange of the tokens and the type object.
 class Token {
   /// The location of the token. This is actually a SourceLocation.
-  unsigned Loc;
+  PODSourceLocation Loc;
 
   // Conceptually these next two fields could be in a union.  However, this
   // causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical
   // routine. Keeping as separate members with casts until a more beautiful fix
   // presents itself.
 
   /// UintData - This holds either the length of the token text, when
   /// a normal token, or the end of the SourceRange when an annotation
   /// token.
-  unsigned UintData;
+  union {
+    PODSourceLocation Loc;
+    unsigned Len;
+  } UintData;
 
   /// PtrData - This is a union of four different pointer types, which depends
   /// on what type of token this is:
   ///  Identifiers, keywords, etc:
   ///    This is an IdentifierInfo*, which contains the uniqued identifier
   ///    spelling.
   ///  Literals:  isLiteral() returns true.
   ///    This is a pointer to the start of the token in a text buffer, which
public:
   /// Return true if this is any of tok::annot_* kind tokens.
   bool isAnnotation() const {
     return tok::isAnnotation(getKind());
   }
 
   /// Return a source location identifier for the specified
   /// offset in the current file.
   SourceLocation getLocation() const {
-    return SourceLocation::getFromRawEncoding(Loc);
+    return SourceLocation::getFromPOD(Loc);
   }
   unsigned getLength() const {
     assert(!isAnnotation() && "Annotation tokens have no length field");
-    return UintData;
+    return UintData.Len;
   }
 
-  void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
+  void setLocation(SourceLocation L) { Loc = L.getPOD(); }
   void setLength(unsigned Len) {
     assert(!isAnnotation() && "Annotation tokens have no length field");
-    UintData = Len;
+    UintData.Len = Len;
   }
 
   SourceLocation getAnnotationEndLoc() const {
     assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token");
-    return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
+    return SourceLocation::getFromPOD(UintData.Loc.isValid() ? UintData.Loc
+                                                             : Loc);
   }
   void setAnnotationEndLoc(SourceLocation L) {
     assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token");
-    UintData = L.getRawEncoding();
+    UintData.Loc = L.getPOD();
   }
 
   SourceLocation getLastLoc() const {
     return isAnnotation() ? getAnnotationEndLoc() : getLocation();
   }
 
   SourceLocation getEndLoc() const {
     return isAnnotation() ? getAnnotationEndLoc()
public:
 
   const char *getName() const { return tok::getTokenName(Kind); }
 
   /// Reset all flags to cleared.
   void startToken() {
     Kind = tok::unknown;
     Flags = 0;
     PtrData = nullptr;
-    UintData = 0;
-    Loc = SourceLocation().getRawEncoding();
+    UintData.Len = 0;
+    Loc = SourceLocation().getPOD();
   }
 
   IdentifierInfo *getIdentifierInfo() const {
     assert(isNot(tok::raw_identifier) &&
            "getIdentifierInfo() on a tok::raw_identifier token!");
     assert(!isAnnotation() &&
            "getIdentifierInfo() on an annotation token!");
     if (isLiteral()) return nullptr;

clang/include/clang/Sema/DeclSpec.h

struct OFI {
 
     /// The source locations of the individual tokens that name
     /// the operator, e.g., the "new", "[", and "]" tokens in
     /// operator new [].
     ///
     /// Different operators have different numbers of tokens in their name,
     /// up to three. Any remaining source locations in this array will be
     /// set to an invalid value for operators with fewer than three tokens.
-    unsigned SymbolLocations[3];
+    PODSourceLocation SymbolLocations[3];
   };
 
   /// Anonymous union that holds extra data associated with the
   /// parsed unqualified-id.
   union {
     /// When Kind == IK_Identifier, the parsed identifier, or when
     /// Kind == IK_UserLiteralId, the identifier suffix.
     IdentifierInfo *Identifier;
struct DeclaratorChunk {
 
   ParsedAttributesView AttrList;
 
   struct PointerTypeInfo {
     /// The type qualifiers: const/volatile/restrict/unaligned/atomic.
     unsigned TypeQuals : 5;
 
     /// The location of the const-qualifier, if any.
-    unsigned ConstQualLoc;
+    PODSourceLocation ConstQualLoc;
 
     /// The location of the volatile-qualifier, if any.
-    unsigned VolatileQualLoc;
+    PODSourceLocation VolatileQualLoc;
 
     /// The location of the restrict-qualifier, if any.
-    unsigned RestrictQualLoc;
+    PODSourceLocation RestrictQualLoc;
 
     /// The location of the _Atomic-qualifier, if any.
-    unsigned AtomicQualLoc;
+    PODSourceLocation AtomicQualLoc;
 
     /// The location of the __unaligned-qualifier, if any.
-    unsigned UnalignedQualLoc;
+    PODSourceLocation UnalignedQualLoc;
 
     void destroy() {
     }
   };
 
   struct ReferenceTypeInfo {
     /// The type qualifier: restrict. [GNU] C++ extension
     bool HasRestrict : 1;
struct FunctionTypeInfo {
     /// DeleteParams - If this is true, we need to delete[] Params.
     unsigned DeleteParams : 1;
 
     /// HasTrailingReturnType - If this is true, a trailing return type was
     /// specified.
     unsigned HasTrailingReturnType : 1;
 
     /// The location of the left parenthesis in the source.
-    unsigned LParenLoc;
+    PODSourceLocation LParenLoc;
 
     /// When isVariadic is true, the location of the ellipsis in the source.
-    unsigned EllipsisLoc;
+    PODSourceLocation EllipsisLoc;
 
     /// The location of the right parenthesis in the source.
-    unsigned RParenLoc;
+    PODSourceLocation RParenLoc;
 
     /// NumParams - This is the number of formal parameters specified by the
     /// declarator.
     unsigned NumParams;
 
     /// NumExceptionsOrDecls - This is the number of types in the
     /// dynamic-exception-decl, if the function has one. In C, this is the
     /// number of declarations in the function prototype.
     unsigned NumExceptionsOrDecls;
 
     /// The location of the ref-qualifier, if any.
     ///
     /// If this is an invalid location, there is no ref-qualifier.
-    unsigned RefQualifierLoc;
+    PODSourceLocation RefQualifierLoc;
 
     /// The location of the 'mutable' qualifer in a lambda-declarator, if
     /// any.
-    unsigned MutableLoc;
+    PODSourceLocation MutableLoc;
 
     /// The beginning location of the exception specification, if any.
-    unsigned ExceptionSpecLocBeg;
+    PODSourceLocation ExceptionSpecLocBeg;
 
     /// The end location of the exception specification, if any.
-    unsigned ExceptionSpecLocEnd;
+    PODSourceLocation ExceptionSpecLocEnd;
 
     /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
     /// describe the parameters specified by this function declarator.  null if
     /// there are no parameters specified.
     ParamInfo *Params;
 
     /// DeclSpec for the function with the qualifier related info.
     DeclSpec *MethodQualifiers;
struct FunctionTypeInfo {
     }
 
     /// isKNRPrototype - Return true if this is a K&R style identifier list,
     /// like "void foo(a,b,c)".  In a function definition, this will be followed
     /// by the parameter type definitions.
     bool isKNRPrototype() const { return !hasPrototype && NumParams != 0; }
 
     SourceLocation getLParenLoc() const {
-      return SourceLocation::getFromRawEncoding(LParenLoc);
+      return SourceLocation::getFromPOD(LParenLoc);
     }
 
     SourceLocation getEllipsisLoc() const {
-      return SourceLocation::getFromRawEncoding(EllipsisLoc);
+      return SourceLocation::getFromPOD(EllipsisLoc);
     }
 
     SourceLocation getRParenLoc() const {
-      return SourceLocation::getFromRawEncoding(RParenLoc);
+      return SourceLocation::getFromPOD(RParenLoc);
     }
 
     SourceLocation getExceptionSpecLocBeg() const {
-      return SourceLocation::getFromRawEncoding(ExceptionSpecLocBeg);
+      return SourceLocation::getFromPOD(ExceptionSpecLocBeg);
     }
 
     SourceLocation getExceptionSpecLocEnd() const {
-      return SourceLocation::getFromRawEncoding(ExceptionSpecLocEnd);
+      return SourceLocation::getFromPOD(ExceptionSpecLocEnd);
     }
 
     SourceRange getExceptionSpecRange() const {
       return SourceRange(getExceptionSpecLocBeg(), getExceptionSpecLocEnd());
     }
 
     /// Retrieve the location of the ref-qualifier, if any.
     SourceLocation getRefQualifierLoc() const {
-      return SourceLocation::getFromRawEncoding(RefQualifierLoc);
+      return SourceLocation::getFromPOD(RefQualifierLoc);
     }
 
     /// Retrieve the location of the 'const' qualifier.
     SourceLocation getConstQualifierLoc() const {
       assert(MethodQualifiers);
       return MethodQualifiers->getConstSpecLoc();
     }
 
     /// Retrieve the location of the 'volatile' qualifier.
     SourceLocation getVolatileQualifierLoc() const {
       assert(MethodQualifiers);
       return MethodQualifiers->getVolatileSpecLoc();
     }
 
     /// Retrieve the location of the 'restrict' qualifier.
     SourceLocation getRestrictQualifierLoc() const {
       assert(MethodQualifiers);
       return MethodQualifiers->getRestrictSpecLoc();
     }
 
     /// Retrieve the location of the 'mutable' qualifier, if any.
     SourceLocation getMutableLoc() const {
-      return SourceLocation::getFromRawEncoding(MutableLoc);
+      return SourceLocation::getFromPOD(MutableLoc);
     }
 
     /// Determine whether this function declaration contains a
     /// ref-qualifier.
     bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
 
     /// Determine whether this lambda-declarator contains a 'mutable'
     /// qualifier.
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
                                     SourceLocation VolatileQualLoc,
                                     SourceLocation RestrictQualLoc,
                                     SourceLocation AtomicQualLoc,
                                     SourceLocation UnalignedQualLoc) {
     DeclaratorChunk I;
     I.Kind                = Pointer;
     I.Loc                 = Loc;
     I.Ptr.TypeQuals       = TypeQuals;
-    I.Ptr.ConstQualLoc    = ConstQualLoc.getRawEncoding();
-    I.Ptr.VolatileQualLoc = VolatileQualLoc.getRawEncoding();
-    I.Ptr.RestrictQualLoc = RestrictQualLoc.getRawEncoding();
-    I.Ptr.AtomicQualLoc   = AtomicQualLoc.getRawEncoding();
-    I.Ptr.UnalignedQualLoc = UnalignedQualLoc.getRawEncoding();
+    I.Ptr.ConstQualLoc    = ConstQualLoc.getPOD();
+    I.Ptr.VolatileQualLoc = VolatileQualLoc.getPOD();
+    I.Ptr.RestrictQualLoc = RestrictQualLoc.getPOD();
+    I.Ptr.AtomicQualLoc   = AtomicQualLoc.getPOD();
+    I.Ptr.UnalignedQualLoc = UnalignedQualLoc.getPOD();
     return I;
   }
 
   /// Return a DeclaratorChunk for a reference.
   static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
                                       bool lvalue) {
     DeclaratorChunk I;
     I.Kind            = Reference;

clang/include/clang/Sema/Designator.h

public:
   enum DesignatorKind {
     FieldDesignator, ArrayDesignator, ArrayRangeDesignator
   };
 private:
   DesignatorKind Kind;
 
   struct FieldDesignatorInfo {
     const IdentifierInfo *II;
-    unsigned DotLoc;
-    unsigned NameLoc;
+    PODSourceLocation DotLoc;
+    PODSourceLocation NameLoc;
   };
   struct ArrayDesignatorInfo {
     Expr *Index;
-    unsigned LBracketLoc;
-    mutable unsigned  RBracketLoc;
+    PODSourceLocation LBracketLoc;
+    mutable PODSourceLocation RBracketLoc;
   };
   struct ArrayRangeDesignatorInfo {
     Expr *Start, *End;
-    unsigned LBracketLoc, EllipsisLoc;
-    mutable unsigned RBracketLoc;
+    PODSourceLocation LBracketLoc, EllipsisLoc;
+    mutable PODSourceLocation RBracketLoc;
   };
 
   union {
     FieldDesignatorInfo FieldInfo;
     ArrayDesignatorInfo ArrayInfo;
     ArrayRangeDesignatorInfo ArrayRangeInfo;
   };
 
 public:
 
   DesignatorKind getKind() const { return Kind; }
   bool isFieldDesignator() const { return Kind == FieldDesignator; }
   bool isArrayDesignator() const { return Kind == ArrayDesignator; }
   bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
 
   const IdentifierInfo *getField() const {
     assert(isFieldDesignator() && "Invalid accessor");
     return FieldInfo.II;
   }
 
   SourceLocation getDotLoc() const {
     assert(isFieldDesignator() && "Invalid accessor");
-    return SourceLocation::getFromRawEncoding(FieldInfo.DotLoc);
+    return SourceLocation::getFromPOD(FieldInfo.DotLoc);
   }
 
   SourceLocation getFieldLoc() const {
     assert(isFieldDesignator() && "Invalid accessor");
-    return SourceLocation::getFromRawEncoding(FieldInfo.NameLoc);
+    return SourceLocation::getFromPOD(FieldInfo.NameLoc);
   }
 
   Expr *getArrayIndex() const {
     assert(isArrayDesignator() && "Invalid accessor");
     return ArrayInfo.Index;
   }
 
   Expr *getArrayRangeStart() const {
     assert(isArrayRangeDesignator() && "Invalid accessor");
     return ArrayRangeInfo.Start;
   }
   Expr *getArrayRangeEnd() const {
     assert(isArrayRangeDesignator() && "Invalid accessor");
     return ArrayRangeInfo.End;
   }
 
   SourceLocation getLBracketLoc() const {
     assert((isArrayDesignator() || isArrayRangeDesignator()) &&
            "Invalid accessor");
     if (isArrayDesignator())
-      return SourceLocation::getFromRawEncoding(ArrayInfo.LBracketLoc);
+      return SourceLocation::getFromPOD(ArrayInfo.LBracketLoc);
     else
-      return SourceLocation::getFromRawEncoding(ArrayRangeInfo.LBracketLoc);
+      return SourceLocation::getFromPOD(ArrayRangeInfo.LBracketLoc);
   }
 
   SourceLocation getRBracketLoc() const {
     assert((isArrayDesignator() || isArrayRangeDesignator()) &&
            "Invalid accessor");
     if (isArrayDesignator())
-      return SourceLocation::getFromRawEncoding(ArrayInfo.RBracketLoc);
+      return SourceLocation::getFromPOD(ArrayInfo.RBracketLoc);
     else
-      return SourceLocation::getFromRawEncoding(ArrayRangeInfo.RBracketLoc);
+      return SourceLocation::getFromPOD(ArrayRangeInfo.RBracketLoc);
   }
 
   SourceLocation getEllipsisLoc() const {
     assert(isArrayRangeDesignator() && "Invalid accessor");
-    return SourceLocation::getFromRawEncoding(ArrayRangeInfo.EllipsisLoc);
+    return SourceLocation::getFromPOD(ArrayRangeInfo.EllipsisLoc);
   }
 
   static Designator getField(const IdentifierInfo *II, SourceLocation DotLoc,
                              SourceLocation NameLoc) {
     Designator D;
     D.Kind = FieldDesignator;
     D.FieldInfo.II = II;
-    D.FieldInfo.DotLoc = DotLoc.getRawEncoding();
-    D.FieldInfo.NameLoc = NameLoc.getRawEncoding();
+    D.FieldInfo.DotLoc = DotLoc.getPOD();
+    D.FieldInfo.NameLoc = NameLoc.getPOD();
     return D;
   }
 
   static Designator getArray(Expr *Index,
                              SourceLocation LBracketLoc) {
     Designator D;
     D.Kind = ArrayDesignator;
     D.ArrayInfo.Index = Index;
-    D.ArrayInfo.LBracketLoc = LBracketLoc.getRawEncoding();
-    D.ArrayInfo.RBracketLoc = 0;
+    D.ArrayInfo.LBracketLoc = LBracketLoc.getPOD();
+    D.ArrayInfo.RBracketLoc.clear();
     return D;
   }
 
   static Designator getArrayRange(Expr *Start,
                                   Expr *End,
                                   SourceLocation LBracketLoc,
                                   SourceLocation EllipsisLoc) {
     Designator D;
     D.Kind = ArrayRangeDesignator;
     D.ArrayRangeInfo.Start = Start;
     D.ArrayRangeInfo.End = End;
-    D.ArrayRangeInfo.LBracketLoc = LBracketLoc.getRawEncoding();
-    D.ArrayRangeInfo.EllipsisLoc = EllipsisLoc.getRawEncoding();
-    D.ArrayRangeInfo.RBracketLoc = 0;
+    D.ArrayRangeInfo.LBracketLoc = LBracketLoc.getPOD();
+    D.ArrayRangeInfo.EllipsisLoc = EllipsisLoc.getPOD();
+    D.ArrayRangeInfo.RBracketLoc.clear();
     return D;
   }
 
   void setRBracketLoc(SourceLocation RBracketLoc) const {
     assert((isArrayDesignator() || isArrayRangeDesignator()) &&
            "Invalid accessor");
     if (isArrayDesignator())
-      ArrayInfo.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayInfo.RBracketLoc = RBracketLoc.getPOD();
     else
-      ArrayRangeInfo.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayRangeInfo.RBracketLoc = RBracketLoc.getPOD();
   }
 
   /// ClearExprs - Null out any expression references, which prevents
   /// them from being 'delete'd later.
   void ClearExprs(Sema &Actions) {}
 
   /// FreeExprs - Release any unclaimed memory for the expressions in
   /// this designator.

clang/include/clang/Sema/Initialization.h

private:
   /// The mangling number for the next reference temporary to be created.
   mutable unsigned ManglingNumber = 0;
 
   struct LN {
     /// When Kind == EK_Result, EK_Exception, EK_New, the
     /// location of the 'return', 'throw', or 'new' keyword,
     /// respectively. When Kind == EK_Temporary, the location where
     /// the temporary is being created.
-    unsigned Location;
+    PODSourceLocation Location;
 
     /// Whether the entity being initialized may end up using the
     /// named return value optimization (NRVO).
     bool NRVO;
   };
 
   struct VD {
     /// The VarDecl, FieldDecl, or BindingDecl being initialized.
struct VD {
     bool IsDefaultMemberInit;
   };
 
   struct C {
     /// The name of the variable being captured by an EK_LambdaCapture.
     IdentifierInfo *VarID;
 
     /// The source location at which the capture occurs.
-    unsigned Location;
+    PODSourceLocation Location;
   };
 
   union {
     /// When Kind == EK_Variable, EK_Member or EK_Binding, the variable.
     VD Variable;
 
     /// When Kind == EK_RelatedResult, the ObjectiveC method where
     /// result type was implicitly changed to accommodate ARC semantics.
InitializedEntity(VarDecl *Var, EntityKind EK = EK_Variable)
       : Kind(EK), Type(Var->getType()), Variable{Var, false, false} {}
 
   /// Create the initialization entity for the result of a
   /// function, throwing an object, performing an explicit cast, or
   /// initializing a parameter for which there is no declaration.
   InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type,
                     bool NRVO = false)
       : Kind(Kind), Type(Type) {
-    LocAndNRVO.Location = Loc.getRawEncoding();
+    LocAndNRVO.Location = Loc.getPOD();
     LocAndNRVO.NRVO = NRVO;
   }
 
   /// Create the initialization entity for a member subobject.
   InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent,
                     bool Implicit, bool DefaultMemberInit)
       : Kind(EK_Member), Parent(Parent), Type(Member->getType()),
         Variable{Member, Implicit, DefaultMemberInit} {}
 
   /// Create the initialization entity for an array element.
   InitializedEntity(ASTContext &Context, unsigned Index,
                     const InitializedEntity &Parent);
 
   /// Create the initialization entity for a lambda capture.
   InitializedEntity(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc)
       : Kind(EK_LambdaCapture), Type(FieldType) {
     Capture.VarID = VarID;
-    Capture.Location = Loc.getRawEncoding();
+    Capture.Location = Loc.getPOD();
   }
 
 public:
   /// Create the initialization entity for a variable.
   static InitializedEntity InitializeVariable(VarDecl *Var) {
     return InitializedEntity(Var);
   }
 
public:
   bool isDefaultMemberInitializer() const {
     return getKind() == EK_Member && Variable.IsDefaultMemberInit;
   }
 
   /// Determine the location of the 'return' keyword when initializing
   /// the result of a function call.
   SourceLocation getReturnLoc() const {
     assert(getKind() == EK_Result && "No 'return' location!");
-    return SourceLocation::getFromRawEncoding(LocAndNRVO.Location);
+    return SourceLocation::getFromPOD(LocAndNRVO.Location);
   }
 
   /// Determine the location of the 'throw' keyword when initializing
   /// an exception object.
   SourceLocation getThrowLoc() const {
     assert(getKind() == EK_Exception && "No 'throw' location!");
-    return SourceLocation::getFromRawEncoding(LocAndNRVO.Location);
+    return SourceLocation::getFromPOD(LocAndNRVO.Location);
   }
 
   /// If this is an array, vector, or complex number element, get the
   /// element's index.
   unsigned getElementIndex() const {
     assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement ||
            getKind() == EK_ComplexElement);
     return Index;
StringRef getCapturedVarName() const {
     assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
     return Capture.VarID ? Capture.VarID->getName() : "this";
   }
 
   /// Determine the location of the capture when initializing
   /// field from a captured variable in a lambda.
   SourceLocation getCaptureLoc() const {
     assert(getKind() == EK_LambdaCapture && "Not a lambda capture!");
-    return SourceLocation::getFromRawEncoding(Capture.Location);
+    return SourceLocation::getFromPOD(Capture.Location);
   }
 
   void setParameterCFAudited() {
     Kind = EK_Parameter_CF_Audited;
   }
 
   unsigned allocateManglingNumber() const { return ++ManglingNumber; }
 

clang/include/clang/Serialization/ASTBitCodes.h

namespace serialization {
     /// An ID number that refers to a submodule in a module file.
     using SubmoduleID = uint32_t;
 
     /// The number of predefined submodule IDs.
     const unsigned int NUM_PREDEF_SUBMODULE_IDS = 1;
 
     /// Source range/offset of a preprocessed entity.
     struct PPEntityOffset {
-      /// Raw source location of beginning of range.
-      unsigned Begin;
+      /// Source location of beginning of range.
+      PODSourceLocation Begin;
 
-      /// Raw source location of end of range.
-      unsigned End;
+      /// Source location of end of range.
+      PODSourceLocation End;
 
       /// Offset in the AST file.
       uint32_t BitOffset;
 
       PPEntityOffset(SourceRange R, uint32_t BitOffset)
-        : Begin(R.getBegin().getRawEncoding()),
-          End(R.getEnd().getRawEncoding()), BitOffset(BitOffset) {}
+        : Begin(R.getBegin().getPOD()),
+          End(R.getEnd().getPOD()), BitOffset(BitOffset) {}
 
       SourceLocation getBegin() const {
-        return SourceLocation::getFromRawEncoding(Begin);
+        return SourceLocation::getFromPOD(Begin);
       }
 
       SourceLocation getEnd() const {
-        return SourceLocation::getFromRawEncoding(End);
+        return SourceLocation::getFromPOD(End);
       }
     };
 
     /// Source range of a skipped preprocessor region
     struct PPSkippedRange {
-      /// Raw source location of beginning of range.
-      unsigned Begin;
-      /// Raw source location of end of range.
-      unsigned End;
+      /// Source location of beginning of range.
+      PODSourceLocation Begin;
+      /// Source location of end of range.
+      PODSourceLocation End;
 
       PPSkippedRange(SourceRange R)
-        : Begin(R.getBegin().getRawEncoding()),
-          End(R.getEnd().getRawEncoding()) { }
+        : Begin(R.getBegin().getPOD()),
+          End(R.getEnd().getPOD()) { }
 
       SourceLocation getBegin() const {
-        return SourceLocation::getFromRawEncoding(Begin);
+        return SourceLocation::getFromPOD(Begin);
       }
       SourceLocation getEnd() const {
-        return SourceLocation::getFromRawEncoding(End);
+        return SourceLocation::getFromPOD(End);
       }
     };
 
     /// Source range/offset of a preprocessed entity.
     struct DeclOffset {
-      /// Raw source location.
-      unsigned Loc = 0;
+      /// Source location.
+      PODSourceLocation Loc = {};
 
       /// Offset in the AST file.
       uint32_t BitOffset = 0;
 
       DeclOffset() = default;
       DeclOffset(SourceLocation Loc, uint32_t BitOffset)
-        : Loc(Loc.getRawEncoding()), BitOffset(BitOffset) {}
+        : Loc(Loc.getPOD()), BitOffset(BitOffset) {}
 
       void setLocation(SourceLocation L) {
-        Loc = L.getRawEncoding();
+        Loc = L.getPOD();
       }
 
       SourceLocation getLocation() const {
-        return SourceLocation::getFromRawEncoding(Loc);
+        return SourceLocation::getFromPOD(Loc);
       }
     };
 
     /// The number of predefined preprocessed entity IDs.
     const unsigned int NUM_PREDEF_PP_ENTITY_IDS = 1;
 
     /// Describes the various kinds of blocks that occur within
     /// an AST file.

clang/lib/AST/ASTContext.cpp

case TemplateName::DependentTemplate: {
     DeclarationName DName;
     if (DTN->isIdentifier()) {
       DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
       return DeclarationNameInfo(DName, NameLoc);
     } else {
       DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
       // DNInfo work in progress: FIXME: source locations?
       DeclarationNameLoc DNLoc;
-      DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
-      DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
+      DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getPOD();
+      DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getPOD();
       return DeclarationNameInfo(DName, NameLoc, DNLoc);
     }
   }
 
   case TemplateName::SubstTemplateTemplateParm: {
     SubstTemplateTemplateParmStorage *subst
       = Name.getAsSubstTemplateTemplateParm();
     return DeclarationNameInfo(subst->getParameter()->getDeclName(),

clang/lib/AST/DeclObjC.cpp

 
 //===----------------------------------------------------------------------===//
 // ObjCTypeParamList
 //===----------------------------------------------------------------------===//
 ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
                                      ArrayRef<ObjCTypeParamDecl *> typeParams,
                                      SourceLocation rAngleLoc)
     : NumParams(typeParams.size()) {
-  Brackets.Begin = lAngleLoc.getRawEncoding();
-  Brackets.End = rAngleLoc.getRawEncoding();
+  Brackets.Begin = lAngleLoc.getPOD();
+  Brackets.End = rAngleLoc.getPOD();
   std::copy(typeParams.begin(), typeParams.end(), begin());
 }
 
 ObjCTypeParamList *ObjCTypeParamList::create(
                      ASTContext &ctx,
                      SourceLocation lAngleLoc,
                      ArrayRef<ObjCTypeParamDecl *> typeParams,
                      SourceLocation rAngleLoc) {

clang/lib/AST/DeclarationName.cpp

DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
   case DeclarationName::CXXDeductionGuideName:
     break;
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
     NamedType.TInfo = nullptr;
     break;
   case DeclarationName::CXXOperatorName:
-    CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
-    CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
+    CXXOperatorName.BeginOpNameLoc = SourceLocation().getPOD();
+    CXXOperatorName.EndOpNameLoc = SourceLocation().getPOD();
     break;
   case DeclarationName::CXXLiteralOperatorName:
-    CXXLiteralOperatorName.OpNameLoc = SourceLocation().getRawEncoding();
+    CXXLiteralOperatorName.OpNameLoc = SourceLocation().getPOD();
     break;
   case DeclarationName::ObjCZeroArgSelector:
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector:
     // FIXME: ?
     break;
   case DeclarationName::CXXUsingDirective:
     break;

 
 SourceLocation DeclarationNameInfo::getEndLocPrivate() const {
   switch (Name.getNameKind()) {
   case DeclarationName::Identifier:
   case DeclarationName::CXXDeductionGuideName:
     return NameLoc;
 
   case DeclarationName::CXXOperatorName: {
-    unsigned raw = LocInfo.CXXOperatorName.EndOpNameLoc;
-    return SourceLocation::getFromRawEncoding(raw);
+    PODSourceLocation raw = LocInfo.CXXOperatorName.EndOpNameLoc;
+    return SourceLocation::getFromPOD(raw);
   }
 
   case DeclarationName::CXXLiteralOperatorName: {
-    unsigned raw = LocInfo.CXXLiteralOperatorName.OpNameLoc;
-    return SourceLocation::getFromRawEncoding(raw);
+    PODSourceLocation raw = LocInfo.CXXLiteralOperatorName.OpNameLoc;
+    return SourceLocation::getFromPOD(raw);
   }
 
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
     if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
       return TInfo->getTypeLoc().getEndLoc();
     else

clang/lib/AST/Expr.cpp

 }
 
 SourceLocation DesignatedInitExpr::getBeginLoc() const {
   SourceLocation StartLoc;
   auto *DIE = const_cast<DesignatedInitExpr *>(this);
   Designator &First = *DIE->getDesignator(0);
   if (First.isFieldDesignator()) {
     if (GNUSyntax)
-      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
+      StartLoc = SourceLocation::getFromPOD(First.Field.FieldLoc);
     else
-      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
+      StartLoc = SourceLocation::getFromPOD(First.Field.DotLoc);
   } else
     StartLoc =
-      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
+      SourceLocation::getFromPOD(First.ArrayOrRange.LBracketLoc);
   return StartLoc;
 }
 
 SourceLocation DesignatedInitExpr::getEndLoc() const {
   return getInit()->getEndLoc();
 }
 
 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {

clang/lib/AST/NestedNameSpecifier.cpp

NestedNameSpecifierLoc::getDataLength(NestedNameSpecifier *Qualifier) {
   for (; Qualifier; Qualifier = Qualifier->getPrefix())
     Length += getLocalDataLength(Qualifier);
   return Length;
 }
 
 /// Load a (possibly unaligned) source location from a given address
 /// and offset.
 static SourceLocation LoadSourceLocation(void *Data, unsigned Offset) {
-  unsigned Raw;
-  memcpy(&Raw, static_cast<char *>(Data) + Offset, sizeof(unsigned));
-  return SourceLocation::getFromRawEncoding(Raw);
+  PODSourceLocation Raw;
+  memcpy(&Raw, static_cast<char *>(Data) + Offset, sizeof(PODSourceLocation));
+  return SourceLocation::getFromPOD(Raw);
 }
 
 /// Load a (possibly unaligned) pointer from a given address and
 /// offset.
 static void *LoadPointer(void *Data, unsigned Offset) {
   void *Result;
   memcpy(&Result, static_cast<char *>(Data) + Offset, sizeof(void*));
   return Result;
static void Append(char *Start, char *End, char *&Buffer, unsigned &BufferSize,
 
   memcpy(Buffer + BufferSize, Start, End - Start);
   BufferSize += End-Start;
 }
 
 /// Save a source location to the given buffer.
 static void SaveSourceLocation(SourceLocation Loc, char *&Buffer,
                                unsigned &BufferSize, unsigned &BufferCapacity) {
-  unsigned Raw = Loc.getRawEncoding();
+  PODSourceLocation Raw = Loc.getPOD();
   Append(reinterpret_cast<char *>(&Raw),
-         reinterpret_cast<char *>(&Raw) + sizeof(unsigned),
+         reinterpret_cast<char *>(&Raw) + sizeof(PODSourceLocation),
          Buffer, BufferSize, BufferCapacity);
 }
 
 /// Save a pointer to the given buffer.
 static void SavePointer(void *Ptr, char *&Buffer, unsigned &BufferSize,
                         unsigned &BufferCapacity) {
   Append(reinterpret_cast<char *>(&Ptr),
          reinterpret_cast<char *>(&Ptr) + sizeof(void *),

clang/lib/Lex/ModuleMap.cpp

enum TokenKind {
       IntegerLiteral,
       TextualKeyword,
       LBrace,
       RBrace,
       LSquare,
       RSquare
     } Kind;
 
-    unsigned Location;
+    PODSourceLocation Location;
     unsigned StringLength;
     union {
       // If Kind != IntegerLiteral.
       const char *StringData;
 
       // If Kind == IntegerLiteral.
       uint64_t IntegerValue;
     };
 
     void clear() {
       Kind = EndOfFile;
-      Location = 0;
+      Location.clear();
       StringLength = 0;
       StringData = nullptr;
     }
 
     bool is(TokenKind K) const { return Kind == K; }
 
     SourceLocation getLocation() const {
-      return SourceLocation::getFromRawEncoding(Location);
+      return SourceLocation::getFromPOD(Location);
     }
 
     uint64_t getInteger() const {
       return Kind == IntegerLiteral ? IntegerValue : 0;
     }
 
     StringRef getString() const {
       return Kind == IntegerLiteral ? StringRef()

 
 SourceLocation ModuleMapParser::consumeToken() {
   SourceLocation Result = Tok.getLocation();
 
 retry:
   Tok.clear();
   Token LToken;
   L.LexFromRawLexer(LToken);
-  Tok.Location = LToken.getLocation().getRawEncoding();
+  Tok.Location = LToken.getLocation().getPOD();
   switch (LToken.getKind()) {
   case tok::raw_identifier: {
     StringRef RI = LToken.getRawIdentifier();
     Tok.StringData = RI.data();
     Tok.StringLength = RI.size();
     Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(RI)
                  .Case("config_macros", MMToken::ConfigMacros)
                  .Case("conflict", MMToken::Conflict)

clang/lib/Parse/ParseDeclCXX.cpp

if (D.isFunctionDeclarator()) {
 
     // Parse ref-qualifiers.
     bool RefQualifierIsLValueRef = true;
     SourceLocation RefQualifierLoc;
     if (ParseRefQualifier(RefQualifierIsLValueRef, RefQualifierLoc)) {
       const char *Name = (RefQualifierIsLValueRef ? "& " : "&& ");
       FixItHint Insertion = FixItHint::CreateInsertion(VS.getFirstLocation(), Name);
       Function.RefQualifierIsLValueRef = RefQualifierIsLValueRef;
-      Function.RefQualifierLoc = RefQualifierLoc.getRawEncoding();
+      Function.RefQualifierLoc = RefQualifierLoc.getPOD();
 
       Diag(RefQualifierLoc, diag::err_declspec_after_virtspec)
         << (RefQualifierIsLValueRef ? "&" : "&&")
         << VirtSpecifiers::getSpecifierName(VS.getLastSpecifier())
         << FixItHint::CreateRemoval(RefQualifierLoc)
         << Insertion;
       D.SetRangeEnd(RefQualifierLoc);
     }

clang/lib/Sema/DeclSpec.cpp

DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
 
   DeclaratorChunk I;
   I.Kind                        = Function;
   I.Loc                         = LocalRangeBegin;
   I.EndLoc                      = LocalRangeEnd;
   I.Fun.hasPrototype            = hasProto;
   I.Fun.isVariadic              = EllipsisLoc.isValid();
   I.Fun.isAmbiguous             = isAmbiguous;
-  I.Fun.LParenLoc               = LParenLoc.getRawEncoding();
-  I.Fun.EllipsisLoc             = EllipsisLoc.getRawEncoding();
-  I.Fun.RParenLoc               = RParenLoc.getRawEncoding();
+  I.Fun.LParenLoc               = LParenLoc.getPOD();
+  I.Fun.EllipsisLoc             = EllipsisLoc.getPOD();
+  I.Fun.RParenLoc               = RParenLoc.getPOD();
   I.Fun.DeleteParams            = false;
   I.Fun.NumParams               = NumParams;
   I.Fun.Params                  = nullptr;
   I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
-  I.Fun.RefQualifierLoc         = RefQualifierLoc.getRawEncoding();
-  I.Fun.MutableLoc              = MutableLoc.getRawEncoding();
+  I.Fun.RefQualifierLoc         = RefQualifierLoc.getPOD();
+  I.Fun.MutableLoc              = MutableLoc.getPOD();
   I.Fun.ExceptionSpecType       = ESpecType;
-  I.Fun.ExceptionSpecLocBeg     = ESpecRange.getBegin().getRawEncoding();
-  I.Fun.ExceptionSpecLocEnd     = ESpecRange.getEnd().getRawEncoding();
+  I.Fun.ExceptionSpecLocBeg     = ESpecRange.getBegin().getPOD();
+  I.Fun.ExceptionSpecLocEnd     = ESpecRange.getEnd().getPOD();
   I.Fun.NumExceptionsOrDecls    = 0;
   I.Fun.Exceptions              = nullptr;
   I.Fun.NoexceptExpr            = nullptr;
   I.Fun.HasTrailingReturnType   = TrailingReturnType.isUsable() ||
                                   TrailingReturnType.isInvalid();
   I.Fun.TrailingReturnType      = TrailingReturnType.get();
   I.Fun.MethodQualifiers        = nullptr;
   I.Fun.QualAttrFactory         = nullptr;

 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc,
                                           OverloadedOperatorKind Op,
                                           SourceLocation SymbolLocations[3]) {
   Kind = UnqualifiedIdKind::IK_OperatorFunctionId;
   StartLocation = OperatorLoc;
   EndLocation = OperatorLoc;
   OperatorFunctionId.Operator = Op;
   for (unsigned I = 0; I != 3; ++I) {
-    OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding();
+    OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getPOD();
 
     if (SymbolLocations[I].isValid())
       EndLocation = SymbolLocations[I];
   }
 }
 
 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc,
                                   const char *&PrevSpec) {

clang/lib/Sema/SemaDecl.cpp

case LookupResult::Ambiguous:
     }
 
     // Look to see if we have a type anywhere in the list of results.
     for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
          Res != ResEnd; ++Res) {
       if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res) ||
           (AllowDeducedTemplate && getAsTypeTemplateDecl(*Res))) {
         if (!IIDecl ||
-            (*Res)->getLocation().getRawEncoding() <
-              IIDecl->getLocation().getRawEncoding())
+            (*Res)->getLocation().getPOD() <
+              IIDecl->getLocation().getPOD())
           IIDecl = *Res;
       }
     }
 
     if (!IIDecl) {
       // None of the entities we found is a type, so there is no way
       // to even assume that the result is a type. In this case, don't
       // complain about the ambiguity. The parser will either try to
Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
   }
 
   case UnqualifiedIdKind::IK_OperatorFunctionId:
     NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
                                            Name.OperatorFunctionId.Operator));
     NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
       = Name.OperatorFunctionId.SymbolLocations[0];
     NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
-      = Name.EndLocation.getRawEncoding();
+      = Name.EndLocation.getPOD();
     return NameInfo;
 
   case UnqualifiedIdKind::IK_LiteralOperatorId:
     NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
                                                            Name.Identifier));
     NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
     return NameInfo;
 

clang/lib/Sema/SemaLambda.cpp

CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
   //   The closure type for a lambda-expression has a public inline function
   //   call operator (13.5.4) whose parameters and return type are described by
   //   the lambda-expression's parameter-declaration-clause and
   //   trailing-return-type respectively.
   DeclarationName MethodName
     = Context.DeclarationNames.getCXXOperatorName(OO_Call);
   DeclarationNameLoc MethodNameLoc;
   MethodNameLoc.CXXOperatorName.BeginOpNameLoc
-    = IntroducerRange.getBegin().getRawEncoding();
+    = IntroducerRange.getBegin().getPOD();
   MethodNameLoc.CXXOperatorName.EndOpNameLoc
-    = IntroducerRange.getEnd().getRawEncoding();
+    = IntroducerRange.getEnd().getPOD();
   CXXMethodDecl *Method = CXXMethodDecl::Create(
       Context, Class, EndLoc,
       DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
                           MethodNameLoc),
       MethodType, MethodTypeInfo, SC_None,
       /*isInline=*/true, ConstexprKind, EndLoc);
   Method->setAccess(AS_public);
   if (!TemplateParams)

clang/lib/Sema/SemaType.cpp

case DeclaratorChunk::Paren:
       continue;
 
     case DeclaratorChunk::Pointer: {
       DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr;
       S.diagnoseIgnoredQualifiers(
           diag::warn_qual_return_type,
           PTI.TypeQuals,
           SourceLocation(),
-          SourceLocation::getFromRawEncoding(PTI.ConstQualLoc),
-          SourceLocation::getFromRawEncoding(PTI.VolatileQualLoc),
-          SourceLocation::getFromRawEncoding(PTI.RestrictQualLoc),
-          SourceLocation::getFromRawEncoding(PTI.AtomicQualLoc),
-          SourceLocation::getFromRawEncoding(PTI.UnalignedQualLoc));
+          SourceLocation::getFromPOD(PTI.ConstQualLoc),
+          SourceLocation::getFromPOD(PTI.VolatileQualLoc),
+          SourceLocation::getFromPOD(PTI.RestrictQualLoc),
+          SourceLocation::getFromPOD(PTI.AtomicQualLoc),
+          SourceLocation::getFromPOD(PTI.UnalignedQualLoc));
       return;
     }
 
     case DeclaratorChunk::Function:
     case DeclaratorChunk::BlockPointer:
     case DeclaratorChunk::Reference:
     case DeclaratorChunk::Array:
     case DeclaratorChunk::MemberPointer:
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) {
   switch (Chunk.Kind) {
   case DeclaratorChunk::Function:
   case DeclaratorChunk::Array:
   case DeclaratorChunk::Paren:
   case DeclaratorChunk::Pipe:
     llvm_unreachable("cannot be _Atomic qualified");
 
   case DeclaratorChunk::Pointer:
-    Loc = SourceLocation::getFromRawEncoding(Chunk.Ptr.AtomicQualLoc);
+    Loc = SourceLocation::getFromPOD(Chunk.Ptr.AtomicQualLoc);
     break;
 
   case DeclaratorChunk::BlockPointer:
   case DeclaratorChunk::Reference:
   case DeclaratorChunk::MemberPointer:
     // FIXME: Provide a source location for the _Atomic keyword.
     break;
   }

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
   }
 
   if (Op == OO_Subscript) {
     SourceLocation LBrace;
     SourceLocation RBrace;
 
     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
         DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
-        LBrace = SourceLocation::getFromRawEncoding(
+        LBrace = SourceLocation::getFromPOD(
                     NameLoc.CXXOperatorName.BeginOpNameLoc);
-        RBrace = SourceLocation::getFromRawEncoding(
+        RBrace = SourceLocation::getFromPOD(
                     NameLoc.CXXOperatorName.EndOpNameLoc);
     } else {
       LBrace = Callee->getBeginLoc();
       RBrace = OpLoc;
     }
 
     return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
                                                       First, Second);

clang/lib/Serialization/ASTReader.cpp

void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
     DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
     break;
 
   case DeclarationName::CXXOperatorName:
     DNLoc.CXXOperatorName.BeginOpNameLoc
-        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
+        = ReadSourceLocation(F, Record, Idx).getPOD();
     DNLoc.CXXOperatorName.EndOpNameLoc
-        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
+        = ReadSourceLocation(F, Record, Idx).getPOD();
     break;
 
   case DeclarationName::CXXLiteralOperatorName:
     DNLoc.CXXLiteralOperatorName.OpNameLoc
-        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
+        = ReadSourceLocation(F, Record, Idx).getPOD();
     break;
 
   case DeclarationName::Identifier:
   case DeclarationName::ObjCZeroArgSelector:
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector:
   case DeclarationName::CXXUsingDirective:
   case DeclarationName::CXXDeductionGuideName:

clang/lib/Serialization/ASTWriter.cpp

void ASTRecordWriter::AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
   switch (Name.getNameKind()) {
   case DeclarationName::CXXConstructorName:
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
     AddTypeSourceInfo(DNLoc.NamedType.TInfo);
     break;
 
   case DeclarationName::CXXOperatorName:
-    AddSourceLocation(SourceLocation::getFromRawEncoding(
+    AddSourceLocation(SourceLocation::getFromPOD(
         DNLoc.CXXOperatorName.BeginOpNameLoc));
     AddSourceLocation(
-        SourceLocation::getFromRawEncoding(DNLoc.CXXOperatorName.EndOpNameLoc));
+        SourceLocation::getFromPOD(DNLoc.CXXOperatorName.EndOpNameLoc));
     break;
 
   case DeclarationName::CXXLiteralOperatorName:
-    AddSourceLocation(SourceLocation::getFromRawEncoding(
+    AddSourceLocation(SourceLocation::getFromPOD(
         DNLoc.CXXLiteralOperatorName.OpNameLoc));
     break;
 
   case DeclarationName::Identifier:
   case DeclarationName::ObjCZeroArgSelector:
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector:
   case DeclarationName::CXXUsingDirective:

clang/tools/clang-refactor/TestSupport.cpp

static Regex RangeRegex("range[[:blank:]]*([[:alpha:]_]*)?[[:blank:]]*=[[:"
                           "blank:]]*(\\+[[:digit:]]+)?[[:blank:]]*(->[[:blank:]"
                           "]*[\\+\\:[:digit:]]+)?");
 
   std::map<std::string, SmallVector<TestSelectionRange, 8>> GroupedRanges;
 
   LangOptions LangOpts;
   LangOpts.CPlusPlus = 1;
   LangOpts.CPlusPlus11 = 1;
-  Lexer Lex(SourceLocation::getFromRawEncoding(0), LangOpts, Source.begin(),
+  PODSourceLocation BeginLoc;
+  BeginLoc.clear();
+  Lexer Lex(SourceLocation::getFromPOD(BeginLoc), LangOpts, Source.begin(),
             Source.begin(), Source.end());
   Lex.SetCommentRetentionState(true);
   Token Tok;
   for (Lex.LexFromRawLexer(Tok); Tok.isNot(tok::eof);
        Lex.LexFromRawLexer(Tok)) {
     if (Tok.isNot(tok::comment))
       continue;
     StringRef Comment =

clang/tools/libclang/CIndex.cpp

RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
   
   if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
     Pieces.push_back(NI.getLoc());
 
   if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid())
     Pieces.push_back(*TemplateArgsLoc);
 
   if (Kind == DeclarationName::CXXOperatorName) {
-    Pieces.push_back(SourceLocation::getFromRawEncoding(
+    Pieces.push_back(SourceLocation::getFromPOD(
                        NI.getInfo().CXXOperatorName.BeginOpNameLoc));
-    Pieces.push_back(SourceLocation::getFromRawEncoding(
+    Pieces.push_back(SourceLocation::getFromPOD(
                        NI.getInfo().CXXOperatorName.EndOpNameLoc));
   }
   
   if (WantSinglePiece) {
     SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
     Pieces.clear();
     Pieces.push_back(R);
   }