[clang-doc] Switch Generator::CreateResources to use llvm::Error

[DiegoAstiazaran]

LGTM

clang-tools-extra/clang-doc/Generators.h

public:
 
   // Write out the decl info in the specified format.
   virtual llvm::Error generateDocForInfo(Info *I, llvm::raw_ostream &OS,
                                          const ClangDocContext &CDCtx) = 0;
   // This function writes a file with the index previously constructed.
   // It can be overwritten by any of the inherited generators.
   // If the override method wants to run this it should call
   // Generator::createResources(CDCtx);
-  virtual bool createResources(ClangDocContext &CDCtx);
+  virtual llvm::Error createResources(ClangDocContext &CDCtx);
 
   static void addInfoToIndex(Index &Idx, const doc::Info *Info);
 };
 
 typedef llvm::Registry<Generator> GeneratorRegistry;
 
 llvm::Expected<std::unique_ptr<Generator>>
 findGeneratorByName(llvm::StringRef Format);

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

std::string getTagType(TagTypeKind AS) {
   case TagTypeKind::TTK_Struct:
     return "struct";
   case TagTypeKind::TTK_Enum:
     return "enum";
   }
   llvm_unreachable("Unknown TagTypeKind");
 }
 
-bool Generator::createResources(ClangDocContext &CDCtx) { return true; }
+llvm::Error Generator::createResources(ClangDocContext &CDCtx) {
+  return llvm::Error::success();
+}
 
 // A function to add a reference to Info in Idx.
 // Given an Info X with the following namespaces: [B,A]; a reference to X will
 // be added in the children of a reference to B, which should be also a child of
 // a reference to A, where A is a child of Idx.
 //   Idx
 //    |-- A
 //        |--B

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

 
 /// Generator for HTML documentation.
 class HTMLGenerator : public Generator {
 public:
   static const char *Format;
 
   llvm::Error generateDocForInfo(Info *I, llvm::raw_ostream &OS,
                                  const ClangDocContext &CDCtx) override;
-  bool createResources(ClangDocContext &CDCtx) override;
+  llvm::Error createResources(ClangDocContext &CDCtx) override;
 };
 
 const char *HTMLGenerator::Format = "html";
 
 llvm::Error HTMLGenerator::generateDocForInfo(Info *I, llvm::raw_ostream &OS,
                                               const ClangDocContext &CDCtx) {
   std::string InfoTitle;
   std::vector<std::unique_ptr<TagNode>> MainContentNodes;
static std::string getRefType(InfoType IT) {
   case InfoType::IT_function:
     return "function";
   case InfoType::IT_enum:
     return "enum";
   }
   llvm_unreachable("Unknown InfoType");
 }
 
-static bool SerializeIndex(ClangDocContext &CDCtx) {
+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) {
-    llvm::errs() << "Error creating index file: " << FileErr.message() << "\n";
-    return false;
+    return llvm::make_error<llvm::StringError>(
+        "Error creating index file: " + FileErr.message() + "\n",
+        llvm::inconvertibleErrorCode());
   }
   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));
       J.attribute("Path", I.Path);
       J.attributeArray("Children", [&] {
         for (const Index &C : I.Children)
           IndexToJSON(C);
       });
     });
   };
   OS << "var JsonIndex = `\n";
   IndexToJSON(CDCtx.Idx);
   OS << "`;\n";
-  return true;
+  return llvm::Error::success();
 }
 
 // Generates a main HTML node that has the main content of the file that shows
 // only the general index
 // It contains the general index with links to all the generated files
 static std::unique_ptr<TagNode> genIndexFileMainNode() {
   auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);
 
   auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
   LeftSidebarNode->Attributes.emplace_back("id", "sidebar-left");
   LeftSidebarNode->Attributes.emplace_back("path", "");
   LeftSidebarNode->Attributes.emplace_back(
       "class", "col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left");
   LeftSidebarNode->Attributes.emplace_back("style", "flex: 0 100%;");
 
   MainNode->Children.emplace_back(std::move(LeftSidebarNode));
 
   return MainNode;
 }
 
-static bool GenIndex(const ClangDocContext &CDCtx) {
+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) {
-    llvm::errs() << "Error creating main index: " << FileErr.message() << "\n";
-    return false;
+    return llvm::make_error<llvm::StringError>(
+        "Error creating main index: " + FileErr.message() + "\n",
+        llvm::inconvertibleErrorCode());
   }
 
   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();
   std::unique_ptr<TagNode> FooterNode = genFileFooterNode();
 
   AppendVector(std::move(HeadNodes), F.Children);
   F.Children.emplace_back(std::move(HeaderNode));
   F.Children.emplace_back(std::move(MainNode));
   F.Children.emplace_back(std::move(FooterNode));
 
   F.Render(IndexOS);
 
-  return true;
+  return llvm::Error::success();
 }
 
-static bool CopyFile(StringRef FilePath, StringRef OutDirectory) {
+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) {
-    llvm::errs() << "Error creating file "
-                 << llvm::sys::path::filename(FilePath) << ": "
-                 << FileErr.message() << "\n";
-    return false;
+    return llvm::make_error<llvm::StringError>(
+        "Error creating file " + llvm::sys::path::filename(FilePath) + ": " +
+            FileErr.message() + "\n",
+        llvm::inconvertibleErrorCode());
   }
-  return true;
+  return llvm::Error::success();
 }
 
-bool HTMLGenerator::createResources(ClangDocContext &CDCtx) {
-  if (!SerializeIndex(CDCtx) || !GenIndex(CDCtx))
-    return false;
-  for (const auto &FilePath : CDCtx.UserStylesheets)
-    if (!CopyFile(FilePath, CDCtx.OutDirectory))
-      return false;
-  for (const auto &FilePath : CDCtx.FilesToCopy)
-    if (!CopyFile(FilePath, CDCtx.OutDirectory))
-      return false;
-  return true;
+llvm::Error HTMLGenerator::createResources(ClangDocContext &CDCtx) {
+  auto Err = SerializeIndex(CDCtx);
+  if (Err)
+    return Err;
+  Err = GenIndex(CDCtx);
+  if (Err)
+    return Err;
+
+  for (const auto &FilePath : CDCtx.UserStylesheets) {
+    Err = CopyFile(FilePath, CDCtx.OutDirectory);
+    if (Err)
+      return Err;
+  }
+  for (const auto &FilePath : CDCtx.FilesToCopy) {
+    Err = CopyFile(FilePath, CDCtx.OutDirectory);
+    if (Err)
+      return Err;
+  }
+  return llvm::Error::success();
 }
 
 static GeneratorRegistry::Add<HTMLGenerator> HTML(HTMLGenerator::Format,
                                                   "Generator for HTML output.");
 
 // This anchor is used to force the linker to link in the generated object
 // file and thus register the generator.
 volatile int HTMLGeneratorAnchorSource = 0;
 
 } // namespace doc
 } // namespace clang

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

int main(int argc, const char **argv) {
   }
 
   Pool.wait();
 
   if (Error)
     return 1;
 
   llvm::outs() << "Generating assets for docs...\n";
-  if (!G->get()->createResources(CDCtx))
+  Err = G->get()->createResources(CDCtx);
+  if (Err) {
+    llvm::errs() << toString(std::move(Err)) << "\n";
     return 1;
+  }
 
   return 0;
 }