refactor Reporter

Author: vinniefalco

include/mrdox/Reporter.hpp

@@ -13,10 +13,10 @@
 #define MRDOX_REPORTER_HPP
 
 #include <llvm/Support/Error.h>
+#include <llvm/Support/Format.h>
 #include <llvm/Support/Mutex.h>
 #include <llvm/Support/raw_ostream.h>
 #include <cassert>
-#include <new>
 #include <source_location>
 #include <string>
 #include <string_view>
@@ -38,74 +38,79 @@ struct Reporter
 {
     /** Return a suitable exit code.
     */
-    int
-    getExitCode() const noexcept
-    {
-        if(! failed_)
-            return EXIT_SUCCESS;
-        return EXIT_FAILURE;
-    }
+    int getExitCode() const noexcept;
+
+    /** Print formatted output.
 
-    /** Report a non-successful Error
+        @param arg0, args The values to write.
     */
+    template<class Arg0, class... Args>
     void
-    failed(llvm::Error&& err);
+    print(
+        Arg0&& arg, Args&&... args);
 
     /** Report the failure of an action.
 
-        @param action   The operation which failed.
-        @param e        The object which holds the error.
-        @param loc      The location where the report is called.
+        @param arg0, args The values to write.
     */
-    template<class E>
+    template<class Arg0, class... Args>
     void
     failed(
-        llvm::StringRef action,
-        E&& e,
-        std::source_location const& loc =
-            std::source_location::current())
-    {
-        errs(action, " failed: ", std::move(e), " at ", loc);
-        failed_ = true;
-    }
+        Arg0&& arg, Args&&... args);
 
-    /** Report a unit test failure.
+    /** Return true and report a message if an error is indicated.
 
-        @par Thread Safety
-        May be called concurrently.
-    */
-    void
-    testFailed()
-    {
-        failed_ = true;
-    }
+        The error object `e` is inspected for a failure
+        condition. If `e` does not contain a failure,
+        then this function returns `false`. Otherwise
+        the function emits a diagnostic message to the
+        error channel and returns `true`.
 
-    /** Write a formatted string to outputs.
+        @par Output
+        The diagnostic message will always have the form:
+        @code
+        error: couldn't %1 because %2
+        @endcode
+        The first string is formed from the `actionFormat`
+        parameter and the variadic list of arguments,
+        while the second string is formed from the error
+        object.
 
-        @par Thread Safety
-        May be called concurrently.
+        If source location information is available, it
+        is reported on additional indented lines following
+        the diagnostic message.
+
+        @par Effects
+        The number of errors seen by the reporter
+        is incremented by one.
+
+        @return true if `e` indicates a failure.
+
+        @param e The error object to inspect.
+
+        @param arg0, args The values to write.
     */
-    template<class... Args>
-    void
-    outs(Args&&... args) const
-    {
-        llvm::StringRef s = format(std::forward<Args>(args)...);
-        std::lock_guard<llvm::sys::Mutex> lock(m_);
-        llvm::errs() << s << '\n';
-    }
+    template<
+        class E,
+        class Arg0, class... Args>
+    [[nodiscard]]
+    bool
+    error(
+        E&& e,
+        Arg0&& arg0,
+        Args&&... args);
 
-    /** Write a formatted string to errors.
+    //--------------------------------------------
+
+    /** Report a unit test failure.
 
         @par Thread Safety
         May be called concurrently.
     */
-    template<class... Args>
     void
-    errs(Args&&... args) const
+    testFailed()
     {
-        llvm::StringRef s = format(std::forward<Args>(args)...);
-        std::lock_guard<llvm::sys::Mutex> lock(m_);
-        llvm::errs() << s << '\n';
+        failed_ = true;
     }
 
     static
@@ -114,94 +119,145 @@ struct Reporter
         std::source_location const& loc);
 
 private:
-    /** Return a string formatted from arguments.
+    //--------------------------------------------
 
-        @par Thread Safety
-        May be called concurrently.
-    */
-    template<class... Args>
-    llvm::StringRef
-    format(
-        Args&&... args) const
+    template<class T>
+    static bool isFailure(llvm::Expected<T>& e) noexcept
     {
-        static thread_local std::string temp;
-        temp.clear();
-        llvm::raw_string_ostream os(temp);
-        format_impl(os, std::forward<Args>(args)...);
-        return llvm::StringRef(temp.data(), temp.size());
+        return ! e.operator bool();
     }
 
-    /** Format arguments into an output stream.
-    */
-    template<class Arg0, class... Args>
-    void
-    format_impl(
-        llvm::raw_string_ostream& os,
-        Arg0&& arg0,
-        Args&&... args) const
+    template<class T>
+    static bool isFailure(llvm::ErrorOr<T>& e) noexcept
     {
-        format_one(os, std::forward<Arg0>(arg0));
-        if constexpr(sizeof...(args) > 0)
-            format_impl(os, std::forward<Args>(args)...);
+        return ! e.operator bool();
+    }
+
+    static bool isFailure(std::error_code const& ec) noexcept
+    {
+        return ec.operator bool();
     }
 
     template<class T>
-    void
-    format_one(
-        llvm::raw_string_ostream& os,
-        T const& t) const
+    auto&& nice(T&& t) const
     {
-        os << t;
+        return std::forward<T>(t);
     }
 
-    void
-    format_one(
-        llvm::raw_string_ostream& os,
-        std::error_code const& ec) const
+    template<class T>
+    auto nice(llvm::Expected<T>& e) const
     {
-        os << ec.message();
+        return nice(e.takeError());
     }
 
-    void
-    format_one(
-        llvm::raw_string_ostream& os,
-        llvm::Error&& err) const
+    template<class T>
+    auto nice(llvm::Expected<T>&& e) const
     {
-        //err.operator bool(); // VFALCO?
-        os << toString(std::move(err));
+        return nice(e.takeError());
     }
 
     template<class T>
-    void
-    format_one(
-        llvm::raw_string_ostream& os,
-        llvm::Expected<T>&& ex) const
+    auto nice(llvm::ErrorOr<T>& e) const
     {
-        format_one(os, ex.takeError());
+        return nice(e.takeError());
     }
 
     template<class T>
-    void
-    format_one(
-        llvm::raw_string_ostream& os,
-        llvm::ErrorOr<T>&& eor) const
+    auto nice(llvm::ErrorOr<T>&& e) const
     {
-        format_one(os, eor.getError());
+        return nice(e.getError());
     }
 
-    void
-    format_one(
-        llvm::raw_string_ostream& os,
-        std::source_location const& loc) const
+    auto nice(std::error_code&& ec) const
     {
-        os << makeString(loc);
+        return ec.message();
     }
 
+    auto nice(std::error_code const& ec) const
+    {
+        return ec.message();
+    }
+
+    void
+    threadSafePrint(
+        llvm::raw_fd_ostream& os,
+        llvm::StringRef s,
+        std::size_t* n = nullptr);
+
+    static std::string& temp_string();
+
 private:
     llvm::sys::Mutex mutable m_;
+    std::size_t errorCount_ = 0;
     bool failed_ = false;
 };
 
+//------------------------------------------------
+
+template<
+    class Arg0, class... Args>
+void
+Reporter::
+print(
+    Arg0&& arg,
+    Args&&... args)
+{
+    auto& temp = temp_string();
+    temp.clear();
+    {
+        llvm::raw_string_ostream os(temp);
+        os << std::forward<Arg0>(arg);
+        (os << ... << nice(std::forward<Args>(args)));
+    }
+    threadSafePrint(llvm::outs(), temp, nullptr);
+}
+
+template<
+    class Arg0, class... Args>
+void
+Reporter::
+failed(
+    Arg0&& arg,
+    Args&&... args)
+{
+    auto& temp = temp_string();
+    temp.clear();
+    {
+        llvm::raw_string_ostream os(temp);
+        os << "error: Couldn't ";
+        os << std::forward<Arg0>(arg);
+        (os << ... << nice(std::forward<Args>(args)));
+        os << ".";
+    }
+    threadSafePrint(llvm::errs(), temp, &errorCount_);
+}
+
+template<
+    class E,
+    class Arg0, class... Args>
+bool
+Reporter::
+error(
+    E&& e,
+    Arg0&& arg,
+    Args&&... args)
+{
+    if(! isFailure(e))
+        return false;
+    auto& temp = temp_string();
+    temp.clear();
+    {
+        llvm::raw_string_ostream os(temp);
+        os << "error: Couldn't ";
+        os << std::forward<Arg0>(arg);
+        (os << ... << nice(std::forward<Args>(args)));
+        os << " because " <<
+            nice(std::move(e)) << '.';
+    }
+    threadSafePrint(llvm::errs(), temp, &errorCount_);
+    return true;
+}
+
 } // mrdox
 } // clang
 

source/lib/Asciidoc.cpp

@@ -93,11 +93,8 @@ buildOne(
         fs::CD_CreateAlways,
         fs::FA_Write,
         fs::OF_None);
-    if(ec)
-    {
-        R.failed("llvm::raw_fd_ostream", ec);
+    if(R.error(ec, "open the stream for '", fileName, "'"))
         return false;
-    }
 
     if(! corpus.canonicalize(R))
         return false;

source/lib/Config.cpp

@@ -100,19 +100,12 @@ loadFromFile(
 
     // Read the YAML file and apply to this
     auto fileText = llvm::MemoryBuffer::getFile(configPath);
-    if(! fileText)
-    {
-        R.failed("llvm::MemoryBuffer::getFile", fileText);
+    if(R.error(fileText, "read the file '", configPath, "'"))
         return false;
-    }
     llvm::yaml::Input yin(**fileText);
     yin >> *this;
-    std::error_code ec = yin.error();
-    if(ec)
-    {
-        R.failed("llvm::yaml::Input::operator>>", ec);
+    if(R.error(yin.error(), "parse the YAML file"))
         return false;
-    }
 
     // change configPath to the directory
     path::remove_filename(configPath);