Merge pull request swiftlang#11998 from compnerd/qualifiers

runtime: clean up last of -Wqual-cast warnings

Author: compnerd

lib/AST/RawComment.cpp

@@ -258,7 +258,7 @@ CharSourceRange RawComment::getCharSourceRange() {
     return CharSourceRange();
   }
   auto End = this->Comments.back().Range.getEnd();
-  auto Length = (char *)End.getOpaquePointerValue() -
-                (char* )Start.getOpaquePointerValue();
+  auto Length = static_cast<const char *>(End.getOpaquePointerValue()) -
+                static_cast<const char *>(Start.getOpaquePointerValue());
   return CharSourceRange(Start, Length);
 }

lib/IDE/SwiftSourceDocInfo.cpp

@@ -773,8 +773,9 @@ calculateContentRange(ArrayRef<Token> Tokens) {
   auto StartLoc = StartTok.hasComment() ?
     StartTok.getCommentStart() : StartTok.getLoc();
   auto EndLoc = EndTok.getRange().getEnd();
-  return CharSourceRange(StartLoc, (char*)EndLoc.getOpaquePointerValue() -
-    (char*)StartLoc.getOpaquePointerValue());
+  auto Length = static_cast<const char *>(EndLoc.getOpaquePointerValue()) -
+                static_cast<const char *>(StartLoc.getOpaquePointerValue());
+  return CharSourceRange(StartLoc, Length);
 }
 
 bool DeclaredDecl::operator==(const DeclaredDecl& Other) {

lib/IDE/Utils.cpp

@@ -449,7 +449,7 @@ ide::replacePlaceholders(std::unique_ptr<llvm::MemoryBuffer> InputBuf,
     assert(Id.size() == Occur.FullPlaceholder.size());
 
     unsigned Offset = Occur.FullPlaceholder.data() - InputBuf->getBufferStart();
-    char *Ptr = (char*)NewBuf->getBufferStart() + Offset;
+    char *Ptr = const_cast<char *>(NewBuf->getBufferStart()) + Offset;
     std::copy(Id.begin(), Id.end(), Ptr);
 
     Occur.IdentifierReplacement = Id.str();

lib/IRGen/IRGen.cpp

@@ -269,7 +269,7 @@ class MD5Stream : public llvm::raw_ostream {
   llvm::MD5 Hash;
 
   void write_impl(const char *Ptr, size_t Size) override {
-    Hash.update(ArrayRef<uint8_t>((uint8_t *)Ptr, Size));
+    Hash.update(ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(Ptr), Size));
     Pos += Size;
   }
 
@@ -336,12 +336,16 @@ static bool needsRecompile(StringRef OutputFilename, ArrayRef<uint8_t> HashData,
     if (SectionName == HashSectionName) {
       StringRef SectionData;
       Section.getContents(SectionData);
-      ArrayRef<uint8_t> PrevHashData((uint8_t *)SectionData.data(),
-                                     SectionData.size());
+      ArrayRef<uint8_t> PrevHashData(
+          reinterpret_cast<const uint8_t *>(SectionData.data()),
+          SectionData.size());
       DEBUG(if (PrevHashData.size() == sizeof(MD5::MD5Result)) {
         if (DiagMutex) DiagMutex->lock();
         SmallString<32> HashStr;
-        MD5::stringifyResult(*(MD5::MD5Result *)PrevHashData.data(), HashStr);
+        MD5::stringifyResult(
+            *reinterpret_cast<MD5::MD5Result *>(
+                const_cast<unsigned char *>(PrevHashData.data())),
+            HashStr);
         llvm::dbgs() << OutputFilename << ": prev MD5=" << HashStr <<
           (HashData == PrevHashData ? " skipping\n" : " recompiling\n");
         if (DiagMutex) DiagMutex->unlock();
@@ -590,7 +594,8 @@ static void embedBitcode(llvm::Module *M, const IRGenOptions &Opts)
   if (Opts.EmbedMode == IRGenEmbedMode::EmbedBitcode)
     llvm::WriteBitcodeToFile(M, OS);
 
-  ArrayRef<uint8_t> ModuleData((uint8_t*)OS.str().data(), OS.str().size());
+  ArrayRef<uint8_t> ModuleData(
+      reinterpret_cast<const uint8_t *>(OS.str().data()), OS.str().size());
   llvm::Constant *ModuleConstant =
     llvm::ConstantDataArray::get(M->getContext(), ModuleData);
   llvm::GlobalVariable *GV = new llvm::GlobalVariable(*M,
@@ -610,8 +615,9 @@ static void embedBitcode(llvm::Module *M, const IRGenOptions &Opts)
   }
 
   // Embed command-line options.
-  ArrayRef<uint8_t> CmdData((uint8_t*)Opts.CmdArgs.data(),
-                            Opts.CmdArgs.size());
+  ArrayRef<uint8_t>
+      CmdData(reinterpret_cast<const uint8_t *>(Opts.CmdArgs.data()),
+              Opts.CmdArgs.size());
   llvm::Constant *CmdConstant =
     llvm::ConstantDataArray::get(M->getContext(), CmdData);
   GV = new llvm::GlobalVariable(*M, CmdConstant->getType(), true,

lib/Parse/Lexer.cpp

@@ -325,7 +325,7 @@ void Lexer::skipUpToEndOfLine() {
         return;
       default:
         // If this is a "high" UTF-8 character, validate it.
-        if (*((signed char *)CurPtr) < 0) {
+        if (*reinterpret_cast<const signed char *>(CurPtr) < 0) {
           const char *CharStart = CurPtr;
           if (validateUTF8CharacterAndAdvance(CurPtr, BufferEnd) == ~0U)
             diagnose(CharStart, diag::lex_invalid_utf8);

stdlib/public/runtime/ExistentialMetadataImpl.h

@@ -561,16 +561,17 @@ struct LLVM_LIBRARY_VISIBILITY ExistentialMetatypeBoxBase
 
   template <class Container, class... A>
   static void storeExtraInhabitant(Container *dest, int index, A... args) {
-    swift_storeHeapObjectExtraInhabitant((HeapObject**) dest->getValueSlot(),
+    Metadata **MD = const_cast<Metadata **>(dest->getValueSlot());
+    swift_storeHeapObjectExtraInhabitant(reinterpret_cast<HeapObject **>(MD),
                                          index);
   }
 
   template <class Container, class... A>
   static int getExtraInhabitantIndex(const Container *src, A... args) {
+    Metadata **MD = const_cast<Metadata **>(src->getValueSlot());
     return swift_getHeapObjectExtraInhabitantIndex(
-                                  (HeapObject* const *) src->getValueSlot());
+        reinterpret_cast<HeapObject *const *>(MD));
   }
-  
 };
 
 /// A box implementation class for an existential metatype container

stdlib/public/runtime/MetadataLookup.cpp

@@ -130,8 +130,11 @@ const Metadata *TypeMetadataRecord::getCanonicalTypeMetadata() const {
   switch (getTypeKind()) {
   case TypeMetadataRecordKind::UniqueDirectType:
     return getDirectType();
-  case TypeMetadataRecordKind::NonuniqueDirectType:
-    return swift_getForeignTypeMetadata((ForeignTypeMetadata *)getDirectType());
+  case TypeMetadataRecordKind::NonuniqueDirectType: {
+    const ForeignTypeMetadata *FMD =
+        static_cast<const ForeignTypeMetadata *>(getDirectType());
+    return swift_getForeignTypeMetadata(const_cast<ForeignTypeMetadata *>(FMD));
+  }
   case TypeMetadataRecordKind::UniqueDirectClass:
     if (auto *ClassMetadata =
           static_cast<const ::ClassMetadata *>(getDirectType()))

stdlib/public/runtime/ProtocolConformance.cpp

@@ -91,15 +91,18 @@ template<> void ProtocolConformanceRecord::dump() const {
 /// Take the type reference inside a protocol conformance record and fetch the
 /// canonical metadata pointer for the type it refers to.
 /// Returns nil for universal or generic type references.
-template<> const Metadata *ProtocolConformanceRecord::getCanonicalTypeMetadata()
-const {
+template <>
+const Metadata *ProtocolConformanceRecord::getCanonicalTypeMetadata() const {
   switch (getTypeKind()) {
   case TypeMetadataRecordKind::UniqueDirectType:
     // Already unique.
     return getDirectType();
-  case TypeMetadataRecordKind::NonuniqueDirectType:
+  case TypeMetadataRecordKind::NonuniqueDirectType: {
     // Ask the runtime for the unique metadata record we've canonized.
-    return swift_getForeignTypeMetadata((ForeignTypeMetadata*)getDirectType());
+    const ForeignTypeMetadata *FMD =
+        static_cast<const ForeignTypeMetadata *>(getDirectType());
+    return swift_getForeignTypeMetadata(const_cast<ForeignTypeMetadata *>(FMD));
+  }
   case TypeMetadataRecordKind::UniqueIndirectClass:
     // The class may be ObjC, in which case we need to instantiate its Swift
     // metadata. The class additionally may be weak-linked, so we have to check