move Corpus::build to CorpusImpl::build

Author: sdkrystian

include/mrdox/Corpus.hpp

@@ -16,7 +16,6 @@
 #include <mrdox/Config.hpp>
 #include <mrdox/MetadataFwd.hpp>
 #include <mrdox/Metadata/Symbols.hpp>
-#include <clang/Tooling/Execution.h>
 #include <cassert>
 #include <memory>
 #include <string>
@@ -129,18 +128,6 @@ class MRDOX_VISIBLE
 
     //--------------------------------------------
 
-    /** Build metadata for a set of translation units.
-
-        @param config A shared pointer to the configuration.
-    */
-    MRDOX_DECL
-    [[nodiscard]]
-    static
-    Expected<std::unique_ptr<Corpus>>
-    build(
-        tooling::ToolExecutor& ex,
-        std::shared_ptr<Config const> config);
-
     // KRYSTIAN NOTE: temporary
     MRDOX_DECL
     std::string&

source/AST/Bitcode.hpp

@@ -14,6 +14,7 @@
 
 #include <mrdox/Platform.hpp>
 #include <mrdox/MetadataFwd.hpp>
+#include <mrdox/Support/Expected.hpp>
 #include <clang/Tooling/Execution.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/StringMap.h>
@@ -78,7 +79,7 @@ writeBitcode(
 
 /** Return an array of Info read from a bitstream.
 */
-Expected<std::vector<std::unique_ptr<Info>>>
+mrdox::Expected<std::vector<std::unique_ptr<Info>>>
 readBitcode(llvm::StringRef bitcode);
 
 /** Store a key/value pair in the tool results.

source/AST/BitcodeReader.cpp

@@ -14,12 +14,13 @@
 #include "DecodeRecord.hpp"
 #include "Support/Debug.hpp"
 #include "Support/Error.hpp"
+#include <mrdox/Support/Expected.hpp>
 
 namespace clang {
 namespace mrdox {
 
 // Entry point
-Expected<std::vector<std::unique_ptr<Info>>>
+mrdox::Expected<std::vector<std::unique_ptr<Info>>>
 BitcodeReader::
 getInfos()
 {
@@ -173,7 +174,7 @@ readBlockInfoBlock()
 //------------------------------------------------
 
 template<class T>
-Expected<std::unique_ptr<Info>>
+mrdox::Expected<std::unique_ptr<Info>>
 BitcodeReader::
 readInfo(
     unsigned ID)
@@ -298,7 +299,7 @@ skipUntilRecordOrBlock(
 //------------------------------------------------
 
 // Calls readBlock to read each block in the given bitcode.
-Expected<std::vector<std::unique_ptr<Info>>>
+mrdox::Expected<std::vector<std::unique_ptr<Info>>>
 readBitcode(llvm::StringRef bitcode)
 {
     llvm::BitstreamCursor Stream(bitcode);

source/AST/BitcodeReader.hpp

@@ -46,7 +46,7 @@ class BitcodeReader
     // Main entry point, calls readBlock to read each block in the given stream.
     auto
     getInfos() ->
-        Expected<std::vector<std::unique_ptr<Info>>>;
+        mrdox::Expected<std::vector<std::unique_ptr<Info>>>;
 public:
     struct AnyBlock;
 
@@ -64,7 +64,7 @@ class BitcodeReader
     /** Return the next decoded Info from the stream.
     */
     template<class T>
-    Expected<std::unique_ptr<Info>>
+    mrdox::Expected<std::unique_ptr<Info>>
     readInfo(unsigned ID);
 
     /** Read a single block.

source/Corpus.cpp

@@ -9,55 +9,15 @@
 // Official repository: https://github.com/cppalliance/mrdox
 //
 
-#include "CorpusImpl.hpp"
 #include "ConfigImpl.hpp"
-#include "AST/Bitcode.hpp"
-#include "AST/FrontendAction.hpp"
-#include "Metadata/Reduce.hpp"
-#include "Support/Error.hpp"
+#include <mrdox/Corpus.hpp>
 #include <mrdox/Support/Report.hpp>
 #include <mrdox/Metadata.hpp>
-#include <clang/Tooling/ArgumentsAdjusters.h>
-#include <clang/Tooling/CommonOptionsParser.h>
-#include <llvm/Bitstream/BitstreamReader.h>
-#include <llvm/Support/Mutex.h>
 #include <cassert>
 
 namespace clang {
 namespace mrdox {
 
-// A standalone function to call to merge a vector of infos into one.
-// This assumes that all infos in the vector are of the same type, and will fail
-// if they are different.
-// Dispatch function.
-llvm::Expected<std::unique_ptr<Info>>
-mergeInfos(std::vector<std::unique_ptr<Info>>& Values)
-{
-    if (Values.empty() || !Values[0])
-        return llvm::createStringError(llvm::inconvertibleErrorCode(),
-            "no info values to merge");
-
-    switch (Values[0]->Kind) {
-    case InfoKind::Namespace:
-        return reduce<NamespaceInfo>(Values);
-    case InfoKind::Record:
-        return reduce<RecordInfo>(Values);
-    case InfoKind::Enum:
-        return reduce<EnumInfo>(Values);
-    case InfoKind::Function:
-        return reduce<FunctionInfo>(Values);
-    case InfoKind::Typedef:
-        return reduce<TypedefInfo>(Values);
-    case InfoKind::Variable:
-        return reduce<VarInfo>(Values);
-    case InfoKind::Field:
-        return reduce<FieldInfo>(Values);
-    default:
-        return llvm::createStringError(llvm::inconvertibleErrorCode(),
-            "unexpected info type");
-    }
-}
-
 //------------------------------------------------
 
 Corpus::~Corpus() noexcept = default;
@@ -285,113 +245,6 @@ traverse(
 //
 //------------------------------------------------
 
-Expected<std::unique_ptr<Corpus>>
-Corpus::
-build(
-    tooling::ToolExecutor& ex,
-    std::shared_ptr<Config const> config_)
-{
-    auto config = std::dynamic_pointer_cast<ConfigImpl const>(config_);
-    auto corpus = std::make_unique<CorpusImpl>(config);
-
-    // Build arguments adjuster
-    tooling::ArgumentsAdjuster ArgAdjuster;
-    {
-        for(auto const& define : config->additionalDefines_)
-        {
-            std::string s;
-            llvm::raw_string_ostream os(s);
-            os << "-D" << define;
-            ArgAdjuster = tooling::combineAdjusters(
-                tooling::getInsertArgumentAdjuster(
-                    s.c_str(), tooling::ArgumentInsertPosition::END),
-                ArgAdjuster);
-        }
-    }
-
-    // Traverse the AST for all translation units
-    // and emit serializd bitcode into tool results.
-    // This operation happens ona thread pool.
-    if(corpus->config.verboseOutput)
-        reportInfo("Mapping declarations");
-    if(auto err = ex.execute(
-        makeFrontendActionFactory(
-            *ex.getExecutionContext(), *config), ArgAdjuster))
-    {
-        if(! corpus->config.ignoreFailures)
-            return toError(std::move(err));
-        reportWarning("warning: mapping failed because ", toString(std::move(err)));
-    }
-
-    // Inject the global namespace
-    {
-        // default-constructed NamespaceInfo
-        // describes the global namespace
-        NamespaceInfo I;
-        insertBitcode(
-            *ex.getExecutionContext(),
-            writeBitcode(I));
-    }
-
-    // Collect the symbols. Each symbol will have
-    // a vector of one or more bitcodes. These will
-    // be merged later.
-    if(corpus->config.verboseOutput)
-        reportInfo("Collecting symbols");
-    auto bitcodes = collectBitcodes(ex);
-
-    // First reducing phase (reduce all decls into one info per decl).
-    if(corpus->config.verboseOutput)
-        reportInfo("Reducing {} declarations", bitcodes.size());
-    std::atomic<bool> GotFailure;
-    GotFailure = false;
-    corpus->config.parallelForEach(
-        bitcodes,
-        [&](auto& Group)
-        {
-            // One or more Info for the same symbol ID
-            std::vector<std::unique_ptr<Info>> Infos;
-
-            // Each Bitcode can have multiple Infos
-            for (auto& bitcode : Group.getValue())
-            {
-                auto infos = readBitcode(bitcode);
-                if(! infos)
-                {
-                    reportError(infos.getError(), "read bitcode");
-                    GotFailure = true;
-                    return;
-                }
-                std::move(
-                    infos->begin(),
-                    infos->end(),
-                    std::back_inserter(Infos));
-            }
-
-            auto merged = mergeInfos(Infos);
-            if(! merged)
-            {
-                reportError(toError(merged.takeError()), "merge metadata");
-                GotFailure = true;
-                return;
-            }
-
-            std::unique_ptr<Info> I(merged.get().release());
-            Assert(Group.getKey() == I->id);
-            corpus->insert(std::move(I));
-        });
-
-    if(corpus->config.verboseOutput)
-        llvm::outs() << "Collected " << corpus->InfoMap.size() << " symbols.\n";
-
-    if(GotFailure)
-        return Error("multiple errors occurred");
-
-    corpus->canonicalize();
-
-    return corpus;
-}
-
 // KRYSTIAN NOTE: temporary
 std::string&
 Corpus::