Add FIXMEs to all derived classes of std::error_category.

[pcc]

Summary

This helps make clear that we're moving away from std::error_code.

[• rafael]

LGTM, thanks!

[lhames]

I like the idea of making it clearer that we're moving to Error as the standard error handling mechanism, but this could generate confusion because (at least the way I read them) these FIXMEs suggest that we could remove the error categories piecemeal, which isn't the case: To maintain compatibility with std::error_code (via the errorToErrorCode and expectedToErrorOr methods) we require that all error types be convertible to an equivalent error_code. We can't remove that requirement until all LLVM code has moved over to Error.

[lhames]

Oh - I see this was motivated by http://reviews.llvm.org/D20550.

Maybe a re-worded FIXME would work:

// FIXME: This class is only here to support the transition to llvm::Error. It will be
// removed once this transition is complete. Clients should prefer to deal with the
// Error value directly, rather than converting to error_code.

It is a bit more verbose though.

[pcc]

Maybe a re-worded FIXME would work:

SGTM, I'll commit with your proposed wording.

[lhames]

Cool. Thanks Peter!

lib/Bitcode/Reader/BitcodeReader.cpp

if (isBitcodeWrapper(buf, buf + 4)) {
     SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false);
     Bytes.dropLeadingBytes(bitcodeStart - buf);
     Bytes.setKnownObjectSize(bitcodeEnd - bitcodeStart);
   }
   return std::error_code();
 }
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class BitcodeErrorCategoryType : public std::error_category {
   const char *name() const LLVM_NOEXCEPT override {
     return "llvm.bitcode";
   }
   std::string message(int IE) const override {
     BitcodeError E = static_cast<BitcodeError>(IE);
     switch (E) {
     case BitcodeError::InvalidBitcodeSignature:

lib/DebugInfo/PDB/DIA/DIAError.cpp

 #include "llvm/DebugInfo/PDB/DIA/DIAError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
+// FIXME: Use llvm::Error instead of std::error_code.
 class DIAErrorCategory : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override { return "llvm.pdb.dia"; }
 
   std::string message(int Condition) const override {
     switch (static_cast<dia_error_code>(Condition)) {
     case dia_error_code::could_not_create_impl:
       return "Failed to connect to DIA at runtime.  Verify that Visual Studio "

lib/DebugInfo/PDB/GenericError.cpp

 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class GenericErrorCategory : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override { return "llvm.pdb"; }
 
   std::string message(int Condition) const override {
     switch (static_cast<generic_error_code>(Condition)) {
     case generic_error_code::unspecified:
       return "An unknown error has occurred.";

lib/DebugInfo/PDB/Raw/RawError.cpp

 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class RawErrorCategory : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override { return "llvm.pdb.raw"; }
 
   std::string message(int Condition) const override {
     switch (static_cast<raw_error_code>(Condition)) {
     case raw_error_code::unspecified:
       return "An unknown error has occurred.";

lib/ExecutionEngine/Orc/OrcError.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
 namespace {
 
+// FIXME: Use llvm::Error instead of std::error_code.
 class OrcErrorCategory : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override { return "orc"; }
 
   std::string message(int condition) const override {
     switch (static_cast<OrcErrorCode>(condition)) {
     case OrcErrorCode::RemoteAllocatorDoesNotExist:
       return "Remote allocator does not exist";

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 #define DEBUG_TYPE "dyld"
 
 namespace {
 
 enum RuntimeDyldErrorCode {
   GenericRTDyldError = 1
 };
 
+// FIXME: Use llvm::Error instead of std::error_code.
 class RuntimeDyldErrorCategory : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override { return "runtimedyld"; }
 
   std::string message(int Condition) const override {
     switch (static_cast<RuntimeDyldErrorCode>(Condition)) {
       case GenericRTDyldError: return "Generic RuntimeDyld error";
     }

lib/Object/Error.cpp

 #include "llvm/Object/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace object;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class _object_error_category : public std::error_category {
 public:
   const char* name() const LLVM_NOEXCEPT override;
   std::string message(int ev) const override;
 };
 }
 
 const char *_object_error_category::name() const LLVM_NOEXCEPT {

lib/ProfileData/Coverage/CoverageMapping.cpp

std::string getCoverageMapErrString(coveragemap_error Err) {
   case coveragemap_error::truncated:
     return "Truncated coverage data";
   case coveragemap_error::malformed:
     return "Malformed coverage data";
   }
   llvm_unreachable("A value of coveragemap_error has no message.");
 }
 
+// FIXME: Use llvm::Error instead of std::error_code.
 class CoverageMappingErrorCategoryType : public std::error_category {
   const char *name() const LLVM_NOEXCEPT override { return "llvm.coveragemap"; }
   std::string message(int IE) const override {
     return getCoverageMapErrString(static_cast<coveragemap_error>(IE));
   }
 };
 } // end anonymous namespace
 

lib/ProfileData/InstrProf.cpp

std::string getInstrProfErrString(instrprof_error Err) {
   case instrprof_error::compress_failed:
     return "Failed to compress data (zlib)";
   case instrprof_error::uncompress_failed:
     return "Failed to uncompress data (zlib)";
   }
   llvm_unreachable("A value of instrprof_error has no message.");
 }
 
+// FIXME: Use llvm::Error instead of std::error_code.
 class InstrProfErrorCategoryType : public std::error_category {
   const char *name() const LLVM_NOEXCEPT override { return "llvm.instrprof"; }
   std::string message(int IE) const override {
     return getInstrProfErrString(static_cast<instrprof_error>(IE));
   }
 };
 } // end anonymous namespace
 

lib/ProfileData/SampleProf.cpp

 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm::sampleprof;
 using namespace llvm;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class SampleProfErrorCategoryType : public std::error_category {
   const char *name() const LLVM_NOEXCEPT override { return "llvm.sampleprof"; }
   std::string message(int IE) const override {
     sampleprof_error E = static_cast<sampleprof_error>(IE);
     switch (E) {
     case sampleprof_error::success:
       return "Success";
     case sampleprof_error::bad_magic:

lib/Support/Error.cpp

 using namespace llvm;
 
 namespace {
 
   enum class ErrorErrorCode {
     MultipleErrors
   };
 
+  // FIXME: Use llvm::Error instead of std::error_code.
   class ErrorErrorCategory : public std::error_category {
   public:
     const char *name() const LLVM_NOEXCEPT override { return "Error"; }
 
     std::string message(int condition) const override {
       switch (static_cast<ErrorErrorCode>(condition)) {
       case ErrorErrorCode::MultipleErrors:
         return "Multiple errors";

tools/llvm-cxxdump/Error.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class cxxdump_error_category : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override { return "llvm.cxxdump"; }
   std::string message(int ev) const override {
     switch (static_cast<cxxdump_error>(ev)) {
     case cxxdump_error::success:
       return "Success";
     case cxxdump_error::file_not_found:

tools/llvm-readobj/Error.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class _readobj_error_category : public std::error_category {
 public:
   const char* name() const LLVM_NOEXCEPT override;
   std::string message(int ev) const override;
 };
 } // namespace
 
 const char *_readobj_error_category::name() const LLVM_NOEXCEPT {

tools/obj2yaml/Error.cpp

 //===- Error.cpp - system_error extensions for obj2yaml ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 namespace {
+// FIXME: Use llvm::Error instead of std::error_code.
 class _obj2yaml_error_category : public std::error_category {
 public:
   const char *name() const LLVM_NOEXCEPT override;
   std::string message(int ev) const override;
 };
 } // namespace
 
 const char *_obj2yaml_error_category::name() const LLVM_NOEXCEPT {