Function getCurrentCoverageRegions

src/Common/CoverageCollection.cpp:332–385

}

CurrentCoverageRegions getCurrentCoverageRegions()
{
    ensureCoverageMapLoaded();

    auto name_refs = getCurrentCoveredNameRefs();

    /// Collect unique (file, line_start, line_end) triples — same dedup logic as collectAndInsertCoverage.
    struct LineKey
    {
        std::string file;
        uint32_t line_start;
        uint32_t line_end;

        bool operator==(const LineKey & o) const
        {
            return line_start == o.line_start && line_end == o.line_end && file == o.file;
        }
    };
    struct LineKeyHash
    {
        std::size_t operator()(const LineKey & k) const
        {
            std::size_t h = std::hash<std::string>{}(k.file);
            h ^= std::hash<uint32_t>{}(k.line_start) + 0x9e3779b9u + (h << 6) + (h >> 2);
            h ^= std::hash<uint32_t>{}(k.line_end)   + 0x9e3779b9u + (h << 6) + (h >> 2);
            return h;
        }
    };

    std::unordered_map<LineKey, bool, LineKeyHash> seen;
    seen.reserve(name_refs.size());

    CurrentCoverageRegions out;
    for (const auto & [name_hash, func_hash, counter_id, min_depth] : name_refs)
    {
        const auto it = g_coverage_map.find(CoverageKey{name_hash, func_hash, counter_id});
        if (it == g_coverage_map.end())
            continue;

        const CoverageRegion & region = it->second;
        if (region.file.empty() || region.line_start == 0)
            continue;

        LineKey key{region.file, region.line_start, region.line_end};
        if (!seen.emplace(key, true).second)
            continue;

        out.files.push_back(region.file);
        out.line_starts.push_back(region.line_start);
        out.line_ends.push_back(region.line_end);
    }

    return out;
}

}