{libutil,libexpr}: Move pos-idx,pos-table code to libutil

All of this code doesn't actually depend on anything from
libexpr. Because Pos is so tigtly coupled with Error, it
makes sense to have in the same library.

src/libexpr/meson.build

@@ -172,8 +172,6 @@ headers = [config_h] + files(
   # internal: 'lexer-helpers.hh',
   'nixexpr.hh',
   'parser-state.hh',
-  'pos-idx.hh',
-  'pos-table.hh',
   'primops.hh',
   'print-ambiguous.hh',
   'print-options.hh',

src/libexpr/nixexpr.cc

@@ -601,41 +601,6 @@ void ExprLambda::setDocComment(DocComment docComment) {
     }
 };
 
-
-
-/* Position table. */
-
-Pos PosTable::operator[](PosIdx p) const
-{
-    auto origin = resolve(p);
-    if (!origin)
-        return {};
-
-    const auto offset = origin->offsetOf(p);
-
-    Pos result{0, 0, origin->origin};
-    auto lines = this->lines.lock();
-    auto linesForInput = (*lines)[origin->offset];
-
-    if (linesForInput.empty()) {
-        auto source = result.getSource().value_or("");
-        const char * begin = source.data();
-        for (Pos::LinesIterator it(source), end; it != end; it++)
-            linesForInput.push_back(it->data() - begin);
-        if (linesForInput.empty())
-            linesForInput.push_back(0);
-    }
-    // as above: the first line starts at byte 0 and is always present
-    auto lineStartOffset = std::prev(
-        std::upper_bound(linesForInput.begin(), linesForInput.end(), offset));
-
-    result.line = 1 + (lineStartOffset - linesForInput.begin());
-    result.column = 1 + (offset - *lineStartOffset);
-    return result;
-}
-
-
-
 /* Symbol table. */
 
 size_t SymbolTable::totalSize() const

src/libexpr/pos-idx.hh

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <cinttypes>
-#include <functional>
-
-namespace nix {
-
-class PosIdx
-{
-    friend struct LazyPosAcessors;
-    friend class PosTable;
-    friend class std::hash<PosIdx>;
-
-private:
-    uint32_t id;
-
-    explicit PosIdx(uint32_t id)
-        : id(id)
-    {
-    }
-
-public:
-    PosIdx()
-        : id(0)
-    {
-    }
-
-    explicit operator bool() const
-    {
-        return id > 0;
-    }
-
-    auto operator<=>(const PosIdx other) const
-    {
-        return id <=> other.id;
-    }
-
-    bool operator==(const PosIdx other) const
-    {
-        return id == other.id;
-    }
-
-    size_t hash() const noexcept
-    {
-        return std::hash<uint32_t>{}(id);
-    }
-};
-
-inline PosIdx noPos = {};
-
-}
-
-namespace std {
-
-template<>
-struct hash<nix::PosIdx>
-{
-    std::size_t operator()(nix::PosIdx pos) const noexcept
-    {
-        return pos.hash();
-    }
-};
-
-} // namespace std

src/libexpr/pos-table.hh

@@ -1,85 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <vector>
-
-#include "pos-idx.hh"
-#include "position.hh"
-#include "sync.hh"
-
-namespace nix {
-
-class PosTable
-{
-public:
-    class Origin
-    {
-        friend PosTable;
-    private:
-        uint32_t offset;
-
-        Origin(Pos::Origin origin, uint32_t offset, size_t size):
-            offset(offset), origin(origin), size(size)
-        {}
-
-    public:
-        const Pos::Origin origin;
-        const size_t size;
-
-        uint32_t offsetOf(PosIdx p) const
-        {
-            return p.id - 1 - offset;
-        }
-    };
-
-private:
-    using Lines = std::vector<uint32_t>;
-
-    std::map<uint32_t, Origin> origins;
-    mutable Sync<std::map<uint32_t, Lines>> lines;
-
-    const Origin * resolve(PosIdx p) const
-    {
-        if (p.id == 0)
-            return nullptr;
-
-        const auto idx = p.id - 1;
-        /* we want the last key <= idx, so we'll take prev(first key > idx).
-            this is guaranteed to never rewind origin.begin because the first
-            key is always 0. */
-        const auto pastOrigin = origins.upper_bound(idx);
-        return &std::prev(pastOrigin)->second;
-    }
-
-public:
-    Origin addOrigin(Pos::Origin origin, size_t size)
-    {
-        uint32_t offset = 0;
-        if (auto it = origins.rbegin(); it != origins.rend())
-            offset = it->first + it->second.size;
-        // +1 because all PosIdx are offset by 1 to begin with, and
-        // another +1 to ensure that all origins can point to EOF, eg
-        // on (invalid) empty inputs.
-        if (2 + offset + size < offset)
-            return Origin{origin, offset, 0};
-        return origins.emplace(offset, Origin{origin, offset, size}).first->second;
-    }
-
-    PosIdx add(const Origin & origin, size_t offset)
-    {
-        if (offset > origin.size)
-            return PosIdx();
-        return PosIdx(1 + origin.offset + offset);
-    }
-
-    Pos operator[](PosIdx p) const;
-
-    Pos::Origin originOf(PosIdx p) const
-    {
-        if (auto o = resolve(p))
-            return o->origin;
-        return std::monostate{};
-    }
-};
-
-}