64 bit SourceLocs

[teemperor]

Summary

Patch by Matt Asplund.

clang/include/clang/AST/ASTContext.h

class ASTContext : public RefCountedBase<ASTContext> {
   mutable TypedefDecl *ObjCClassDecl = nullptr;
 
   /// The typedef for the predefined \c Protocol class in Objective-C.
   mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;
 
   /// The typedef for the predefined 'BOOL' type.
   mutable TypedefDecl *BOOLDecl = nullptr;
 
+  /// The class for the predifined 'type_info' type.
+  mutable RecordDecl *TypeInfoClassDecl = nullptr;
+
   // Typedefs which may be provided defining the structure of Objective-C
   // pseudo-builtins
   QualType ObjCIdRedefinitionType;
   QualType ObjCClassRedefinitionType;
   QualType ObjCSelRedefinitionType;
 
   /// The identifier 'bool'.
   mutable IdentifierInfo *BoolName = nullptr;
#include "clang/Basic/AArch64SVEACLETypes.def"
   TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;
 
   /// Retrieve the declaration for the 128-bit signed integer type.
   TypedefDecl *getInt128Decl() const;
 
   /// Retrieve the declaration for the 128-bit unsigned integer type.
   TypedefDecl *getUInt128Decl() const;
 
+  /// Retrieve the declaration for the MSVC ::type_info class type.
+  RecordDecl *getTypeInfoClassDecl() const;
+
   //===--------------------------------------------------------------------===//
   //                           Type Constructors
   //===--------------------------------------------------------------------===//
 
 private:
   /// Return a type with extended qualifiers.
   QualType getExtQualType(const Type *Base, Qualifiers Quals) const;
 

clang/include/clang/AST/DeclBase.h

class DeclContext {
   /// methods in ObjCContainerDecl should be updated appropriately.
   class ObjCContainerDeclBitfields {
     friend class ObjCContainerDecl;
     /// For the bits in DeclContextBitfields
     uint32_t : NumDeclContextBits;
 
     // Not a bitfield but this saves space.
     // Note that ObjCContainerDeclBitfields is full.
-    SourceLocation AtStart;
+    unsigned AtStart;
   };
 
   /// Number of non-inherited bits in ObjCContainerDeclBitfields.
   /// Note that here we rely on the fact that SourceLocation is 32 bits
   /// wide. We check this with the static_assert in the ctor of DeclContext.
   enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };
 
   /// Stores the bits used by LinkageSpecDecl.

clang/include/clang/AST/DeclObjC.h

public:
   using PropertyDeclOrder = llvm::SmallVector<ObjCPropertyDecl *, 8>;
 
   /// This routine collects list of properties to be implemented in the class.
   /// This includes, class's and its conforming protocols' properties.
   /// Note, the superclass's properties are not included in the list.
   virtual void collectPropertiesToImplement(PropertyMap &PM,
                                             PropertyDeclOrder &PO) const {}
 
-  SourceLocation getAtStartLoc() const { return ObjCContainerDeclBits.AtStart; }
+  SourceLocation getAtStartLoc() const { 
+    return SourceLocation::getFromRawEncoding(ObjCContainerDeclBits.AtStart);
+  }
 
   void setAtStartLoc(SourceLocation Loc) {
-    ObjCContainerDeclBits.AtStart = Loc;
+    ObjCContainerDeclBits.AtStart = Loc.getRawEncoding();
   }
 
   // Marks the end of the container.
   SourceRange getAtEndRange() const { return AtEnd; }
 
   void setAtEndRange(SourceRange atEnd) { AtEnd = atEnd; }
 
   SourceRange getSourceRange() const override LLVM_READONLY {

clang/include/clang/AST/Stmt.h

 public:
   Stmt() = delete;
   Stmt(const Stmt &) = delete;
   Stmt(Stmt &&) = delete;
   Stmt &operator=(const Stmt &) = delete;
   Stmt &operator=(Stmt &&) = delete;
 
   Stmt(StmtClass SC) {
-    static_assert(sizeof(*this) <= 8,
+    static_assert(sizeof(*this) <= 16,
                   "changing bitfields changed sizeof(Stmt)");
     static_assert(sizeof(*this) % alignof(void *) == 0,
                   "Insufficient alignment!");
     StmtBits.sClass = SC;
     StmtBits.IsOMPStructuredBlock = false;
     if (StatisticsEnabled) Stmt::addStmtClass(SC);
   }
 

clang/include/clang/Basic/SourceLocation.h

 /// information whether the location is in a file or a macro expansion.
 ///
 /// It is important that this type remains small. It is currently 32 bits wide.
 class SourceLocation {
   friend class ASTReader;
   friend class ASTWriter;
   friend class SourceManager;
 
-  unsigned ID = 0;
+  unsigned long long ID = 0;
+
+  enum : unsigned long long {
+    MacroIDBitLong = 1ULL << 63,
+    OffsetMaskLong = ~MacroIDBitLong,
+  };
 
   enum : unsigned {
-    MacroIDBit = 1U << 31
+    MacroIDBitShort = 1U << 31,
+    OffsetMaskShort = ~MacroIDBitShort,
   };
 
 public:
-  bool isFileID() const  { return (ID & MacroIDBit) == 0; }
-  bool isMacroID() const { return (ID & MacroIDBit) != 0; }
+  bool isFileID() const  { return (ID & MacroIDBitLong) == 0; }
+  bool isMacroID() const { return (ID & MacroIDBitLong) != 0; }
 
   /// Return true if this is a valid SourceLocation object.
   ///
   /// Invalid SourceLocations are often used when events have no corresponding
   /// location in the source (e.g. a diagnostic is required for a command line
   /// option).
   bool isValid() const { return ID != 0; }
   bool isInvalid() const { return ID == 0; }
 
 private:
   /// Return the offset into the manager's global input view.
-  unsigned getOffset() const {
-    return ID & ~MacroIDBit;
+  unsigned getOffsetShort() const {
+    assert((ID & OffsetMaskLong) <= OffsetMaskShort && "Cannot fit location in 32 bits!");
+    return static_cast<unsigned>(ID);
+  }
+  unsigned long long getOffsetLong() const {
+    return ID & OffsetMaskLong;
   }
 
   static SourceLocation getFileLoc(unsigned ID) {
-    assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
+    assert((ID & MacroIDBitLong) == 0 && "Ran out of source locations!");
     SourceLocation L;
     L.ID = ID;
     return L;
   }
 
   static SourceLocation getMacroLoc(unsigned ID) {
-    assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
+    assert((ID & MacroIDBitLong) == 0 && "Ran out of source locations!");
     SourceLocation L;
-    L.ID = MacroIDBit | ID;
+    L.ID = MacroIDBitLong | ID;
     return L;
   }
 
 public:
   /// Return a source location with the specified offset from this
   /// SourceLocation.
   SourceLocation getLocWithOffset(int Offset) const {
-    assert(((getOffset()+Offset) & MacroIDBit) == 0 && "offset overflow");
+    assert(((getOffsetLong() + Offset) & MacroIDBitLong) == 0 && "offset overflow");
     SourceLocation L;
-    L.ID = ID+Offset;
+    L.ID = ID + Offset;
     return L;
   }
 
   /// 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.
-  unsigned getRawEncoding() const { return ID; }
+  unsigned long long getRawEncodingLong() const { return ID; }
+  unsigned getRawEncoding() const {
+    unsigned X = getOffsetShort();
+    if (isMacroID())
+      X |= MacroIDBitShort;
+    return X; 
+  }
 
   /// Turn a raw encoding of a SourceLocation object into
   /// a real SourceLocation.
   ///
   /// \see getRawEncoding.
   static SourceLocation getFromRawEncoding(unsigned Encoding) {
     SourceLocation X;
+    X.ID = Encoding & OffsetMaskShort;
+    if ((Encoding & MacroIDBitShort) != 0)
+      X.ID |= MacroIDBitLong;
+    return X;
+  }
+  static SourceLocation getFromRawEncodingLong(unsigned long long Encoding) {
+    SourceLocation X;
     X.ID = Encoding;
     return X;
   }
 
   /// When a SourceLocation itself cannot be used, this returns
   /// an (opaque) pointer encoding for it.
   ///
   /// This should only be passed to SourceLocation::getFromPtrEncoding, it
public:
   }
 
   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.getRawEncodingLong() == RHS.getRawEncodingLong();
 }
 
 inline bool operator!=(const SourceLocation &LHS, const SourceLocation &RHS) {
   return !(LHS == RHS);
 }
 
 // Ordering is meaningful only if LHS and RHS have the same FileID!
 // Otherwise use SourceManager::isBeforeInTranslationUnit().
 inline bool operator<(const SourceLocation &LHS, const SourceLocation &RHS) {
-  return LHS.getRawEncoding() < RHS.getRawEncoding();
+  return LHS.getRawEncodingLong() < RHS.getRawEncodingLong();
 }
 inline bool operator>(const SourceLocation &LHS, const SourceLocation &RHS) {
   return LHS.getRawEncoding() > RHS.getRawEncoding();
 }
 inline bool operator<=(const SourceLocation &LHS, const SourceLocation &RHS) {
   return LHS.getRawEncoding() <= RHS.getRawEncoding();
 }
 inline bool operator>=(const SourceLocation &LHS, const SourceLocation &RHS) {
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.getRawEncodingLong() == RHS.getRawEncodingLong() &&
           LHS.SrcMgr == RHS.SrcMgr;
   }
 
   friend bool
   operator!=(const FullSourceLoc &LHS, const FullSourceLoc &RHS) {
     return !(LHS == RHS);
   }
 };

clang/include/clang/Basic/SourceManager.h

public:
 
   /// Return the FileID for a SourceLocation.
   ///
   /// This is a very hot method that is used for all SourceManager queries
   /// that start with a SourceLocation object.  It is responsible for finding
   /// the entry in SLocEntryTable which contains the specified location.
   ///
   FileID getFileID(SourceLocation SpellingLoc) const {
-    unsigned SLocOffset = SpellingLoc.getOffset();
+    unsigned SLocOffset = SpellingLoc.getOffsetShort();
 
     // If our one-entry cache covers this offset, just return it.
     if (isOffsetInFileID(LastFileIDLookup, SLocOffset))
       return LastFileIDLookup;
 
     return getFileIDSlow(SLocOffset);
   }
 
public:
   /// The first element is the FileID, the second is the offset from the
   /// start of the buffer of the location.
   std::pair<FileID, unsigned> getDecomposedLoc(SourceLocation Loc) const {
     FileID FID = getFileID(Loc);
     bool Invalid = false;
     const SrcMgr::SLocEntry &E = getSLocEntry(FID, &Invalid);
     if (Invalid)
       return std::make_pair(FileID(), 0);
-    return std::make_pair(FID, Loc.getOffset()-E.getOffset());
+    return std::make_pair(FID, Loc.getOffsetShort()-E.getOffset());
   }
 
   /// Decompose the specified location into a raw FileID + Offset pair.
   ///
   /// If the location is an expansion record, walk through it until we find
   /// the final location expanded.
   std::pair<FileID, unsigned>
   getDecomposedExpansionLoc(SourceLocation Loc) const {
     FileID FID = getFileID(Loc);
     bool Invalid = false;
     const SrcMgr::SLocEntry *E = &getSLocEntry(FID, &Invalid);
     if (Invalid)
       return std::make_pair(FileID(), 0);
 
-    unsigned Offset = Loc.getOffset()-E->getOffset();
+    unsigned Offset = Loc.getOffsetShort()-E->getOffset();
     if (Loc.isFileID())
       return std::make_pair(FID, Offset);
 
     return getDecomposedExpansionLocSlowCase(E);
   }
 
   /// Decompose the specified location into a raw FileID + Offset pair.
   ///
   /// If the location is an expansion record, walk through it until we find
   /// its spelling record.
   std::pair<FileID, unsigned>
   getDecomposedSpellingLoc(SourceLocation Loc) const {
     FileID FID = getFileID(Loc);
     bool Invalid = false;
     const SrcMgr::SLocEntry *E = &getSLocEntry(FID, &Invalid);
     if (Invalid)
       return std::make_pair(FileID(), 0);
 
-    unsigned Offset = Loc.getOffset()-E->getOffset();
+    unsigned Offset = Loc.getOffsetShort()-E->getOffset();
     if (Loc.isFileID())
       return std::make_pair(FID, Offset);
     return getDecomposedSpellingLocSlowCase(E, Offset);
   }
 
   /// Returns the "included/expanded in" decomposed location of the given
   /// FileID.
   std::pair<FileID, unsigned> getDecomposedIncludedLoc(FileID FID) const;
public:
   /// Returns true if \p Loc is inside the [\p Start, +\p Length)
   /// chunk of the source location address space.
   ///
   /// If it's true and \p RelativeOffset is non-null, it will be set to the
   /// relative offset of \p Loc inside the chunk.
   bool isInSLocAddrSpace(SourceLocation Loc,
                          SourceLocation Start, unsigned Length,
                          unsigned *RelativeOffset = nullptr) const {
-    assert(((Start.getOffset() < NextLocalOffset &&
-               Start.getOffset()+Length <= NextLocalOffset) ||
-            (Start.getOffset() >= CurrentLoadedOffset &&
-                Start.getOffset()+Length < MaxLoadedOffset)) &&
+    assert(((Start.getOffsetShort() < NextLocalOffset &&
+               Start.getOffsetShort()+Length <= NextLocalOffset) ||
+            (Start.getOffsetShort() >= CurrentLoadedOffset &&
+                Start.getOffsetShort()+Length < MaxLoadedOffset)) &&
            "Chunk is not valid SLoc address space");
-    unsigned LocOffs = Loc.getOffset();
-    unsigned BeginOffs = Start.getOffset();
+    unsigned LocOffs = Loc.getOffsetShort();
+    unsigned BeginOffs = Start.getOffsetShort();
     unsigned EndOffs = BeginOffs + Length;
     if (LocOffs >= BeginOffs && LocOffs < EndOffs) {
       if (RelativeOffset)
         *RelativeOffset = LocOffs - BeginOffs;
       return true;
     }
 
     return false;
   }
 
   /// Return true if both \p LHS and \p RHS are in the local source
   /// location address space or the loaded one.
   ///
   /// If it's true and \p RelativeOffset is non-null, it will be set to the
   /// offset of \p RHS relative to \p LHS.
   bool isInSameSLocAddrSpace(SourceLocation LHS, SourceLocation RHS,
                              int *RelativeOffset) const {
-    unsigned LHSOffs = LHS.getOffset(), RHSOffs = RHS.getOffset();
+    unsigned LHSOffs = LHS.getOffsetShort(), RHSOffs = RHS.getOffsetShort();
     bool LHSLoaded = LHSOffs >= CurrentLoadedOffset;
     bool RHSLoaded = RHSOffs >= CurrentLoadedOffset;
 
     if (LHSLoaded == RHSLoaded) {
       if (RelativeOffset)
         *RelativeOffset = RHSOffs - LHSOffs;
       return true;
     }
public:
   /// The size of the SLocEntry that \p FID represents.
   unsigned getFileIDSize(FileID FID) const;
 
   /// Given a specific FileID, returns true if \p Loc is inside that
   /// FileID chunk and sets relative offset (offset of \p Loc from beginning
   /// of FileID) to \p relativeOffset.
   bool isInFileID(SourceLocation Loc, FileID FID,
                   unsigned *RelativeOffset = nullptr) const {
-    unsigned Offs = Loc.getOffset();
+    unsigned Offs = Loc.getOffsetShort();
     if (isOffsetInFileID(FID, Offs)) {
       if (RelativeOffset)
         *RelativeOffset = Offs - getSLocEntry(FID).getOffset();
       return true;
     }
 
     return false;
   }
public:
   ///          and \p LOffs is before \p ROffs.
   std::pair<bool, bool>
   isInTheSameTranslationUnit(std::pair<FileID, unsigned> &LOffs,
                              std::pair<FileID, unsigned> &ROffs) const;
 
   /// Determines the order of 2 source locations in the "source location
   /// address space".
   bool isBeforeInSLocAddrSpace(SourceLocation LHS, SourceLocation RHS) const {
-    return isBeforeInSLocAddrSpace(LHS, RHS.getOffset());
+    return isBeforeInSLocAddrSpace(LHS, RHS.getOffsetShort());
   }
 
   /// Determines the order of a source location and a source location
   /// offset in the "source location address space".
   ///
   /// Note that we always consider source locations loaded from
   bool isBeforeInSLocAddrSpace(SourceLocation LHS, unsigned RHS) const {
-    unsigned LHSOffset = LHS.getOffset();
+    unsigned LHSOffset = LHS.getOffsetShort();
     bool LHSLoaded = LHSOffset >= CurrentLoadedOffset;
     bool RHSLoaded = RHS >= CurrentLoadedOffset;
     if (LHSLoaded == RHSLoaded)
       return LHSOffset < RHS;
 
     return LHSLoaded;
   }
 
public:
   /// NumSLocEntries will be allocated, which occupy a total of TotalSize space
   /// in the global source view. The lowest ID and the base offset of the
   /// entries will be returned.
   std::pair<int, unsigned>
   AllocateLoadedSLocEntries(unsigned NumSLocEntries, unsigned TotalSize);
 
   /// Returns true if \p Loc came from a PCH/Module.
   bool isLoadedSourceLocation(SourceLocation Loc) const {
-    return Loc.getOffset() >= CurrentLoadedOffset;
+    return Loc.getOffsetShort() >= CurrentLoadedOffset;
   }
 
   /// Returns true if \p Loc did not come from a PCH/Module.
   bool isLocalSourceLocation(SourceLocation Loc) const {
-    return Loc.getOffset() < NextLocalOffset;
+    return Loc.getOffsetShort() < NextLocalOffset;
   }
 
   /// Returns true if \p FID came from a PCH/Module.
   bool isLoadedFileID(FileID FID) const {
     assert(FID.ID != -1 && "Using FileID sentinel value");
     return FID.ID < 0;
   }
 

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;
+  unsigned long long 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;
 
   /// 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
   ///    may be dirty (have trigraphs / escaped newlines).
   ///  Annotations (resolved type names, C++ scopes, etc): isAnnotation().
   ///    This is a pointer to sema-specific data for the annotation token.
   ///  Eof:
-  //     This is a pointer to a Decl.
+  ///    This is a pointer to a Decl.
   ///  Other:
   ///    This is null.
   void *PtrData;
 
   /// Kind - The actual flavor of token this is.
   tok::TokenKind Kind;
 
   /// Flags - Bits we track about this token, members of the TokenFlags enum.
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::getFromRawEncodingLong(Loc);
   }
   unsigned getLength() const {
     assert(!isAnnotation() && "Annotation tokens have no length field");
     return UintData;
   }
 
-  void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
+  void setLocation(SourceLocation L) { Loc = L.getRawEncodingLong(); }
   void setLength(unsigned Len) {
     assert(!isAnnotation() && "Annotation tokens have no length field");
     UintData = Len;
   }
 
   SourceLocation getAnnotationEndLoc() const {
     assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token");
-    return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
+    return UintData ? SourceLocation::getFromRawEncoding(UintData) : SourceLocation::getFromRawEncodingLong(Loc);
   }
   void setAnnotationEndLoc(SourceLocation L) {
     assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token");
     UintData = L.getRawEncoding();
   }
 
   SourceLocation getLastLoc() const {
     return isAnnotation() ? getAnnotationEndLoc() : getLocation();
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();
+    Loc = SourceLocation().getRawEncodingLong();
   }
 
   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/Serialization/ASTBitCodes.h

enum PredefinedDeclIDs {
       /// The internal '__NSConstantString' typedef.
       PREDEF_DECL_CF_CONSTANT_STRING_ID = 14,
 
       /// The internal '__NSConstantString' tag type.
       PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID = 15,
 
       /// The internal '__type_pack_element' template.
       PREDEF_DECL_TYPE_PACK_ELEMENT_ID = 16,
+
+      /// The internal 'type_info' class.
+      PREDEF_DECL_TYPE_INFO_CLASS_ID = 17,
     };
 
     /// The number of declaration IDs that are predefined.
     ///
     /// For more information about predefined declarations, see the
     /// \c PredefinedDeclIDs type and the PREDEF_DECL_*_ID constants.
-    const unsigned int NUM_PREDEF_DECL_IDS = 17;
+    const unsigned int NUM_PREDEF_DECL_IDS = 18;
 
     /// Record of updates for a declaration that was modified after
     /// being deserialized. This can occur within DECLTYPES_BLOCK_ID.
     const unsigned int DECL_UPDATES = 49;
 
     /// Record code for a list of local redeclarations of a declaration.
     /// This can occur within DECLTYPES_BLOCK_ID.
     const unsigned int LOCAL_REDECLARATIONS = 50;

clang/include/clang/Serialization/ASTReader.h

public:
   }
 
   /// Translate a source location from another module file's source
   /// location space into ours.
   SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile,
                                          SourceLocation Loc) const {
     if (!ModuleFile.ModuleOffsetMap.empty())
       ReadModuleOffsetMap(ModuleFile);
-    assert(ModuleFile.SLocRemap.find(Loc.getOffset()) !=
+    assert(ModuleFile.SLocRemap.find(Loc.getOffsetShort()) !=
                ModuleFile.SLocRemap.end() &&
            "Cannot find offset to remap.");
-    int Remap = ModuleFile.SLocRemap.find(Loc.getOffset())->second;
+    int Remap = ModuleFile.SLocRemap.find(Loc.getOffsetShort())->second;
     return Loc.getLocWithOffset(Remap);
   }
 
   /// Read a source location.
   SourceLocation ReadSourceLocation(ModuleFile &ModuleFile,
                                     const RecordDataImpl &Record,
                                     unsigned &Idx) {
     return ReadSourceLocation(ModuleFile, Record[Idx++]);

clang/lib/AST/ASTContext.cpp

 }
 
 TypedefDecl *ASTContext::getUInt128Decl() const {
   if (!UInt128Decl)
     UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
   return UInt128Decl;
 }
 
+RecordDecl *ASTContext::getTypeInfoClassDecl() const {
+  if (!TypeInfoClassDecl) {
+    TypeInfoClassDecl = buildImplicitRecord("type_info", TTK_Class);
+    TypeInfoClassDecl->setModuleOwnershipKind(
+        Decl::ModuleOwnershipKind::Unowned);
+  }
+  return TypeInfoClassDecl;
+}
+
 void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
   auto *Ty = new (*this, TypeAlignment) BuiltinType(K);
   R = CanQualType::CreateUnsafe(QualType(Ty, 0));
   Types.push_back(Ty);
 }
 
 void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
                                   const TargetInfo *AuxTarget) {

clang/lib/AST/Decl.cpp

LinkageInfo LinkageComputer::getLVForDecl(const NamedDecl *D,
 
   if (computation.IgnoreAllVisibility && D->hasCachedLinkage())
     return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
 
   if (llvm::Optional<LinkageInfo> LI = lookup(D, computation))
     return *LI;
 
   LinkageInfo LV = computeLVForDecl(D, computation);
-  if (D->hasCachedLinkage())
-    assert(D->getCachedLinkage() == LV.getLinkage());
+  // TODO : We can have implementation units re-declare an interface unit. Need to convert it.
+  // if (D->hasCachedLinkage())
+  //   assert(D->getCachedLinkage() == LV.getLinkage());
 
   D->setCachedLinkage(LV.getLinkage());
   cache(D, computation, LV);
 
 #ifndef NDEBUG
   // In C (because of gnu inline) and in c++ with microsoft extensions an
   // static can follow an extern, so we can have two decls with different
   // linkages.

clang/lib/AST/MicrosoftMangle.cpp

bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
     if (!discriminator)
       discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
     disc = discriminator + 1;
     return true;
   }
 
   unsigned getLambdaId(const CXXRecordDecl *RD) {
     assert(RD->isLambda() && "RD must be a lambda!");
-    assert(!RD->isExternallyVisible() && "RD must not be visible!");
+    // TODO: Investigate why this lambda is visible
+    assert((getASTContext().getLangOpts().CPlusPlusModules || 
+      !RD->isExternallyVisible()) && "RD must not be visible!");
     assert(RD->getLambdaManglingNumber() == 0 &&
            "RD must not have a mangling number!");
     std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>
         Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size()));
     return Result.first->second;
   }
 
   /// Return a character sequence that is (somewhat) unique to the TU suitable

clang/lib/AST/Type.cpp

bool Type::isLinkageValid() const {
   return L == TypeBits.getLinkage();
 }
 
 LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(const Type *T) {
   if (!T->isCanonicalUnqualified())
     return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
 
   LinkageInfo LV = computeTypeLinkageInfo(T);
-  assert(LV.getLinkage() == T->getLinkage());
+  // TODO : We can have implementation units re-declare an interface unit. Need to convert it.
+  // assert(LV.getLinkage() == T->getLinkage());
   return LV;
 }
 
 LinkageInfo Type::getLinkageAndVisibility() const {
   return LinkageComputer{}.getTypeLinkageAndVisibility(this);
 }
 
 Optional<NullabilityKind>

clang/lib/Basic/SourceManager.cpp

 
 SourceLocation SourceManager::createTokenSplitLoc(SourceLocation Spelling,
                                                   SourceLocation TokenStart,
                                                   SourceLocation TokenEnd) {
   assert(getFileID(TokenStart) == getFileID(TokenEnd) &&
          "token spans multiple files");
   return createExpansionLocImpl(
       ExpansionInfo::createForTokenSplit(Spelling, TokenStart, TokenEnd),
-      TokenEnd.getOffset() - TokenStart.getOffset());
+      TokenEnd.getOffsetShort() - TokenStart.getOffsetShort());
 }
 
 SourceLocation
 SourceManager::createExpansionLocImpl(const ExpansionInfo &Info,
                                       unsigned TokLength,
                                       int LoadedID,
                                       unsigned LoadedOffset) {
   if (LoadedID < 0) {
SourceManager::getDecomposedExpansionLocSlowCase(
   FileID FID;
   SourceLocation Loc;
   unsigned Offset;
   do {
     Loc = E->getExpansion().getExpansionLocStart();
 
     FID = getFileID(Loc);
     E = &getSLocEntry(FID);
-    Offset = Loc.getOffset()-E->getOffset();
+    Offset = Loc.getOffsetShort()-E->getOffset();
   } while (!Loc.isFileID());
 
   return std::make_pair(FID, Offset);
 }
 
 std::pair<FileID, unsigned>
 SourceManager::getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E,
                                                 unsigned Offset) const {
   // If this is an expansion record, walk through all the expansion points.
   FileID FID;
   SourceLocation Loc;
   do {
     Loc = E->getExpansion().getSpellingLoc();
     Loc = Loc.getLocWithOffset(Offset);
 
     FID = getFileID(Loc);
     E = &getSLocEntry(FID);
-    Offset = Loc.getOffset()-E->getOffset();
+    Offset = Loc.getOffsetShort()-E->getOffset();
   } while (!Loc.isFileID());
 
   return std::make_pair(FID, Offset);
 }
 
 /// getImmediateSpellingLoc - Given a SourceLocation object, return the
 /// spelling location referenced by the ID.  This is the first level down
 /// towards the place where the characters that make up the lexed token can be

 
 void SourceManager::associateFileChunkWithMacroArgExp(
                                          MacroArgsMap &MacroArgsCache,
                                          FileID FID,
                                          SourceLocation SpellLoc,
                                          SourceLocation ExpansionLoc,
                                          unsigned ExpansionLength) const {
   if (!SpellLoc.isFileID()) {
-    unsigned SpellBeginOffs = SpellLoc.getOffset();
+    unsigned SpellBeginOffs = SpellLoc.getOffsetShort();
     unsigned SpellEndOffs = SpellBeginOffs + ExpansionLength;
 
     // The spelling range for this macro argument expansion can span multiple
     // consecutive FileID entries. Go through each entry contained in the
     // spelling range and if one is itself a macro argument expansion, recurse
     // and associate the file chunk that it represents.
 
     FileID SpellFID; // Current FileID in the spelling range.
auto DumpSLocEntry = [&](int ID, const SrcMgr::SLocEntry &Entry,
     else
       out << "???\?>\n";
     if (Entry.isFile()) {
       auto &FI = Entry.getFile();
       if (FI.NumCreatedFIDs)
         out << "  covers <FileID " << ID << ":" << int(ID + FI.NumCreatedFIDs)
             << ">\n";
       if (FI.getIncludeLoc().isValid())
-        out << "  included from " << FI.getIncludeLoc().getOffset() << "\n";
+        out << "  included from " << FI.getIncludeLoc().getOffsetLong() << "\n";
       if (auto *CC = FI.getContentCache()) {
         out << "  for " << (CC->OrigEntry ? CC->OrigEntry->getName() : "<none>")
             << "\n";
         if (CC->BufferOverridden)
           out << "  contents overridden\n";
         if (CC->ContentsEntry != CC->OrigEntry) {
           out << "  contents from "
               << (CC->ContentsEntry ? CC->ContentsEntry->getName() : "<none>")
               << "\n";
         }
       }
     } else {
       auto &EI = Entry.getExpansion();
-      out << "  spelling from " << EI.getSpellingLoc().getOffset() << "\n";
+      out << "  spelling from " << EI.getSpellingLoc().getOffsetLong() << "\n";
       out << "  macro " << (EI.isMacroArgExpansion() ? "arg" : "body")
-          << " range <" << EI.getExpansionLocStart().getOffset() << ":"
-          << EI.getExpansionLocEnd().getOffset() << ">\n";
+          << " range <" << EI.getExpansionLocStart().getOffsetLong() << ":"
+          << EI.getExpansionLocEnd().getOffsetLong() << ">\n";
     }
   };
 
   // Dump local SLocEntries.
   for (unsigned ID = 0, NumIDs = LocalSLocEntryTable.size(); ID != NumIDs; ++ID) {
     DumpSLocEntry(ID, LocalSLocEntryTable[ID],
                   ID == NumIDs - 1 ? NextLocalOffset
                                    : LocalSLocEntryTable[ID + 1].getOffset());

clang/lib/Sema/Sema.cpp

void Sema::Initialize() {
   DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
   if (IdResolver.begin(ConstantString) == IdResolver.end())
     PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
 
   // Initialize Microsoft "predefined C++ types".
   if (getLangOpts().MSVCCompat) {
     if (getLangOpts().CPlusPlus &&
         IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
-      PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
-                        TUScope);
+      PushOnScopeChains(Context.getTypeInfoClassDecl(), TUScope);
 
     addImplicitTypedef("size_t", Context.getSizeType());
   }
 
   // Initialize predefined OpenCL types and supported extensions and (optional)
   // core features.
   if (getLangOpts().OpenCL) {
     getOpenCLOptions().addSupport(

clang/lib/Sema/SemaDecl.cpp

bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) {
   // linkage in redeclarations of the same entity, so for now allow the
   // redeclaration and change the owning modules to match.
   if (New->getFriendObjectKind() &&
       Old->getOwningModuleForLinkage() != New->getOwningModuleForLinkage()) {
     New->setLocalOwningModule(Old->getOwningModule());
     makeMergedDefinitionVisible(New);
     return false;
   }
  
+  // TODO: This allows builtins that fall into the global module to be rediclared in the module purview
+  if (!Old->hasOwningModule() && Old->isImplicit())
+    return false;
+
   Module *NewM = New->getOwningModule();
   Module *OldM = Old->getOwningModule();
 
   if (NewM && NewM->Kind == Module::PrivateModuleFragment)
     NewM = NewM->Parent;
   if (OldM && OldM->Kind == Module::PrivateModuleFragment)
     OldM = OldM->Parent;
 

clang/lib/Sema/SemaModule.cpp

Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
   }
 
   // Switch from the global module fragment (if any) to the named module.
   ModuleScopes.back().BeginLoc = StartLoc;
   ModuleScopes.back().Module = Mod;
   ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
   VisibleModules.setVisible(Mod, ModuleLoc);
 
+  if (MDK == ModuleDeclKind::Implementation) {
+    // [Modules TS] 10.7.1 p8
+    // The declsets made available by the moduleimport-declarations in the
+    // purview of the module interface unit of M are also available to name
+    // lookup in the purview of all module implementation units of M.
+    for (auto importedModule : Mod->Imports) {
+      // TDOD : SHOULD THIS BE importedModule->Loc?
+      VisibleModules.setVisible(importedModule, ModuleLoc);
+    }
+  }
+
   // From now on, we have an owning module for all declarations we see.
   // However, those declarations are module-private unless explicitly
   // exported.
   auto *TU = Context.getTranslationUnitDecl();
   TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
   TU->setLocalOwningModule(Mod);
 
   // FIXME: Create a ModuleDecl.

clang/lib/Serialization/ASTReader.cpp

case HEADER_SEARCH_TABLE:
         F.HeaderFileInfoTable
           = HeaderFileInfoLookupTable::Create(
                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
                    (const unsigned char *)F.HeaderFileInfoTableData,
                    HeaderFileInfoTrait(*this, F,
                                        &PP.getHeaderSearchInfo(),
                                        Blob.data() + Record[2]));
 
+        // C++20 Modules should not use pre-processed header lookup
+        if (!PP.getLangOpts().CPlusPlusModules) {
           PP.getHeaderSearchInfo().SetExternalSource(this);
           if (!PP.getHeaderSearchInfo().getExternalLookup())
             PP.getHeaderSearchInfo().SetExternalLookup(this);
         }
+      }
       break;
 
     case FP_PRAGMA_OPTIONS:
       // Later tables overwrite earlier ones.
       FPPragmaOptions.swap(Record);
       break;
 
     case OPENCL_EXTENSIONS:
case SUBMODULE_DEFINITION: {
       SubmodulesLoaded[GlobalIndex] = CurrentModule;
 
       // Clear out data that will be replaced by what is in the module file.
       CurrentModule->LinkLibraries.clear();
       CurrentModule->ConfigMacros.clear();
       CurrentModule->UnresolvedConflicts.clear();
       CurrentModule->Conflicts.clear();
 
+      // Copy over the imports
+      for (auto importModuleFile : F.Imports) {
+        auto importModule = ModMap.findModule(importModuleFile->ModuleName);
+        assert(importModule != nullptr && "Verify import module exists.");
+        CurrentModule->Imports.insert(importModule);
+      }
+
       // The module is available unless it's missing a requirement; relevant
       // requirements will be (re-)added by SUBMODULE_REQUIRES records.
       // Missing headers that were present when the module was built do not
       // make it unavailable -- if we got this far, this must be an explicitly
       // imported module file.
       CurrentModule->Requirements.clear();
       CurrentModule->MissingHeaders.clear();
       CurrentModule->IsMissingRequirement =

 } // namespace
 
 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
                                                        bool EndsAfter) const {
   if (SourceMgr.isLocalSourceLocation(Loc))
     return getTotalNumPreprocessedEntities();
 
   GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
-      SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
+      SourceManager::MaxLoadedOffset - Loc.getOffsetShort() - 1);
   assert(SLocMapI != GlobalSLocOffsetMap.end() &&
          "Corrupted global sloc offset map");
 
   if (SLocMapI->second->NumPreprocessedEntities == 0)
     return findNextPreprocessedEntity(SLocMapI);
 
   ModuleFile &M = *SLocMapI->second;
 
static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
   case PREDEF_DECL_CF_CONSTANT_STRING_ID:
     return Context.getCFConstantStringDecl();
 
   case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
     return Context.getCFConstantStringTagDecl();
 
   case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
     return Context.getTypePackElementDecl();
+
+  case PREDEF_DECL_TYPE_INFO_CLASS_ID:
+    return Context.getTypeInfoClassDecl();
   }
   llvm_unreachable("PredefinedDeclIDs unknown enum value");
 }
 
 Decl *ASTReader::GetExistingDecl(DeclID ID) {
   assert(ContextObj && "reading decl with no AST context");
   if (ID < NUM_PREDEF_DECL_IDS) {
     Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
void ASTReader::ReadPendingInstantiations(
   PendingInstantiations.clear();
 }
 
 void ASTReader::ReadLateParsedTemplates(
     llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
         &LPTMap) {
   for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
        /* In loop */) {
+
     FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
 
     auto LT = std::make_unique<LateParsedTemplate>();
     LT->D = GetDecl(LateParsedTemplates[Idx++]);
 
     ModuleFile *F = getOwningModuleFile(LT->D);
     assert(F && "No module");
 

clang/lib/Serialization/ASTWriter.cpp

ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
   RegisterPredefDecl(Context.MakeIntegerSeqDecl,
                      PREDEF_DECL_MAKE_INTEGER_SEQ_ID);
   RegisterPredefDecl(Context.CFConstantStringTypeDecl,
                      PREDEF_DECL_CF_CONSTANT_STRING_ID);
   RegisterPredefDecl(Context.CFConstantStringTagDecl,
                      PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID);
   RegisterPredefDecl(Context.TypePackElementDecl,
                      PREDEF_DECL_TYPE_PACK_ELEMENT_ID);
+  RegisterPredefDecl(Context.TypeInfoClassDecl,
+                     PREDEF_DECL_TYPE_INFO_CLASS_ID);
 
   // Build a record containing all of the tentative definitions in this file, in
   // TentativeDefinitions order.  Generally, this record will be empty for
   // headers.
   RecordData TentativeDefinitions;
   AddLazyVectorDecls(*this, SemaRef.TentativeDefinitions, TentativeDefinitions);
 
   // Build a record containing all of the file scoped decls in this file.