[rebranch] Fix compilation failures

include/swift/Basic/APIntMap.h

@@ -38,11 +38,11 @@ struct WidthPreservingAPIntDenseMapInfo {
   }
 
   static unsigned getHashValue(const APInt &Key) {
-    return static_cast<unsigned>(hash_value(Key));
+    return llvm::DenseMapInfo<APInt>::getHashValue(Key);
   }
 
   static bool isEqual(const APInt &LHS, const APInt &RHS) {
-    return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
+    return llvm::DenseMapInfo<APInt>::isEqual(LHS, RHS);
   }
 };
 

include/swift/Demangling/TypeLookupError.h

@@ -20,7 +20,7 @@
 
 #include "swift/Basic/TaggedUnion.h"
 #include "swift/Runtime/Portability.h"
-#include <string.h>
+#include <string>
 
 namespace swift {
 

lib/ClangImporter/ClangAdapter.cpp

@@ -396,6 +396,7 @@ OmissionTypeName importer::getClangTypeNameForOmission(clang::ASTContext &ctx,
     case clang::BuiltinType::Float16:
     case clang::BuiltinType::Float128:
     case clang::BuiltinType::NullPtr:
+    case clang::BuiltinType::Ibm128:
       return OmissionTypeName();
 
     // Objective-C types that aren't mapped directly; rather, pointers to

lib/ClangImporter/ImportType.cpp

@@ -289,6 +289,7 @@ namespace {
       case clang::BuiltinType::Float128:
       case clang::BuiltinType::NullPtr:
       case clang::BuiltinType::Char8:
+      case clang::BuiltinType::Ibm128:
         return Type();
 
       // Objective-C types that aren't mapped directly; rather, pointers to

lib/ClangImporter/ImporterImpl.h

@@ -1618,7 +1618,7 @@ class SwiftNameLookupExtension : public clang::ModuleFileExtension {
         buffersForDiagnostics(buffersForDiagnostics), availability(avail) {}
 
   clang::ModuleFileExtensionMetadata getExtensionMetadata() const override;
-  llvm::hash_code hashExtension(llvm::hash_code code) const override;
+  void hashExtension(ExtensionHashBuilder &HBuilder) const override;
 
   std::unique_ptr<clang::ModuleFileExtensionWriter>
   createExtensionWriter(clang::ASTWriter &writer) override;

lib/ClangImporter/SwiftLookupTable.cpp

@@ -1849,12 +1849,12 @@ SwiftNameLookupExtension::getExtensionMetadata() const {
   return metadata;
 }
 
-llvm::hash_code
-SwiftNameLookupExtension::hashExtension(llvm::hash_code code) const {
-  return llvm::hash_combine(code, StringRef("swift.lookup"),
-                            SWIFT_LOOKUP_TABLE_VERSION_MAJOR,
-                            SWIFT_LOOKUP_TABLE_VERSION_MINOR,
-                            version::getSwiftFullVersion());
+void
+SwiftNameLookupExtension::hashExtension(ExtensionHashBuilder &HBuilder) const {
+  HBuilder.add(StringRef("swift.lookup"));
+  HBuilder.add(SWIFT_LOOKUP_TABLE_VERSION_MAJOR);
+  HBuilder.add(SWIFT_LOOKUP_TABLE_VERSION_MINOR);
+  HBuilder.add(version::getSwiftFullVersion());
 }
 
 void importer::addEntryToLookupTable(SwiftLookupTable &table,

lib/DependencyScan/ScanDependencies.cpp

@@ -775,8 +775,8 @@ generateFullDependencyGraph(CompilerInstance &instance,
                                         module.first,
                                         {module.second, currentImportPathSet});
     if (!moduleDepsQuery) {
-      std::string err = "Module Dependency Cache missing module" + module.first;
-      llvm::report_fatal_error(err);
+      llvm::report_fatal_error(Twine("Module Dependency Cache missing module") +
+                               module.first);
     }
 
     auto moduleDeps = *moduleDepsQuery;

lib/Driver/Driver.cpp

@@ -1157,7 +1157,8 @@ parseArgsUntil(const llvm::opt::OptTable& Opts,
     }
 
     unsigned Prev = Index;
-    Arg *A = Opts.ParseOneArg(*Args, Index, FlagsToInclude, FlagsToExclude);
+    std::unique_ptr<Arg> A = Opts.ParseOneArg(*Args, Index, FlagsToInclude,
+                                              FlagsToExclude);
     assert(Index > Prev && "Parser failed to consume argument.");
 
     // Check for missing argument error.
@@ -1169,7 +1170,7 @@ parseArgsUntil(const llvm::opt::OptTable& Opts,
       break;
     }
 
-    Args->append(A);
+    Args->append(A.release());
 
     if (CheckUntil && A->getOption().matches(UntilOption)) {
       if (Index < End)

lib/Driver/UnixToolChains.cpp

@@ -307,11 +307,11 @@ toolchains::GenericUnix::constructInvocation(const DynamicLinkJobAction &job,
   }
 
   if (!linkFilePath.empty()) {
-    auto linkFile = linkFilePath.str();
-    if (llvm::sys::fs::is_regular_file(linkFile)) {
-      Arguments.push_back(context.Args.MakeArgString(Twine("@") + linkFile));
+    if (llvm::sys::fs::is_regular_file(linkFilePath)) {
+      Arguments.push_back(
+          context.Args.MakeArgString(Twine("@") + linkFilePath));
     } else {
-      llvm::report_fatal_error(linkFile + " not found");
+      llvm::report_fatal_error(Twine(linkFilePath) + " not found");
     }
   }
 

lib/FrontendTool/FrontendTool.cpp

@@ -1978,15 +1978,15 @@ int swift::performFrontend(ArrayRef<const char *> Args,
   //
   // Unfortunately it's not really safe to do anything else, since very
   // low-level operations in LLVM can trigger fatal errors.
-  auto diagnoseFatalError = [&PDC](const std::string &reason, bool shouldCrash){
-    static const std::string *recursiveFatalError = nullptr;
+  auto diagnoseFatalError = [&PDC](const char *reason, bool shouldCrash) {
+    static const char *recursiveFatalError = nullptr;
     if (recursiveFatalError) {
       // Report the /original/ error through LLVM's default handler, not
       // whatever we encountered.
       llvm::remove_fatal_error_handler();
-      llvm::report_fatal_error(*recursiveFatalError, shouldCrash);
+      llvm::report_fatal_error(recursiveFatalError, shouldCrash);
     }
-    recursiveFatalError = &reason;
+    recursiveFatalError = reason;
 
     SourceManager dummyMgr;
 
@@ -2002,12 +2002,13 @@ int swift::performFrontend(ArrayRef<const char *> Args,
     if (shouldCrash)
       abort();
   };
-  llvm::ScopedFatalErrorHandler handler([](void *rawCallback,
-                                           const std::string &reason,
-                                           bool shouldCrash) {
-    auto *callback = static_cast<decltype(&diagnoseFatalError)>(rawCallback);
-    (*callback)(reason, shouldCrash);
-  }, &diagnoseFatalError);
+  llvm::ScopedFatalErrorHandler handler(
+      [](void *rawCallback, const char *reason, bool shouldCrash) {
+        auto *callback =
+            static_cast<decltype(&diagnoseFatalError)>(rawCallback);
+        (*callback)(reason, shouldCrash);
+      },
+      &diagnoseFatalError);
 
   std::unique_ptr<CompilerInstance> Instance =
     std::make_unique<CompilerInstance>();

lib/FrontendTool/LoadedModuleTrace.cpp

@@ -154,8 +154,8 @@ class ABIDependencyEvaluator {
   llvm::DenseSet<ModuleDecl *> visited;
 
   /// Helper function to handle invariant violations as crashes in debug mode.
-  void crashOnInvariantViolation(
-      llvm::function_ref<void(llvm::raw_string_ostream &)> f) const;
+  void
+  crashOnInvariantViolation(llvm::function_ref<void(raw_ostream &)> f) const;
 
   /// Computes the ABI exports for \p importedModule and adds them to
   /// \p module's ABI exports.
@@ -223,13 +223,13 @@ class ABIDependencyEvaluator {
 // See [NOTE: Bailing-vs-crashing-in-trace-emission].
 // TODO: Use PrettyStackTrace instead?
 void ABIDependencyEvaluator::crashOnInvariantViolation(
-    llvm::function_ref<void(llvm::raw_string_ostream &)> f) const {
+    llvm::function_ref<void(raw_ostream &)> f) const {
 #ifndef NDEBUG
-  std::string msg;
-  llvm::raw_string_ostream os(msg);
+  SmallVector<char, 0> msg;
+  llvm::raw_svector_ostream os(msg);
   os << "error: invariant violation: ";
   f(os);
-  llvm::report_fatal_error(os.str());
+  llvm::report_fatal_error(msg);
 #endif
 }
 
@@ -256,7 +256,7 @@ void ABIDependencyEvaluator::reexposeImportedABI(ModuleDecl *module,
                                                  ModuleDecl *importedModule,
                                                  bool includeImportedModule) {
   if (module == importedModule) {
-    crashOnInvariantViolation([&](llvm::raw_string_ostream &os) {
+    crashOnInvariantViolation([&](raw_ostream &os) {
       os << "module ";
       printModule(module, os);
       os << " imports itself!\n";
@@ -266,7 +266,7 @@ void ABIDependencyEvaluator::reexposeImportedABI(ModuleDecl *module,
 
   auto addToABIExportMap = [this](ModuleDecl *module, ModuleDecl *reexport) {
     if (module == reexport) {
-      crashOnInvariantViolation([&](llvm::raw_string_ostream &os) {
+      crashOnInvariantViolation([&](raw_ostream &os) {
         os << "expected module ";
         printModule(reexport, os);
         os << "  to not re-export itself\n";
@@ -409,7 +409,7 @@ void ABIDependencyEvaluator::computeABIDependenciesForModule(
   if (moduleIter != searchStack.end()) {
     if (isFakeCycleThroughOverlay(moduleIter))
       return;
-    crashOnInvariantViolation([&](llvm::raw_string_ostream &os) {
+    crashOnInvariantViolation([&](raw_ostream &os) {
       os << "unexpected cycle in import graph!\n";
       for (auto m : searchStack) {
         printModule(m, os);
@@ -557,21 +557,6 @@ static void computeSwiftModuleTraceInfo(
     const llvm::DenseMap<StringRef, ModuleDecl *> &pathToModuleDecl,
     const DependencyTracker &depTracker, StringRef prebuiltCachePath,
     std::vector<SwiftModuleTraceInfo> &traceInfo) {
-
-  SmallString<256> buffer;
-
-  std::string errMsg;
-  llvm::raw_string_ostream err(errMsg);
-
-  // FIXME: Use PrettyStackTrace instead.
-  auto errorUnexpectedPath =
-      [&pathToModuleDecl](llvm::raw_string_ostream &errStream) {
-        errStream << "The module <-> path mapping we have is:\n";
-        for (auto &m : pathToModuleDecl)
-          errStream << m.second->getName() << " <-> " << m.first << '\n';
-        llvm::report_fatal_error(errStream.str());
-      };
-
   using namespace llvm::sys;
 
   auto computeAdjacentInterfacePath = [](SmallVectorImpl<char> &modPath) {
@@ -580,6 +565,7 @@ static void computeSwiftModuleTraceInfo(
     path::replace_extension(modPath, swiftInterfaceExt);
   };
 
+  SmallString<256> buffer;
   auto deps = depTracker.getDependencies();
   SmallVector<std::string, 16> dependencies{deps.begin(), deps.end()};
   auto incrDeps = depTracker.getIncrementalDependencyPaths();
@@ -643,8 +629,14 @@ static void computeSwiftModuleTraceInfo(
     // built a swiftmodule from that interface, so we should have that
     // filename available.
     if (isSwiftinterface) {
+      // FIXME: Use PrettyStackTrace instead.
+      SmallVector<char, 0> errMsg;
+      llvm::raw_svector_ostream err(errMsg);
       err << "Unexpected path for swiftinterface file:\n" << depPath << "\n";
-      errorUnexpectedPath(err);
+      err << "The module <-> path mapping we have is:\n";
+      for (auto &m : pathToModuleDecl)
+        err << m.second->getName() << " <-> " << m.first << '\n';
+      llvm::report_fatal_error(errMsg);
     }
 
     // Skip cached modules in the prebuilt cache. We will add the corresponding

lib/IDE/SyntaxModel.cpp

@@ -1599,10 +1599,10 @@ class DocFieldParser {
     if (!advanceIf('-') || !advanceIf(' '))
       return None;
 
-    if (ptr == end || !clang::isIdentifierBody(*ptr))
+    if (ptr == end || !clang::isAsciiIdentifierContinue(*ptr))
       return None;
     const char *identStart = ptr++;
-    while (advanceIf([](char c) { return clang::isIdentifierBody(c); }))
+    while (advanceIf([](char c) { return clang::isAsciiIdentifierContinue(c); }))
       ;
     StringRef ident(identStart, ptr - identStart);
 

lib/IRGen/CallEmission.h

@@ -97,7 +97,9 @@ class CallEmission {
                        WitnessMetadata *witnessMetadata);
   virtual Address getCalleeErrorSlot(SILType errorType, bool isCalleeAsync) = 0;
 
-  void addAttribute(unsigned Index, llvm::Attribute::AttrKind Attr);
+  void addFnAttribute(llvm::Attribute::AttrKind Attr);
+
+  void addParamAttribute(unsigned ParamIndex, llvm::Attribute::AttrKind Attr);
 
   void emitToMemory(Address addr, const LoadableTypeInfo &substResultTI,
                     bool isOutlined);

lib/IRGen/GenArchetype.cpp

@@ -518,8 +518,7 @@ MetadataResponse irgen::emitOpaqueTypeMetadataRef(IRGenFunction &IGF,
                        {request.get(IGF), genericArgs, descriptor, indexValue});
       result->setDoesNotThrow();
       result->setCallingConv(IGF.IGM.SwiftCC);
-      result->addAttribute(llvm::AttributeList::FunctionIndex,
-                           llvm::Attribute::ReadOnly);
+      result->addFnAttr(llvm::Attribute::ReadOnly);
     });
   assert(result);
 
@@ -552,8 +551,7 @@ llvm::Value *irgen::emitOpaqueTypeWitnessTableRef(IRGenFunction &IGF,
                                    {genericArgs, descriptor, indexValue});
       result->setDoesNotThrow();
       result->setCallingConv(IGF.IGM.SwiftCC);
-      result->addAttribute(llvm::AttributeList::FunctionIndex,
-                           llvm::Attribute::ReadOnly);
+      result->addFnAttr(llvm::Attribute::ReadOnly);
     });
   assert(result);
 

lib/IRGen/GenBuiltin.cpp

@@ -603,10 +603,8 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     llvm::CallInst *call = IGF.Builder.CreateCall(fn,
                                         {context, errorBuffer.getAddress()});
     call->setCallingConv(IGF.IGM.SwiftCC);
-    call->addAttribute(llvm::AttributeList::FunctionIndex,
-                       llvm::Attribute::NoUnwind);
-    call->addAttribute(llvm::AttributeList::FirstArgIndex + 1,
-                       llvm::Attribute::ReadOnly);
+    call->addFnAttr(llvm::Attribute::NoUnwind);
+    call->addParamAttr(1, llvm::Attribute::ReadOnly);
 
     auto attrs = call->getAttributes();
     IGF.IGM.addSwiftSelfAttributes(attrs, 0);