[clang-doc] Use llvm::createStringError and canonicalize error messages

[MaskRay]

Summary

"Bad block found.\n" -> "bad block found"

The lower cased form with no full stop or newline is more common in LLVM
tools.

[MaskRay]

Fix a few other places

[juliehockett]

LGTM -- thank you!

clang-tools-extra/trunk/clang-doc/BitcodeReader.cpp

 llvm::Error decodeRecord(Record R, llvm::SmallVectorImpl<char> &Field,
                          llvm::StringRef Blob) {
   Field.assign(Blob.begin(), Blob.end());
   return llvm::Error::success();
 }
 
 llvm::Error decodeRecord(Record R, SymbolID &Field, llvm::StringRef Blob) {
   if (R[0] != BitCodeConstants::USRHashSize)
-    return llvm::make_error<llvm::StringError>("Incorrect USR size.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "incorrect USR size");
 
   // First position in the record is the length of the following array, so we
   // copy the following elements to the field.
   for (int I = 0, E = R[0]; I < E; ++I)
     Field[I] = R[I + 1];
   return llvm::Error::success();
 }
 
 llvm::Error decodeRecord(Record R, bool &Field, llvm::StringRef Blob) {
   Field = R[0] != 0;
   return llvm::Error::success();
 }
 
 llvm::Error decodeRecord(Record R, int &Field, llvm::StringRef Blob) {
   if (R[0] > INT_MAX)
-    return llvm::make_error<llvm::StringError>("Integer too large to parse.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "integer too large to parse");
   Field = (int)R[0];
   return llvm::Error::success();
 }
 
 llvm::Error decodeRecord(Record R, AccessSpecifier &Field,
                          llvm::StringRef Blob) {
   switch (R[0]) {
   case AS_public:
   case AS_private:
   case AS_protected:
   case AS_none:
     Field = (AccessSpecifier)R[0];
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid value for AccessSpecifier.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid value for AccessSpecifier");
   }
 }
 
 llvm::Error decodeRecord(Record R, TagTypeKind &Field, llvm::StringRef Blob) {
   switch (R[0]) {
   case TTK_Struct:
   case TTK_Interface:
   case TTK_Union:
   case TTK_Class:
   case TTK_Enum:
     Field = (TagTypeKind)R[0];
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid value for TagTypeKind.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid value for TagTypeKind");
   }
 }
 
 llvm::Error decodeRecord(Record R, llvm::Optional<Location> &Field,
                          llvm::StringRef Blob) {
   if (R[0] > INT_MAX)
-    return llvm::make_error<llvm::StringError>("Integer too large to parse.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "integer too large to parse");
   Field.emplace((int)R[0], Blob, (bool)R[1]);
   return llvm::Error::success();
 }
 
 llvm::Error decodeRecord(Record R, InfoType &Field, llvm::StringRef Blob) {
   switch (auto IT = static_cast<InfoType>(R[0])) {
   case InfoType::IT_namespace:
   case InfoType::IT_record:
   case InfoType::IT_function:
   case InfoType::IT_default:
   case InfoType::IT_enum:
     Field = IT;
     return llvm::Error::success();
   }
-  return llvm::make_error<llvm::StringError>("Invalid value for InfoType.\n",
-                                             llvm::inconvertibleErrorCode());
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "invalid value for InfoType");
 }
 
 llvm::Error decodeRecord(Record R, FieldId &Field, llvm::StringRef Blob) {
   switch (auto F = static_cast<FieldId>(R[0])) {
   case FieldId::F_namespace:
   case FieldId::F_parent:
   case FieldId::F_vparent:
   case FieldId::F_type:
   case FieldId::F_child_namespace:
   case FieldId::F_child_record:
   case FieldId::F_default:
     Field = F;
     return llvm::Error::success();
   }
-  return llvm::make_error<llvm::StringError>("Invalid value for FieldId.\n",
-                                             llvm::inconvertibleErrorCode());
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "invalid value for FieldId");
 }
 
 llvm::Error decodeRecord(Record R,
                          llvm::SmallVectorImpl<llvm::SmallString<16>> &Field,
                          llvm::StringRef Blob) {
   Field.push_back(Blob);
   return llvm::Error::success();
 }
 
 llvm::Error decodeRecord(Record R, llvm::SmallVectorImpl<Location> &Field,
                          llvm::StringRef Blob) {
   if (R[0] > INT_MAX)
-    return llvm::make_error<llvm::StringError>("Integer too large to parse.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "integer too large to parse");
   Field.emplace_back((int)R[0], Blob, (bool)R[1]);
   return llvm::Error::success();
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         const unsigned VersionNo) {
   if (ID == VERSION && R[0] == VersionNo)
     return llvm::Error::success();
-  return llvm::make_error<llvm::StringError>(
-      "Mismatched bitcode version number.\n", llvm::inconvertibleErrorCode());
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "mismatched bitcode version number");
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         NamespaceInfo *I) {
   switch (ID) {
   case NAMESPACE_USR:
     return decodeRecord(R, I->USR, Blob);
   case NAMESPACE_NAME:
     return decodeRecord(R, I->Name, Blob);
   case NAMESPACE_PATH:
     return decodeRecord(R, I->Path, Blob);
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid field for NamespaceInfo.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for NamespaceInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         RecordInfo *I) {
   switch (ID) {
   case RECORD_USR:
     return decodeRecord(R, I->USR, Blob);
   case RECORD_NAME:
     return decodeRecord(R, I->Name, Blob);
   case RECORD_PATH:
     return decodeRecord(R, I->Path, Blob);
   case RECORD_DEFLOCATION:
     return decodeRecord(R, I->DefLoc, Blob);
   case RECORD_LOCATION:
     return decodeRecord(R, I->Loc, Blob);
   case RECORD_TAG_TYPE:
     return decodeRecord(R, I->TagType, Blob);
   case RECORD_IS_TYPE_DEF:
     return decodeRecord(R, I->IsTypeDef, Blob);
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid field for RecordInfo.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for RecordInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         BaseRecordInfo *I) {
   switch (ID) {
   case BASE_RECORD_USR:
     return decodeRecord(R, I->USR, Blob);
   case BASE_RECORD_NAME:
     return decodeRecord(R, I->Name, Blob);
   case BASE_RECORD_PATH:
     return decodeRecord(R, I->Path, Blob);
   case BASE_RECORD_TAG_TYPE:
     return decodeRecord(R, I->TagType, Blob);
   case BASE_RECORD_IS_VIRTUAL:
     return decodeRecord(R, I->IsVirtual, Blob);
   case BASE_RECORD_ACCESS:
     return decodeRecord(R, I->Access, Blob);
   case BASE_RECORD_IS_PARENT:
     return decodeRecord(R, I->IsParent, Blob);
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid field for BaseRecordInfo.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for BaseRecordInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         EnumInfo *I) {
   switch (ID) {
   case ENUM_USR:
     return decodeRecord(R, I->USR, Blob);
   case ENUM_NAME:
     return decodeRecord(R, I->Name, Blob);
   case ENUM_DEFLOCATION:
     return decodeRecord(R, I->DefLoc, Blob);
   case ENUM_LOCATION:
     return decodeRecord(R, I->Loc, Blob);
   case ENUM_MEMBER:
     return decodeRecord(R, I->Members, Blob);
   case ENUM_SCOPED:
     return decodeRecord(R, I->Scoped, Blob);
   default:
-    return llvm::make_error<llvm::StringError>("Invalid field for EnumInfo.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for EnumInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         FunctionInfo *I) {
   switch (ID) {
   case FUNCTION_USR:
     return decodeRecord(R, I->USR, Blob);
   case FUNCTION_NAME:
     return decodeRecord(R, I->Name, Blob);
   case FUNCTION_DEFLOCATION:
     return decodeRecord(R, I->DefLoc, Blob);
   case FUNCTION_LOCATION:
     return decodeRecord(R, I->Loc, Blob);
   case FUNCTION_ACCESS:
     return decodeRecord(R, I->Access, Blob);
   case FUNCTION_IS_METHOD:
     return decodeRecord(R, I->IsMethod, Blob);
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid field for FunctionInfo.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for FunctionInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         TypeInfo *I) {
   return llvm::Error::success();
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         FieldTypeInfo *I) {
   switch (ID) {
   case FIELD_TYPE_NAME:
     return decodeRecord(R, I->Name, Blob);
   default:
-    return llvm::make_error<llvm::StringError>("Invalid field for TypeInfo.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for TypeInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         MemberTypeInfo *I) {
   switch (ID) {
   case MEMBER_TYPE_NAME:
     return decodeRecord(R, I->Name, Blob);
   case MEMBER_TYPE_ACCESS:
     return decodeRecord(R, I->Access, Blob);
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid field for MemberTypeInfo.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for MemberTypeInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         CommentInfo *I) {
   switch (ID) {
   case COMMENT_KIND:
     return decodeRecord(R, I->Kind, Blob);
case COMMENT_ATTRVAL:
     return decodeRecord(R, I->AttrValues, Blob);
   case COMMENT_ARG:
     return decodeRecord(R, I->Args, Blob);
   case COMMENT_SELFCLOSING:
     return decodeRecord(R, I->SelfClosing, Blob);
   case COMMENT_EXPLICIT:
     return decodeRecord(R, I->Explicit, Blob);
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid field for CommentInfo.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for CommentInfo");
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         Reference *I, FieldId &F) {
   switch (ID) {
   case REFERENCE_USR:
     return decodeRecord(R, I->USR, Blob);
   case REFERENCE_NAME:
     return decodeRecord(R, I->Name, Blob);
   case REFERENCE_TYPE:
     return decodeRecord(R, I->RefType, Blob);
   case REFERENCE_PATH:
     return decodeRecord(R, I->Path, Blob);
   case REFERENCE_IS_IN_GLOBAL_NAMESPACE:
     return decodeRecord(R, I->IsInGlobalNamespace, Blob);
   case REFERENCE_FIELD:
     return decodeRecord(R, F, Blob);
   default:
-    return llvm::make_error<llvm::StringError>("Invalid field for Reference.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid field for Reference");
   }
 }
 
 template <typename T> llvm::Expected<CommentInfo *> getCommentInfo(T I) {
-  return llvm::make_error<llvm::StringError>(
-      "Invalid type cannot contain CommentInfo.\n",
-      llvm::inconvertibleErrorCode());
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "invalid type cannot contain CommentInfo");
 }
 
 template <> llvm::Expected<CommentInfo *> getCommentInfo(FunctionInfo *I) {
   I->Description.emplace_back();
   return &I->Description.back();
 }
 
 template <> llvm::Expected<CommentInfo *> getCommentInfo(NamespaceInfo *I) {

 
 template <>
 llvm::Expected<CommentInfo *> getCommentInfo(std::unique_ptr<CommentInfo> &I) {
   return getCommentInfo(I.get());
 }
 
 template <typename T, typename TTypeInfo>
 llvm::Error addTypeInfo(T I, TTypeInfo &&TI) {
-  return llvm::make_error<llvm::StringError>(
-      "Invalid type cannot contain TypeInfo.\n",
-      llvm::inconvertibleErrorCode());
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "invalid type cannot contain TypeInfo");
 }
 
 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
   I->Members.emplace_back(std::move(T));
   return llvm::Error::success();
 }
 
 template <> llvm::Error addTypeInfo(BaseRecordInfo *I, MemberTypeInfo &&T) {
   I->Members.emplace_back(std::move(T));
   return llvm::Error::success();
 }
 
 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
   I->ReturnType = std::move(T);
   return llvm::Error::success();
 }
 
 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
   I->Params.emplace_back(std::move(T));
   return llvm::Error::success();
 }
 
 template <typename T> llvm::Error addReference(T I, Reference &&R, FieldId F) {
-  return llvm::make_error<llvm::StringError>(
-      "Invalid type cannot contain Reference\n",
-      llvm::inconvertibleErrorCode());
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 "invalid type cannot contain Reference");
 }
 
 template <> llvm::Error addReference(TypeInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_type:
     I->Type = std::move(R);
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <>
 llvm::Error addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_type:
     I->Type = std::move(R);
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <>
 llvm::Error addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_type:
     I->Type = std::move(R);
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <> llvm::Error addReference(EnumInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_namespace:
     I->Namespace.emplace_back(std::move(R));
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <>
 llvm::Error addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_namespace:
     I->Namespace.emplace_back(std::move(R));
     return llvm::Error::success();
   case FieldId::F_child_namespace:
     I->ChildNamespaces.emplace_back(std::move(R));
     return llvm::Error::success();
   case FieldId::F_child_record:
     I->ChildRecords.emplace_back(std::move(R));
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <>
 llvm::Error addReference(FunctionInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_namespace:
     I->Namespace.emplace_back(std::move(R));
     return llvm::Error::success();
   case FieldId::F_parent:
     I->Parent = std::move(R);
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <> llvm::Error addReference(RecordInfo *I, Reference &&R, FieldId F) {
   switch (F) {
   case FieldId::F_namespace:
     I->Namespace.emplace_back(std::move(R));
     return llvm::Error::success();
   case FieldId::F_parent:
     I->Parents.emplace_back(std::move(R));
     return llvm::Error::success();
   case FieldId::F_vparent:
     I->VirtualParents.emplace_back(std::move(R));
     return llvm::Error::success();
   case FieldId::F_child_record:
     I->ChildRecords.emplace_back(std::move(R));
     return llvm::Error::success();
   default:
-    return llvm::make_error<llvm::StringError>(
-        "Invalid type cannot contain Reference.\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid type cannot contain Reference");
   }
 }
 
 template <typename T, typename ChildInfoType>
 void addChild(T I, ChildInfoType &&R) {
-  llvm::errs() << "Invalid child type for info.\n";
+  llvm::errs() << "invalid child type for info";
   exit(1);
 }
 
 template <> void addChild(NamespaceInfo *I, FunctionInfo &&R) {
   I->ChildFunctions.emplace_back(std::move(R));
 }
 
 template <> void addChild(NamespaceInfo *I, EnumInfo &&R) {
if (llvm::Error Err = Stream.EnterSubBlock(ID))
     return Err;
 
   while (true) {
     unsigned BlockOrCode = 0;
     Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
 
     switch (Res) {
     case Cursor::BadBlock:
-      return llvm::make_error<llvm::StringError>(
-          "Bad block found.\n", llvm::inconvertibleErrorCode());
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "bad block found");
     case Cursor::BlockEnd:
       return llvm::Error::success();
     case Cursor::BlockBegin:
       if (llvm::Error Err = readSubBlock(BlockOrCode, I)) {
         if (llvm::Error Skipped = Stream.SkipBlock())
           return joinErrors(std::move(Err), std::move(Skipped));
         return Err;
       }
llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
   case BI_ENUM_BLOCK_ID: {
     EnumInfo E;
     if (auto Err = readBlock(ID, &E))
       return Err;
     addChild(I, std::move(E));
     return llvm::Error::success();
   }
   default:
-    return llvm::make_error<llvm::StringError>("Invalid subblock type.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "invalid subblock type");
   }
 }
 
 ClangDocBitcodeReader::Cursor
 ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
   BlockOrRecordID = 0;
 
   while (!Stream.AtEndOfStream()) {
case llvm::bitc::FIRST_APPLICATION_ABBREV:
       llvm_unreachable("Unexpected abbrev id.");
     }
   }
   llvm_unreachable("Premature stream end.");
 }
 
 llvm::Error ClangDocBitcodeReader::validateStream() {
   if (Stream.AtEndOfStream())
-    return llvm::make_error<llvm::StringError>("Premature end of stream.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "premature end of stream");
 
   // Sniff for the signature.
   for (int Idx = 0; Idx != 4; ++Idx) {
     Expected<llvm::SimpleBitstreamCursor::word_t> MaybeRead = Stream.Read(8);
     if (!MaybeRead)
       return MaybeRead.takeError();
     else if (MaybeRead.get() != BitCodeConstants::Signature[Idx])
-      return llvm::make_error<llvm::StringError>(
-          "Invalid bitcode signature.\n", llvm::inconvertibleErrorCode());
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "invalid bitcode signature");
   }
   return llvm::Error::success();
 }
 
 llvm::Error ClangDocBitcodeReader::readBlockInfoBlock() {
   Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo =
       Stream.ReadBlockInfoBlock();
   if (!MaybeBlockInfo)
     return MaybeBlockInfo.takeError();
   else
     BlockInfo = MaybeBlockInfo.get();
   if (!BlockInfo)
-    return llvm::make_error<llvm::StringError>(
-        "Unable to parse BlockInfoBlock.\n", llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "unable to parse BlockInfoBlock");
   Stream.setBlockInfo(&*BlockInfo);
   return llvm::Error::success();
 }
 
 template <typename T>
 llvm::Expected<std::unique_ptr<Info>>
 ClangDocBitcodeReader::createInfo(unsigned ID) {
   std::unique_ptr<Info> I = std::make_unique<T>();
case BI_NAMESPACE_BLOCK_ID:
     return createInfo<NamespaceInfo>(ID);
   case BI_RECORD_BLOCK_ID:
     return createInfo<RecordInfo>(ID);
   case BI_ENUM_BLOCK_ID:
     return createInfo<EnumInfo>(ID);
   case BI_FUNCTION_BLOCK_ID:
     return createInfo<FunctionInfo>(ID);
   default:
-    return llvm::make_error<llvm::StringError>("Cannot create info.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "cannot create info");
   }
 }
 
 // Entry point
 llvm::Expected<std::vector<std::unique_ptr<Info>>>
 ClangDocBitcodeReader::readBitcode() {
   std::vector<std::unique_ptr<Info>> Infos;
   if (auto Err = validateStream())
     return std::move(Err);
 
   // Read the top level blocks.
   while (!Stream.AtEndOfStream()) {
     Expected<unsigned> MaybeCode = Stream.ReadCode();
     if (!MaybeCode)
       return MaybeCode.takeError();
     if (MaybeCode.get() != llvm::bitc::ENTER_SUBBLOCK)
-      return llvm::make_error<llvm::StringError>(
-          "No blocks in input.\n", llvm::inconvertibleErrorCode());
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "no blocks in input");
     Expected<unsigned> MaybeID = Stream.ReadSubBlockID();
     if (!MaybeID)
       return MaybeID.takeError();
     unsigned ID = MaybeID.get();
     switch (ID) {
     // NamedType and Comment blocks should not appear at the top level
     case BI_TYPE_BLOCK_ID:
     case BI_FIELD_TYPE_BLOCK_ID:
     case BI_MEMBER_TYPE_BLOCK_ID:
     case BI_COMMENT_BLOCK_ID:
     case BI_REFERENCE_BLOCK_ID:
-      return llvm::make_error<llvm::StringError>(
-          "Invalid top level block.\n", llvm::inconvertibleErrorCode());
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "invalid top level block");
     case BI_NAMESPACE_BLOCK_ID:
     case BI_RECORD_BLOCK_ID:
     case BI_ENUM_BLOCK_ID:
     case BI_FUNCTION_BLOCK_ID: {
       auto InfoOrErr = readBlockToInfo(ID);
       if (!InfoOrErr)
         return InfoOrErr.takeError();
       Infos.emplace_back(std::move(InfoOrErr.get()));

clang-tools-extra/trunk/clang-doc/Generators.cpp

 llvm::Expected<std::unique_ptr<Generator>>
 findGeneratorByName(llvm::StringRef Format) {
   for (auto I = GeneratorRegistry::begin(), E = GeneratorRegistry::end();
        I != E; ++I) {
     if (I->getName() != Format)
       continue;
     return I->instantiate();
   }
-  return llvm::make_error<llvm::StringError>("Can't find generator: " + Format,
-                                             llvm::inconvertibleErrorCode());
+  return createStringError(llvm::inconvertibleErrorCode(),
+                           "can't find generator: " + Format);
 }
 
 // Enum conversion
 
 std::string getAccess(AccessSpecifier AS) {
   switch (AS) {
   case AccessSpecifier::AS_public:
     return "public";

clang-tools-extra/trunk/clang-doc/HTMLGenerator.cpp

llvm::Error HTMLGenerator::generateDocForInfo(Info *I, llvm::raw_ostream &OS,
   case InfoType::IT_enum:
     MainContentNodes = genHTML(*static_cast<clang::doc::EnumInfo *>(I), CDCtx);
     break;
   case InfoType::IT_function:
     MainContentNodes =
         genHTML(*static_cast<clang::doc::FunctionInfo *>(I), CDCtx, "");
     break;
   case InfoType::IT_default:
-    return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "unexpected info type");
   }
 
   HTMLFile F =
       genInfoFile(InfoTitle, I->Path, MainContentNodes, InfoIndex, CDCtx);
   F.Render(OS);
 
   return llvm::Error::success();
 }

 static llvm::Error SerializeIndex(ClangDocContext &CDCtx) {
   std::error_code OK;
   std::error_code FileErr;
   llvm::SmallString<128> FilePath;
   llvm::sys::path::native(CDCtx.OutDirectory, FilePath);
   llvm::sys::path::append(FilePath, "index_json.js");
   llvm::raw_fd_ostream OS(FilePath, FileErr, llvm::sys::fs::F_None);
   if (FileErr != OK) {
-    return llvm::make_error<llvm::StringError>(
-        "Error creating index file: " + FileErr.message() + "\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "error creating index file: " +
+                                       FileErr.message());
   }
   CDCtx.Idx.sort();
   llvm::json::OStream J(OS, 2);
   std::function<void(Index)> IndexToJSON = [&](Index I) {
     J.object([&] {
       J.attribute("USR", toHex(llvm::toStringRef(I.USR)));
       J.attribute("Name", I.Name);
       J.attribute("RefType", getRefType(I.RefType));

 
 static llvm::Error GenIndex(const ClangDocContext &CDCtx) {
   std::error_code FileErr, OK;
   llvm::SmallString<128> IndexPath;
   llvm::sys::path::native(CDCtx.OutDirectory, IndexPath);
   llvm::sys::path::append(IndexPath, "index.html");
   llvm::raw_fd_ostream IndexOS(IndexPath, FileErr, llvm::sys::fs::F_None);
   if (FileErr != OK) {
-    return llvm::make_error<llvm::StringError>(
-        "Error creating main index: " + FileErr.message() + "\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "error creating main index: " +
+                                       FileErr.message());
   }
 
   HTMLFile F;
 
   std::vector<std::unique_ptr<TagNode>> HeadNodes =
       genFileHeadNodes("Index", "", CDCtx);
   std::unique_ptr<TagNode> HeaderNode = genFileHeaderNode(CDCtx.ProjectName);
   std::unique_ptr<TagNode> MainNode = genIndexFileMainNode();
static llvm::Error CopyFile(StringRef FilePath, StringRef OutDirectory) {
   llvm::SmallString<128> PathWrite;
   llvm::sys::path::native(OutDirectory, PathWrite);
   llvm::sys::path::append(PathWrite, llvm::sys::path::filename(FilePath));
   llvm::SmallString<128> PathRead;
   llvm::sys::path::native(FilePath, PathRead);
   std::error_code OK;
   std::error_code FileErr = llvm::sys::fs::copy_file(PathRead, PathWrite);
   if (FileErr != OK) {
-    return llvm::make_error<llvm::StringError>(
-        "Error creating file " + llvm::sys::path::filename(FilePath) + ": " +
-            FileErr.message() + "\n",
-        llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "error creating file " +
+                                       llvm::sys::path::filename(FilePath) +
+                                       ": " + FileErr.message() + "\n");
   }
   return llvm::Error::success();
 }
 
 llvm::Error HTMLGenerator::createResources(ClangDocContext &CDCtx) {
   auto Err = SerializeIndex(CDCtx);
   if (Err)
     return Err;

clang-tools-extra/trunk/clang-doc/MDGenerator.cpp

case InfoType::IT_record:
     break;
   case InfoType::IT_enum:
     genMarkdown(*static_cast<clang::doc::EnumInfo *>(I), OS);
     break;
   case InfoType::IT_function:
     genMarkdown(*static_cast<clang::doc::FunctionInfo *>(I), OS);
     break;
   case InfoType::IT_default:
-    return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
-                                               llvm::inconvertibleErrorCode());
+    return createStringError(llvm::inconvertibleErrorCode(),
+                             "unexpected InfoType");
   }
   return llvm::Error::success();
 }
 
 static GeneratorRegistry::Add<MDGenerator> MD(MDGenerator::Format,
                                               "Generator for MD output.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the generator.
 volatile int MDGeneratorAnchorSource = 0;
 
 } // namespace doc
 } // namespace clang

clang-tools-extra/trunk/clang-doc/Representation.cpp

 namespace {
 
 const SymbolID EmptySID = SymbolID();
 
 template <typename T>
 llvm::Expected<std::unique_ptr<Info>>
 reduce(std::vector<std::unique_ptr<Info>> &Values) {
   if (Values.empty())
-    return llvm::make_error<llvm::StringError>(" No values to reduce.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "no value to reduce");
   std::unique_ptr<Info> Merged = std::make_unique<T>(Values[0]->USR);
   T *Tmp = static_cast<T *>(Merged.get());
   for (auto &I : Values)
     Tmp->merge(std::move(*static_cast<T *>(I.get())));
   return std::move(Merged);
 }
 
 // Return the index of the matching child in the vector, or -1 if merge is not

 }
 
 } // namespace
 
 // Dispatch function.
 llvm::Expected<std::unique_ptr<Info>>
 mergeInfos(std::vector<std::unique_ptr<Info>> &Values) {
   if (Values.empty())
-    return llvm::make_error<llvm::StringError>("No info values to merge.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "no info values to merge");
 
   switch (Values[0]->IT) {
   case InfoType::IT_namespace:
     return reduce<NamespaceInfo>(Values);
   case InfoType::IT_record:
     return reduce<RecordInfo>(Values);
   case InfoType::IT_enum:
     return reduce<EnumInfo>(Values);
   case InfoType::IT_function:
     return reduce<FunctionInfo>(Values);
   default:
-    return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "unexpected info type");
   }
 }
 
 bool Reference::mergeable(const Reference &Other) {
   return RefType == Other.RefType && USR == Other.USR;
 }
 
 void Reference::merge(Reference &&Other) {

clang-tools-extra/trunk/clang-doc/YAMLGenerator.cpp

case InfoType::IT_record:
     break;
   case InfoType::IT_enum:
     InfoYAML << *static_cast<clang::doc::EnumInfo *>(I);
     break;
   case InfoType::IT_function:
     InfoYAML << *static_cast<clang::doc::FunctionInfo *>(I);
     break;
   case InfoType::IT_default:
-    return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "unexpected InfoType");
   }
   return llvm::Error::success();
 }
 
 static GeneratorRegistry::Add<YAMLGenerator> YAML(YAMLGenerator::Format,
                                                   "Generator for YAML output.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the generator.
 volatile int YAMLGeneratorAnchorSource = 0;
 
 } // namespace doc
 } // namespace clang

clang-tools-extra/trunk/clang-doc/tool/ClangDocMain.cpp

 llvm::Expected<llvm::SmallString<128>> getInfoOutputFile(StringRef Root,
                                                          StringRef RelativePath,
                                                          StringRef Name,
                                                          StringRef Ext) {
   llvm::SmallString<128> Path;
   llvm::sys::path::native(Root, Path);
   llvm::sys::path::append(Path, RelativePath);
   if (CreateDirectory(Path))
-    return llvm::make_error<llvm::StringError>("Unable to create directory.\n",
-                                               llvm::inconvertibleErrorCode());
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "failed to create directory");
   llvm::sys::path::append(Path, Name + Ext);
   return Path;
 }
 
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
   std::error_code OK;