ast: give nast pools stable element addresses

Arena pools were std::vector, so push_back could reallocate and move
existing elements. That breaks

    x->vec.push_back(parse_type());

because the reference to x->vec is resolved before the argument runs,
and the argument allocates into the same pool. Binding the result to a
temporary first fixes each site, but the hazard is reintroduced by any
new call written in that shape.

StablePool appends fixed-size blocks instead, so elements never move and
the shape is safe by construction. std::deque would also do this per the
standard, but MSVC uses one element per block for types over 8 bytes.

Chunk size 8 measured over 306 example files: 9,147KB allocated at 20.2%
waste, against 8,763KB / 16.4% for the vector version, and no measurable
time difference (1541ms vs 1692ms best of five). Larger chunks only cost
memory - 32 reaches 45.3% waste at the same speed.

The vector version reported 93,985 nodes over the corpus where this one
reports 93,540; ASan attributes the difference to the invalidated
writes, so the old counts were reading freed memory.

from_json takes a json_array concept rather than a std::vector overload,
and the pool iterator carries difference_type and post-increment so
as_json can pass it to futils' Stringer as a range.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: on-keyday

src/core/nast/from_json.h

@@ -3,7 +3,9 @@
 #include "nodes.h"
 
 #include <json/json_export.h>
+#include <concepts>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 // Arena::as_json の逆。ebmgen/json_conv.cpp と同じく futils::json::JSON を読むが、
@@ -13,9 +15,20 @@ namespace brgen::nast {
 
     using JSON = futils::json::JSON;
 
-    // for_each_field 版が vector を含みうるので、こちらだけ先に宣言する
+    // 添字で埋められる列。std::vector と StablePool の両方が該当する。
+    // std::string も同じ操作を持つので明示的に除く。
     template <class V>
-    bool read_json(const JSON& j, std::vector<V>& v);
+    concept json_array = !std::is_same_v<V, std::string> && requires(V v) {
+        typename V::value_type;
+        v.clear();
+        v.resize(std::size_t{});
+        { v.size() } -> std::convertible_to<std::size_t>;
+        v[std::size_t{}];
+    };
+
+    // for_each_field 版が列を含みうるので、こちらだけ先に宣言する
+    template <json_array V>
+    bool read_json(const JSON& j, V& v);
 
     inline bool read_json(const JSON& j, std::string& v) {
         return j.as_string(v);
@@ -108,8 +121,8 @@ namespace brgen::nast {
         return ok;
     }
 
-    template <class V>
-    bool read_json(const JSON& j, std::vector<V>& v) {
+    template <json_array V>
+    bool read_json(const JSON& j, V& v) {
         if (!j.is_array()) {
             return false;
         }

src/core/nast/gen/arena.py

@@ -83,7 +83,9 @@ def emit_arena(w: Writer, schema: Schema) -> None:
         if node.get("abstract"):
             continue
         w.write("   private:\n")
-        w.write("    std::vector<NodeData<", name, ">> data_", name, ";\n")
+        # vector だと push_back の再確保で既存要素が動き、
+        # x->vec.push_back(f()) の f() が同じプールへ確保したときに壊れる (pool.h)
+        w.write("    StablePool<NodeData<", name, ">> data_", name, ";\n")
         as_json.write('        obj_("data_', name, '",data_', name, ");\n")
         w.write("   public:\n")
         w.write("    template<>\n")

src/core/nast/nodes.json

@@ -11,7 +11,8 @@
         "<string>",
         "<type_traits>",
         "\"../lexer/token.h\"",
-        "<utility>"
+        "<utility>",
+        "\"pool.h\""
     ],
     "types": {
         "std::uint32_t": {

src/core/nast/pool.h

@@ -0,0 +1,127 @@
+/*license*/
+#pragma once
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+#include <memory>
+#include <vector>
+
+// 要素のアドレスが動かない可変長配列。
+//
+// std::vector だと push_back の再確保で既存要素が移動するため、
+//     x->vec.push_back(f());   // f() が同じプールに確保すると x->vec が無効化される
+// のような式が静かに壊れる。Ref は -> のたびに引き直すが、1 つの式の中では
+// 引き直さないので防げない。ここは固定長ブロックを継ぎ足すだけなので要素は動かない。
+//
+// std::deque でも規格上は参照が保たれるが、MSVC は 8 バイトを超える型で
+// 1 ブロック 1 要素になり (deque の _Block_size)、ノード 1 個ごとに確保が走る。
+// 既定のブロック要素数。計測して決める (build.py --chunk で上書きできる)。
+#ifndef NAST_POOL_CHUNK
+#define NAST_POOL_CHUNK 8
+#endif
+
+namespace brgen::nast {
+
+    template <class T, std::size_t ChunkSize = NAST_POOL_CHUNK>
+    struct StablePool {
+        using value_type = T;
+        static constexpr std::size_t chunk_size = ChunkSize;
+
+       private:
+        std::vector<std::unique_ptr<T[]>> chunks_;
+        std::size_t size_ = 0;
+
+       public:
+        constexpr std::size_t size() const {
+            return size_;
+        }
+
+        constexpr std::size_t capacity() const {
+            return chunks_.size() * ChunkSize;
+        }
+
+        constexpr bool empty() const {
+            return size_ == 0;
+        }
+
+        constexpr T& operator[](std::size_t i) {
+            return chunks_[i / ChunkSize][i % ChunkSize];
+        }
+
+        constexpr const T& operator[](std::size_t i) const {
+            return chunks_[i / ChunkSize][i % ChunkSize];
+        }
+
+        void push_back(T v) {
+            if (size_ == capacity()) {
+                chunks_.push_back(std::make_unique<T[]>(ChunkSize));
+            }
+            (*this)[size_] = std::move(v);
+            size_++;
+        }
+
+        void clear() {
+            chunks_.clear();
+            size_ = 0;
+        }
+
+        void resize(std::size_t n) {
+            while (size_ < n) {
+                push_back(T{});
+            }
+            // 縮小はブロックを返さない。要素のアドレスを動かさないため。
+            size_ = n;
+        }
+
+        // as_json が futils の Stringer に渡すので std::ranges::range を満たす必要がある。
+        // weakly_incrementable が difference_type と後置 ++ を要求する。
+        template <class P, class V>
+        struct iter {
+            using value_type = std::remove_const_t<V>;
+            using difference_type = std::ptrdiff_t;
+
+            P* pool = nullptr;
+            std::size_t i = 0;
+
+            constexpr V& operator*() const {
+                return (*pool)[i];
+            }
+
+            constexpr iter& operator++() {
+                i++;
+                return *this;
+            }
+
+            constexpr iter operator++(int) {
+                auto copy = *this;
+                i++;
+                return copy;
+            }
+
+            constexpr bool operator!=(const iter& o) const {
+                return i != o.i;
+            }
+
+            constexpr bool operator==(const iter& o) const {
+                return i == o.i;
+            }
+        };
+
+        constexpr auto begin() {
+            return iter<StablePool, T>{this, 0};
+        }
+
+        constexpr auto end() {
+            return iter<StablePool, T>{this, size_};
+        }
+
+        constexpr auto begin() const {
+            return iter<const StablePool, const T>{this, 0};
+        }
+
+        constexpr auto end() const {
+            return iter<const StablePool, const T>{this, size_};
+        }
+    };
+
+}  // namespace brgen::nast