[clang] Use SourceLocations in unions [NFCI]

[miyuki]

Summary

Currently, there are many instances where SourceLocation objects are
converted to raw representation to be stored in structs that are
used as fields of tagged unions.

This is done to make the corresponding structs trivial.
Triviality allows avoiding undefined behavior when implicitly changing
the active member of the union.

However, in most cases, we can explicitly construct an active member
using placement new. This patch adds the required active member
selections and replaces SourceLocation-s represented as
unsigned int with proper SourceLocation-s.

One notable exception is DeclarationNameLoc: the objects of this class
are often not properly initialized (so the code currently relies on
its default constructor which uses memset). This class will be fixed
in a separate patch.

[miyuki]

Fixed a typo in the word "implicit"

[dblaikie]

Do you need to run the destructor before placement new in these situations?

[miyuki]

In D94237#2493844, @dblaikie wrote:

Do you need to run the destructor before placement new in these situations?

No, because there is no active union member in any of those situations. And if even if there was an active member, all destructors are trivial anyway.

[miyuki]

Refactored SLocEntry in a similar way.

[dblaikie]

Sounds good

[miyuki]

This revision was landed with ongoing or failed builds.

The only failures were clang-format warnings, they looked bogus to me.

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;
     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 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;
+    SourceLocation 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;
+    SourceLocation DotLoc;
 
     /// The location of the field name in the designated initializer.
-    unsigned FieldLoc;
+    SourceLocation 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;
+    SourceLocation LBracketLoc;
     /// The location of the ellipsis separating the start and end
     /// indices. Only valid for GNU array-range designators.
-    unsigned EllipsisLoc;
+    SourceLocation EllipsisLoc;
     /// The location of the ']' terminating the array range designator.
-    unsigned RBracketLoc;
+    SourceLocation 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) {
+      new (&Field) DesignatedInitExpr::FieldDesignator;
       Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
-      Field.DotLoc = DotLoc.getRawEncoding();
-      Field.FieldLoc = FieldLoc.getRawEncoding();
+      Field.DotLoc = DotLoc;
+      Field.FieldLoc = FieldLoc;
     }
 
     /// Initializes an array designator.
     Designator(unsigned Index, SourceLocation LBracketLoc,
                SourceLocation RBracketLoc)
       : Kind(ArrayDesignator) {
+      new (&ArrayOrRange) DesignatedInitExpr::ArrayOrRangeDesignator;
       ArrayOrRange.Index = Index;
-      ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
-      ArrayOrRange.EllipsisLoc = SourceLocation().getRawEncoding();
-      ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayOrRange.LBracketLoc = LBracketLoc;
+      ArrayOrRange.EllipsisLoc = SourceLocation();
+      ArrayOrRange.RBracketLoc = RBracketLoc;
     }
 
     /// Initializes a GNU array-range designator.
     Designator(unsigned Index, SourceLocation LBracketLoc,
                SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
       : Kind(ArrayRangeDesignator) {
+      new (&ArrayOrRange) DesignatedInitExpr::ArrayOrRangeDesignator;
       ArrayOrRange.Index = Index;
-      ArrayOrRange.LBracketLoc = LBracketLoc.getRawEncoding();
-      ArrayOrRange.EllipsisLoc = EllipsisLoc.getRawEncoding();
-      ArrayOrRange.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayOrRange.LBracketLoc = LBracketLoc;
+      ArrayOrRange.EllipsisLoc = EllipsisLoc;
+      ArrayOrRange.RBracketLoc = RBracketLoc;
     }
 
     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 Field.DotLoc;
     }
 
     SourceLocation getFieldLoc() const {
       assert(Kind == FieldDesignator && "Only valid on a field designator");
-      return SourceLocation::getFromRawEncoding(Field.FieldLoc);
+      return 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 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 ArrayOrRange.RBracketLoc;
     }
 
     SourceLocation getEllipsisLoc() const {
       assert(Kind == ArrayRangeDesignator &&
              "Only valid on an array-range designator");
-      return SourceLocation::getFromRawEncoding(ArrayOrRange.EllipsisLoc);
+      return 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 TemplateTemplateArgLocInfo {
     // 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;
+    SourceLocation TemplateNameLoc;
+    SourceLocation EllipsisLoc;
   };
 
   llvm::PointerUnion<TemplateTemplateArgLocInfo *, Expr *, TypeSourceInfo *>
       Pointer;
 
   TemplateTemplateArgLocInfo *getTemplate() const {
     return Pointer.get<TemplateTemplateArgLocInfo *>();
   }
public:
 
   NestedNameSpecifierLoc getTemplateQualifierLoc() const {
     const auto *Template = getTemplate();
     return NestedNameSpecifierLoc(Template->Qualifier,
                                   Template->QualifierLocData);
   }
 
   SourceLocation getTemplateNameLoc() const {
-    return SourceLocation::getFromRawEncoding(getTemplate()->TemplateNameLoc);
+    return getTemplate()->TemplateNameLoc;
   }
 
   SourceLocation getTemplateEllipsisLoc() const {
-    return SourceLocation::getFromRawEncoding(getTemplate()->EllipsisLoc);
+    return getTemplate()->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/SourceManager.h

 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
+  SourceLocation 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;
 
 public:
   /// Return a FileInfo object.
   static FileInfo get(SourceLocation IL, ContentCache &Con,
                       CharacteristicKind FileCharacter, StringRef Filename) {
     FileInfo X;
-    X.IncludeLoc = IL.getRawEncoding();
+    X.IncludeLoc = IL;
     X.NumCreatedFIDs = 0;
     X.HasLineDirectives = false;
     X.ContentAndKind.setPointer(&Con);
     X.ContentAndKind.setInt(FileCharacter);
     Con.Filename = Filename;
     return X;
   }
 
   SourceLocation getIncludeLoc() const {
-    return SourceLocation::getFromRawEncoding(IncludeLoc);
+    return IncludeLoc;
   }
 
   const ContentCache &getContentCache() const {
     return *ContentAndKind.getPointer();
   }
 
   /// Return whether this is a system header or not.
   CharacteristicKind getFileCharacteristic() const {

 
 /// 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;
+  SourceLocation 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;
+  SourceLocation ExpansionLocStart, ExpansionLocEnd;
 
   /// Whether the expansion range is a token range.
   bool ExpansionIsTokenRange;
 
 public:
   SourceLocation getSpellingLoc() const {
-    SourceLocation SpellLoc = SourceLocation::getFromRawEncoding(SpellingLoc);
-    return SpellLoc.isInvalid() ? getExpansionLocStart() : SpellLoc;
+    return SpellingLoc.isInvalid() ? getExpansionLocStart() : SpellingLoc;
   }
 
   SourceLocation getExpansionLocStart() const {
-    return SourceLocation::getFromRawEncoding(ExpansionLocStart);
+    return ExpansionLocStart;
   }
 
   SourceLocation getExpansionLocEnd() const {
-    SourceLocation EndLoc = SourceLocation::getFromRawEncoding(ExpansionLocEnd);
-    return EndLoc.isInvalid() ? getExpansionLocStart() : EndLoc;
+    return ExpansionLocEnd.isInvalid() ? getExpansionLocStart()
+                                       : ExpansionLocEnd;
   }
 
   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();
+    return getExpansionLocStart().isValid() && ExpansionLocEnd.isInvalid();
   }
 
   bool isMacroBodyExpansion() const {
-    return getExpansionLocStart().isValid() &&
-           SourceLocation::getFromRawEncoding(ExpansionLocEnd).isValid();
+    return getExpansionLocStart().isValid() && 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;
+    X.ExpansionLocStart = Start;
+    X.ExpansionLocEnd = End;
     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
static SLocEntry get(unsigned Offset, const FileInfo &FI) {
     return E;
   }
 
   static SLocEntry get(unsigned Offset, const ExpansionInfo &Expansion) {
     assert(!(Offset & (1u << 31)) && "Offset is too large");
     SLocEntry E;
     E.Offset = Offset;
     E.IsExpansion = true;
-    E.Expansion = Expansion;
+    new (&E.Expansion) ExpansionInfo(Expansion);
     return E;
   }
 };
 
 } // namespace SrcMgr
 
 /// External source of source location entries.
 class ExternalSLocEntrySource {

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];
+    SourceLocation 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;
public:
   /// Determine whether this unqualified-id refers to a valid name.
   bool isValid() const { return StartLocation.isValid(); }
 
   /// Determine whether this unqualified-id refers to an invalid name.
   bool isInvalid() const { return !isValid(); }
 
   /// Determine what kind of name we have.
   UnqualifiedIdKind getKind() const { return Kind; }
-  void setKind(UnqualifiedIdKind kind) { Kind = kind; }
 
   /// Specify that this unqualified-id was parsed as an identifier.
   ///
   /// \param Id the parsed identifier.
   /// \param IdLoc the location of the parsed identifier.
   void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) {
     Kind = UnqualifiedIdKind::IK_Identifier;
     Identifier = const_cast<IdentifierInfo *>(Id);
public:
   /// \param TemplateLoc The location of the parsed template-name.
   void setDeductionGuideName(ParsedTemplateTy Template,
                              SourceLocation TemplateLoc) {
     Kind = UnqualifiedIdKind::IK_DeductionGuideName;
     TemplateName = Template;
     StartLocation = EndLocation = TemplateLoc;
   }
 
+  /// Specify that this unqualified-id is an implicit 'self'
+  /// parameter.
+  ///
+  /// \param Id the identifier.
+  void setImplicitSelfParam(const IdentifierInfo *Id) {
+    Kind = UnqualifiedIdKind::IK_ImplicitSelfParam;
+    Identifier = const_cast<IdentifierInfo *>(Id);
+    StartLocation = EndLocation = SourceLocation();
+  }
+
   /// Return the source range that covers this unqualified-id.
   SourceRange getSourceRange() const LLVM_READONLY {
     return SourceRange(StartLocation, EndLocation);
   }
   SourceLocation getBeginLoc() const LLVM_READONLY { return StartLocation; }
   SourceLocation getEndLoc() const LLVM_READONLY { return EndLocation; }
 };
 
 /// A set of tokens that has been cached for later parsing.
 typedef SmallVector<Token, 4> CachedTokens;
 
 /// One instance of this struct is used for each type in a
 /// declarator that is parsed.
 ///
 /// This is intended to be a small value object.
 struct DeclaratorChunk {
+  DeclaratorChunk() {};
+
   enum {
     Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren, Pipe
   } Kind;
 
   /// Loc - The place where this type was defined.
   SourceLocation Loc;
   /// EndLoc - If valid, the place where this chunck ends.
   SourceLocation EndLoc;
 
   SourceRange getSourceRange() const {
     if (EndLoc.isInvalid())
       return SourceRange(Loc, Loc);
     return SourceRange(Loc, EndLoc);
   }
 
   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;
+    SourceLocation ConstQualLoc;
 
     /// The location of the volatile-qualifier, if any.
-    unsigned VolatileQualLoc;
+    SourceLocation VolatileQualLoc;
 
     /// The location of the restrict-qualifier, if any.
-    unsigned RestrictQualLoc;
+    SourceLocation RestrictQualLoc;
 
     /// The location of the _Atomic-qualifier, if any.
-    unsigned AtomicQualLoc;
+    SourceLocation AtomicQualLoc;
 
     /// The location of the __unaligned-qualifier, if any.
-    unsigned UnalignedQualLoc;
+    SourceLocation 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;
+    SourceLocation LParenLoc;
 
     /// When isVariadic is true, the location of the ellipsis in the source.
-    unsigned EllipsisLoc;
+    SourceLocation EllipsisLoc;
 
     /// The location of the right parenthesis in the source.
-    unsigned RParenLoc;
+    SourceLocation 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;
+    SourceLocation RefQualifierLoc;
 
     /// The location of the 'mutable' qualifer in a lambda-declarator, if
     /// any.
-    unsigned MutableLoc;
+    SourceLocation MutableLoc;
 
     /// The beginning location of the exception specification, if any.
-    unsigned ExceptionSpecLocBeg;
+    SourceLocation ExceptionSpecLocBeg;
 
     /// The end location of the exception specification, if any.
-    unsigned ExceptionSpecLocEnd;
+    SourceLocation 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 {
     };
 
     /// If HasTrailingReturnType is true, this is the trailing return
     /// type specified.
     UnionParsedType TrailingReturnType;
 
     /// If HasTrailingReturnType is true, this is the location of the trailing
     /// return type.
-    unsigned TrailingReturnTypeLoc;
+    SourceLocation TrailingReturnTypeLoc;
 
     /// Reset the parameter list to having zero parameters.
     ///
     /// This is used in various places for error recovery.
     void freeParams() {
       for (unsigned I = 0; I < NumParams; ++I)
         Params[I].DefaultArgTokens.reset();
       if (DeleteParams) {
DeclSpec &getOrCreateMethodQualifiers() {
       return *MethodQualifiers;
     }
 
     /// 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);
-    }
+    SourceLocation getLParenLoc() const { return LParenLoc; }
 
-    SourceLocation getEllipsisLoc() const {
-      return SourceLocation::getFromRawEncoding(EllipsisLoc);
-    }
+    SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
 
-    SourceLocation getRParenLoc() const {
-      return SourceLocation::getFromRawEncoding(RParenLoc);
-    }
+    SourceLocation getRParenLoc() const { return RParenLoc; }
 
     SourceLocation getExceptionSpecLocBeg() const {
-      return SourceLocation::getFromRawEncoding(ExceptionSpecLocBeg);
+      return ExceptionSpecLocBeg;
     }
 
     SourceLocation getExceptionSpecLocEnd() const {
-      return SourceLocation::getFromRawEncoding(ExceptionSpecLocEnd);
+      return ExceptionSpecLocEnd;
     }
 
     SourceRange getExceptionSpecRange() const {
       return SourceRange(getExceptionSpecLocBeg(), getExceptionSpecLocEnd());
     }
 
     /// Retrieve the location of the ref-qualifier, if any.
-    SourceLocation getRefQualifierLoc() const {
-      return SourceLocation::getFromRawEncoding(RefQualifierLoc);
-    }
+    SourceLocation getRefQualifierLoc() const { return 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);
-    }
+    SourceLocation getMutableLoc() const { return 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.
     bool hasMutableQualifier() const { return getMutableLoc().isValid(); }
struct FunctionTypeInfo {
     ParsedType getTrailingReturnType() const {
       assert(HasTrailingReturnType);
       return TrailingReturnType;
     }
 
     /// Get the trailing-return-type location for this function declarator.
     SourceLocation getTrailingReturnTypeLoc() const {
       assert(HasTrailingReturnType);
-      return SourceLocation::getFromRawEncoding(TrailingReturnTypeLoc);
+      return TrailingReturnTypeLoc;
     }
   };
 
   struct BlockPointerTypeInfo {
     /// For now, sema will catch these as invalid.
     /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
     unsigned TypeQuals : 5;
 
     void destroy() {
     }
   };
 
   struct MemberPointerTypeInfo {
     /// The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
     unsigned TypeQuals : 5;
     /// Location of the '*' token.
-    unsigned StarLoc;
+    SourceLocation StarLoc;
     // CXXScopeSpec has a constructor, so it can't be a direct member.
     // So we need some pointer-aligned storage and a bit of trickery.
     alignas(CXXScopeSpec) char ScopeMem[sizeof(CXXScopeSpec)];
     CXXScopeSpec &Scope() {
       return *reinterpret_cast<CXXScopeSpec *>(ScopeMem);
     }
     const CXXScopeSpec &Scope() const {
       return *reinterpret_cast<const CXXScopeSpec *>(ScopeMem);
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
                                     SourceLocation ConstQualLoc,
                                     SourceLocation VolatileQualLoc,
                                     SourceLocation RestrictQualLoc,
                                     SourceLocation AtomicQualLoc,
                                     SourceLocation UnalignedQualLoc) {
     DeclaratorChunk I;
     I.Kind                = Pointer;
     I.Loc                 = Loc;
+    new (&I.Ptr) PointerTypeInfo;
     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;
+    I.Ptr.VolatileQualLoc = VolatileQualLoc;
+    I.Ptr.RestrictQualLoc = RestrictQualLoc;
+    I.Ptr.AtomicQualLoc   = AtomicQualLoc;
+    I.Ptr.UnalignedQualLoc = UnalignedQualLoc;
     return I;
   }
 
   /// Return a DeclaratorChunk for a reference.
   static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc,
                                       bool lvalue) {
     DeclaratorChunk I;
     I.Kind            = Reference;
struct DeclaratorChunk {
   static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS,
                                           unsigned TypeQuals,
                                           SourceLocation StarLoc,
                                           SourceLocation EndLoc) {
     DeclaratorChunk I;
     I.Kind          = MemberPointer;
     I.Loc           = SS.getBeginLoc();
     I.EndLoc = EndLoc;
-    I.Mem.StarLoc = StarLoc.getRawEncoding();
+    new (&I.Mem) MemberPointerTypeInfo;
+    I.Mem.StarLoc = StarLoc;
     I.Mem.TypeQuals = TypeQuals;
     new (I.Mem.ScopeMem) CXXScopeSpec(SS);
     return I;
   }
 
   /// Return a DeclaratorChunk for a paren.
   static DeclaratorChunk getParen(SourceLocation LParenLoc,
                                   SourceLocation RParenLoc) {

clang/include/clang/Sema/Designator.h

 ///  int a[10] = {2, 4, [8]=9, 10};
 ///
 class Designator {
 public:
   enum DesignatorKind {
     FieldDesignator, ArrayDesignator, ArrayRangeDesignator
   };
 private:
+  Designator() {};
+
   DesignatorKind Kind;
 
   struct FieldDesignatorInfo {
     const IdentifierInfo *II;
-    unsigned DotLoc;
-    unsigned NameLoc;
+    SourceLocation DotLoc;
+    SourceLocation NameLoc;
   };
   struct ArrayDesignatorInfo {
     Expr *Index;
-    unsigned LBracketLoc;
-    mutable unsigned  RBracketLoc;
+    SourceLocation LBracketLoc;
+    mutable SourceLocation RBracketLoc;
   };
   struct ArrayRangeDesignatorInfo {
     Expr *Start, *End;
-    unsigned LBracketLoc, EllipsisLoc;
-    mutable unsigned RBracketLoc;
+    SourceLocation LBracketLoc, EllipsisLoc;
+    mutable SourceLocation 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 FieldInfo.DotLoc;
   }
 
   SourceLocation getFieldLoc() const {
     assert(isFieldDesignator() && "Invalid accessor");
-    return SourceLocation::getFromRawEncoding(FieldInfo.NameLoc);
+    return 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 ArrayInfo.LBracketLoc;
     else
-      return SourceLocation::getFromRawEncoding(ArrayRangeInfo.LBracketLoc);
+      return ArrayRangeInfo.LBracketLoc;
   }
 
   SourceLocation getRBracketLoc() const {
     assert((isArrayDesignator() || isArrayRangeDesignator()) &&
            "Invalid accessor");
     if (isArrayDesignator())
-      return SourceLocation::getFromRawEncoding(ArrayInfo.RBracketLoc);
+      return ArrayInfo.RBracketLoc;
     else
-      return SourceLocation::getFromRawEncoding(ArrayRangeInfo.RBracketLoc);
+      return ArrayRangeInfo.RBracketLoc;
   }
 
   SourceLocation getEllipsisLoc() const {
     assert(isArrayRangeDesignator() && "Invalid accessor");
-    return SourceLocation::getFromRawEncoding(ArrayRangeInfo.EllipsisLoc);
+    return ArrayRangeInfo.EllipsisLoc;
   }
 
   static Designator getField(const IdentifierInfo *II, SourceLocation DotLoc,
                              SourceLocation NameLoc) {
     Designator D;
     D.Kind = FieldDesignator;
+    new (&D.FieldInfo) FieldDesignatorInfo;
     D.FieldInfo.II = II;
-    D.FieldInfo.DotLoc = DotLoc.getRawEncoding();
-    D.FieldInfo.NameLoc = NameLoc.getRawEncoding();
+    D.FieldInfo.DotLoc = DotLoc;
+    D.FieldInfo.NameLoc = NameLoc;
     return D;
   }
 
   static Designator getArray(Expr *Index,
                              SourceLocation LBracketLoc) {
     Designator D;
     D.Kind = ArrayDesignator;
+    new (&D.ArrayInfo) ArrayDesignatorInfo;
     D.ArrayInfo.Index = Index;
-    D.ArrayInfo.LBracketLoc = LBracketLoc.getRawEncoding();
-    D.ArrayInfo.RBracketLoc = 0;
+    D.ArrayInfo.LBracketLoc = LBracketLoc;
+    D.ArrayInfo.RBracketLoc = SourceLocation();
     return D;
   }
 
   static Designator getArrayRange(Expr *Start,
                                   Expr *End,
                                   SourceLocation LBracketLoc,
                                   SourceLocation EllipsisLoc) {
     Designator D;
     D.Kind = ArrayRangeDesignator;
+    new (&D.ArrayRangeInfo) ArrayRangeDesignatorInfo;
     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;
+    D.ArrayRangeInfo.EllipsisLoc = EllipsisLoc;
+    D.ArrayRangeInfo.RBracketLoc = SourceLocation();
     return D;
   }
 
   void setRBracketLoc(SourceLocation RBracketLoc) const {
     assert((isArrayDesignator() || isArrayRangeDesignator()) &&
            "Invalid accessor");
     if (isArrayDesignator())
-      ArrayInfo.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayInfo.RBracketLoc = RBracketLoc;
     else
-      ArrayRangeInfo.RBracketLoc = RBracketLoc.getRawEncoding();
+      ArrayRangeInfo.RBracketLoc = RBracketLoc;
   }
 
   /// 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;
+    SourceLocation 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;
+    SourceLocation Location;
   };
 
   union {
     /// When Kind == EK_Variable, EK_Member, EK_Binding, or
     /// EK_TemplateParameter, the variable, binding, or template parameter.
     VD Variable;
 
     /// When Kind == EK_RelatedResult, the ObjectiveC method where
union {
     /// When Kind == EK_ArrayElement, EK_VectorElement, or
     /// EK_ComplexElement, the index of the array or vector element being
     /// initialized.
     unsigned Index;
 
     struct C Capture;
   };
 
-  InitializedEntity() = default;
+  InitializedEntity() {};
 
   /// Create the initialization entity for a variable.
   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();
+    new (&LocAndNRVO) LN;
+    LocAndNRVO.Location = Loc;
     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) {
+    new (&Capture) C;
     Capture.VarID = VarID;
-    Capture.Location = Loc.getRawEncoding();
+    Capture.Location = Loc;
   }
 
 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 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 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 Capture.Location;
   }
 
   void setParameterCFAudited() {
     Kind = EK_Parameter_CF_Audited;
   }
 
   unsigned allocateManglingNumber() const { return ++ManglingNumber; }
 

clang/lib/AST/Expr.cpp

SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
   return SourceRange(DIE->getDesignator(0)->getBeginLoc(),
                      DIE->getDesignator(size() - 1)->getEndLoc());
 }
 
 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);
-    else
-      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
-  } else
-    StartLoc =
-      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
+  if (First.isFieldDesignator())
+    StartLoc = GNUSyntax ? First.Field.FieldLoc : First.Field.DotLoc;
+    StartLoc = First.ArrayOrRange.LBracketLoc;
   return StartLoc;
 }
 
 SourceLocation DesignatedInitExpr::getEndLoc() const {
   return getInit()->getEndLoc();
 }
 
 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {

clang/lib/AST/TemplateBase.cpp

 }
 
 clang::TemplateArgumentLocInfo::TemplateArgumentLocInfo(
     ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
     SourceLocation TemplateNameLoc, SourceLocation EllipsisLoc) {
   TemplateTemplateArgLocInfo *Template = new (Ctx) TemplateTemplateArgLocInfo;
   Template->Qualifier = QualifierLoc.getNestedNameSpecifier();
   Template->QualifierLocData = QualifierLoc.getOpaqueData();
-  Template->TemplateNameLoc = TemplateNameLoc.getRawEncoding();
-  Template->EllipsisLoc = EllipsisLoc.getRawEncoding();
+  Template->TemplateNameLoc = TemplateNameLoc;
+  Template->EllipsisLoc = EllipsisLoc;
   Pointer = Template;
 }
 
 const ASTTemplateArgumentListInfo *
 ASTTemplateArgumentListInfo::Create(const ASTContext &C,
                                     const TemplateArgumentListInfo &List) {
   std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size());
   void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo));

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;
 
       Diag(RefQualifierLoc, diag::err_declspec_after_virtspec)
         << (RefQualifierIsLValueRef ? "&" : "&&")
         << VirtSpecifiers::getSpecifierName(VS.getLastSpecifier())
         << FixItHint::CreateRemoval(RefQualifierLoc)
         << Insertion;
       D.SetRangeEnd(RefQualifierLoc);
     }
if (D.isFunctionDeclarator() && Tok.is(tok::arrow) &&
 
     if (!TrailingReturnType.isInvalid()) {
       Diag(ArrowLoc,
            diag::err_requires_clause_must_appear_after_trailing_return)
           << Range;
       auto &FunctionChunk = D.getFunctionTypeInfo();
       FunctionChunk.HasTrailingReturnType = TrailingReturnType.isUsable();
       FunctionChunk.TrailingReturnType = TrailingReturnType.get();
-      FunctionChunk.TrailingReturnTypeLoc = Range.getBegin().getRawEncoding();
+      FunctionChunk.TrailingReturnTypeLoc = Range.getBegin();
     } else
       SkipUntil({tok::equal, tok::l_brace, tok::arrow, tok::kw_try, tok::comma},
                 StopAtSemi | StopBeforeMatch);
   }
 }
 
 /// We have just started parsing the definition of a new class,
 /// so push that class onto our stack of classes that is currently

clang/lib/Sema/DeclSpec.cpp

DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
                                              DeclSpec *MethodQualifiers) {
   assert(!(MethodQualifiers && MethodQualifiers->getTypeQualifiers() & DeclSpec::TQ_atomic) &&
          "function cannot have _Atomic qualifier");
 
   DeclaratorChunk I;
   I.Kind                        = Function;
   I.Loc                         = LocalRangeBegin;
   I.EndLoc                      = LocalRangeEnd;
+  new (&I.Fun) FunctionTypeInfo;
   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;
+  I.Fun.EllipsisLoc             = EllipsisLoc;
+  I.Fun.RParenLoc               = RParenLoc;
   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;
+  I.Fun.MutableLoc              = MutableLoc;
   I.Fun.ExceptionSpecType       = ESpecType;
-  I.Fun.ExceptionSpecLocBeg     = ESpecRange.getBegin().getRawEncoding();
-  I.Fun.ExceptionSpecLocEnd     = ESpecRange.getEnd().getRawEncoding();
+  I.Fun.ExceptionSpecLocBeg     = ESpecRange.getBegin();
+  I.Fun.ExceptionSpecLocEnd     = ESpecRange.getEnd();
   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.TrailingReturnTypeLoc   = TrailingReturnTypeLoc.getRawEncoding();
+  I.Fun.TrailingReturnTypeLoc   = TrailingReturnTypeLoc;
   I.Fun.MethodQualifiers        = nullptr;
   I.Fun.QualAttrFactory         = nullptr;
 
   if (MethodQualifiers && (MethodQualifiers->getTypeQualifiers() ||
                            MethodQualifiers->getAttributes().size())) {
     auto &attrs = MethodQualifiers->getAttributes();
     I.Fun.MethodQualifiers = new DeclSpec(attrs.getPool().getFactory());
     MethodQualifiers->forEachCVRUQualifier(

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

clang/lib/Sema/SemaDecl.cpp

case UnqualifiedIdKind::IK_DeductionGuideName: {
     NameInfo.setName(
         Context.DeclarationNames.getCXXDeductionGuideName(Template));
     return NameInfo;
   }
 
   case UnqualifiedIdKind::IK_OperatorFunctionId:
     NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
                                            Name.OperatorFunctionId.Operator));
-    NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
-      = Name.OperatorFunctionId.SymbolLocations[0];
+    NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc =
+        Name.OperatorFunctionId.SymbolLocations[0].getRawEncoding();
     NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
       = Name.EndLocation.getRawEncoding();
     return NameInfo;
 
   case UnqualifiedIdKind::IK_LiteralOperatorId:
     NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
                                                            Name.Identifier));
     NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::BuildIvarRefExpr(Scope *S, SourceLocation Loc,
   // Check if referencing a field with __attribute__((deprecated)).
   if (DiagnoseUseOfDecl(IV, Loc))
     return ExprError();
 
   // FIXME: This should use a new expr for a direct reference, don't
   // turn this into Self->ivar, just return a BareIVarExpr or something.
   IdentifierInfo &II = Context.Idents.get("self");
   UnqualifiedId SelfName;
-  SelfName.setIdentifier(&II, SourceLocation());
-  SelfName.setKind(UnqualifiedIdKind::IK_ImplicitSelfParam);
+  SelfName.setImplicitSelfParam(&II);
   CXXScopeSpec SelfScopeSpec;
   SourceLocation TemplateKWLoc;
   ExprResult SelfExpr =
       ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, SelfName,
                         /*HasTrailingLParen=*/false,
                         /*IsAddressOfOperand=*/false);
   if (SelfExpr.isInvalid())
     return ExprError();

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));
+          PTI.ConstQualLoc,
+          PTI.VolatileQualLoc,
+          PTI.RestrictQualLoc,
+          PTI.AtomicQualLoc,
+          PTI.UnalignedQualLoc);
       return;
     }
 
     case DeclaratorChunk::Function:
     case DeclaratorChunk::BlockPointer:
     case DeclaratorChunk::Reference:
     case DeclaratorChunk::Array:
     case DeclaratorChunk::MemberPointer:
void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
       case NestedNameSpecifier::Namespace:
       case NestedNameSpecifier::NamespaceAlias:
       case NestedNameSpecifier::Global:
       case NestedNameSpecifier::Super:
         llvm_unreachable("Nested-name-specifier must name a type");
       }
 
       // Finally fill in MemberPointerLocInfo fields.
-      TL.setStarLoc(SourceLocation::getFromRawEncoding(Chunk.Mem.StarLoc));
+      TL.setStarLoc(Chunk.Mem.StarLoc);
       TL.setClassTInfo(ClsTInfo);
     }
     void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
       assert(Chunk.Kind == DeclaratorChunk::Reference);
       // 'Amp' is misleading: this might have been originally
       /// spelled with AmpAmp.
       TL.setAmpLoc(Chunk.Loc);
     }
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 = Chunk.Ptr.AtomicQualLoc;
     break;
 
   case DeclaratorChunk::BlockPointer:
   case DeclaratorChunk::Reference:
   case DeclaratorChunk::MemberPointer:
     // FIXME: Provide a source location for the _Atomic keyword.
     break;
   }