feat: checkpoint

Author: indietyp

libs/@local/hashql/core/src/collections/pool.rs

@@ -43,6 +43,8 @@
 //! assert_eq!(vec2.len(), 0);
 //! ```
 
+use std::alloc::{Allocator, Global};
+
 use crate::id::{Id, bit_vec::MixedBitSet};
 
 /// Trait for defining how objects are recycled, created, and prepared in a pool.
@@ -234,13 +236,13 @@ pub trait Recycler<T> {
 /// // Pool now contains 2 recycled vectors ready for reuse
 /// ```
 #[derive(Debug)]
-pub struct Pool<T, R> {
-    free: Vec<T>,
+pub struct Pool<T, R, A: Allocator = Global> {
+    free: Vec<T, A>,
     recycler: R,
     capacity: usize,
 }
 
-impl<T, R> Pool<T, R> {
+impl<T, R> Pool<T, R, Global> {
     /// Creates a new pool with the specified capacity and a default recycler.
     ///
     /// The `capacity` parameter sets the maximum number of objects that will be
@@ -278,16 +280,30 @@ impl<T, R> Pool<T, R> {
     /// let mut pool = MixedBitSetPool::<VarId>::with_recycler(5, recycler);
     /// ```
     pub fn with_recycler(capacity: usize, recycler: R) -> Self {
+        Self::with_recycler_in(capacity, recycler, Global)
+    }
+}
+
+impl<T, R, A: Allocator> Pool<T, R, A> {
+    pub fn new_in(capacity: usize, alloc: A) -> Self
+    where
+        R: Default,
+    {
+        Self::with_recycler_in(capacity, R::default(), alloc)
+    }
+
+    pub fn with_recycler_in(capacity: usize, recycler: R, alloc: A) -> Self {
         Self {
-            free: Vec::with_capacity(capacity),
+            free: Vec::with_capacity_in(capacity, alloc),
             recycler,
             capacity,
         }
     }
 }
 
-impl<T, R> Pool<T, R>
+impl<T, R, A> Pool<T, R, A>
 where
+    A: Allocator,
     R: Recycler<T>,
 {
     /// Changes the pool's capacity, adjusting internal storage as needed.
@@ -673,4 +689,4 @@ where
 /// // Return to pool for reuse
 /// pool.release(bitset);
 /// ```
-pub type MixedBitSetPool<I> = Pool<MixedBitSet<I>, MixedBitSetRecycler>;
+pub type MixedBitSetPool<I, A = Global> = Pool<MixedBitSet<I>, MixedBitSetRecycler, A>;

libs/@local/hashql/core/src/module/std_lib/core/json.rs

@@ -1,12 +1,39 @@
 use core::alloc::Allocator;
 
+use self::types::JsonPathDependencies;
 use crate::{
     module::std_lib::{
         CacheId, ItemDef, ModuleCache, ModuleDef, StandardLibraryContext, StandardLibraryModule,
     },
     symbol::{Symbol, sym},
 };
 
+pub mod types {
+    use crate::r#type::{TypeBuilder, TypeId};
+
+    // type JsonPathSegment = String | Integer;
+    #[must_use]
+    pub fn json_path_segment(ty: &TypeBuilder<'_, '_>) -> TypeId {
+        ty.union([ty.string(), ty.integer()])
+    }
+
+    pub struct JsonPathDependencies {
+        pub json_path_segment: TypeId,
+    }
+
+    // type JsonPath = JsonPathSegment[];
+    #[must_use]
+    pub fn json_path(
+        ty: &TypeBuilder<'_, '_>,
+        dependencies: Option<JsonPathDependencies>,
+    ) -> TypeId {
+        ty.list(dependencies.map_or_else(
+            || json_path_segment(ty),
+            |dependencies| dependencies.json_path_segment,
+        ))
+    }
+}
+
 pub(in crate::module::std_lib) struct Json {
     _dependencies: (),
 }
@@ -28,16 +55,19 @@ impl<'heap> StandardLibraryModule<'heap> for Json {
 
         // type JsonPathSegment = String | Integer;
         // Note: The type should be Natural instead, but this requires refinement types
-        let json_path_segment_ty = context
-            .ty
-            .union([context.ty.string(), context.ty.integer()]);
+        let json_path_segment_ty = self::types::json_path_segment(&context.ty);
         def.push(
             sym::JsonPathSegment,
             ItemDef::r#type(context.ty.env, json_path_segment_ty, &[]),
         );
 
         // type JsonPath = JsonPathSegment[];
-        let json_path_ty = context.ty.list(json_path_segment_ty);
+        let json_path_ty = self::types::json_path(
+            &context.ty,
+            Some(JsonPathDependencies {
+                json_path_segment: json_path_segment_ty,
+            }),
+        );
         def.push(
             sym::JsonPath,
             ItemDef::r#type(context.ty.env, json_path_ty, &[]),

libs/@local/hashql/core/src/module/std_lib/core/mod.rs

@@ -11,7 +11,7 @@ use crate::{
 pub(in crate::module::std_lib) mod bits;
 pub(in crate::module::std_lib) mod bool;
 pub(in crate::module::std_lib) mod cmp;
-pub(in crate::module::std_lib) mod json;
+pub mod json;
 pub(in crate::module::std_lib) mod math;
 pub mod option;
 pub(in crate::module::std_lib) mod result;

libs/@local/hashql/core/src/module/std_lib/graph/entity.rs

@@ -64,7 +64,9 @@ impl<'heap> StandardLibraryModule<'heap> for Entity {
             decl,
         );
 
-        // `property<T>(entity: Entity<T>, path: JsonPath) -> Option<?>`
+        // `property<T>(entity: Entity<T>, path: JsonPath) -> ?`
+        // TODO(BE-62): return `Option<?>` once pattern matching allows for option destructuring, to
+        // allow for proper comparison
         let decl = decl!(context;
             <T>(entity: context.ty.apply([(entity_ty.arguments[0].id, T)], entity_ty.id),
                 path: json_path_ty.id

libs/@local/hashql/mir/src/intrinsic.rs

@@ -1,7 +1,7 @@
 use hashql_core::{
     id::{Id, IdVec},
     intern::Interned,
-    module::std_lib::graph::types::knowledge::entity::types::entity,
+    module::std_lib::{core::json, graph::types::knowledge::entity::types::entity},
     span::SpanId,
     symbol::sym,
     r#type::{TypeBuilder, environment::Environment},
@@ -37,21 +37,21 @@ pub(crate) fn entity_property_access_body<'heap>(
     span: SpanId,
 ) -> Body<'heap> {
     // Intrinsic body for property access, we **cannot** mock this specific intrinsic, because it's
-    // semantics are - while expressible - compile-time. We cannot index into a struct at run-time
-    // from a runtime-defined value. We just can't. Meaning that indeed we must mock this specific
-    // intrinsic on all backends that support it.
+    // semantics are - while expressible - compile-time only. We cannot index into a struct at
+    // run-time from a runtime-defined value, without sacrifing correctness guarantees the MIR
+    // relies on. Meaning that indeed we must mock this specific intrinsic on all backends that
+    // support it.
     let builder = TypeBuilder::spanned(span, env);
 
-    let mut local_decls = IdVec::with_capacity_in(1, env.heap);
+    let mut local_decls = IdVec::with_capacity_in(2, env.heap);
     local_decls.push(LocalDecl {
         span,
         r#type: entity(&builder, builder.unknown(), None),
         name: Some(sym::entity),
     });
-    // TODO: we have a json path for exactly this
     local_decls.push(LocalDecl {
         span,
-        r#type: builder.list(builder.union([builder.string(), builder.integer()])),
+        r#type: json::types::json_path(&builder, None),
         name: Some(sym::pointer),
     });
 

libs/@local/hashql/mir/src/reify/atom.rs

@@ -6,7 +6,7 @@ use hashql_hir::node::{
     access::{Access, FieldAccess, IndexAccess},
     data::Data,
     kind::NodeKind,
-    variable::Variable,
+    variable::{QualifiedVariable, Variable},
 };
 
 use super::{
@@ -154,6 +154,11 @@ impl<'heap, A: Allocator, S: Allocator> Reifier<'_, '_, '_, '_, 'heap, A, S> {
         }
     }
 
+    fn qualified_path(&mut self, QualifiedVariable { path, arguments }: QualifiedVariable<'heap>) {
+        // For the path, we simply match against the tree of values that are supported
+        todo!()
+    }
+
     pub(super) fn operand(&mut self, node: Node<'heap>) -> Operand<'heap> {
         match node.kind {
             NodeKind::Variable(Variable::Qualified(_)) => {

libs/@local/hashql/mir/src/reify/mod.rs

@@ -112,7 +112,7 @@ struct CrossCompileState<'heap, S: Allocator> {
     /// Cache of already-created type constructors to avoid duplication.
     ctor: FastHashMap<Symbol<'heap>, DefId>,
 
-    var_pool: MixedBitSetPool<VarId>,
+    var_pool: MixedBitSetPool<VarId, S>,
 }
 
 /// The core reification engine that converts individual HIR nodes to MIR bodies.
@@ -508,11 +508,12 @@ pub fn from_hir<'heap, A: Allocator, S: Allocator + Clone>(
         thunks,
         ctor: FastHashMap::default(),
         diagnostics: ReifyDiagnosticIssues::new(),
-        var_pool: MixedBitSetPool::with_recycler(
+        var_pool: MixedBitSetPool::with_recycler_in(
             8,
             MixedBitSetRecycler {
                 domain_size: context.hir.counter.var.size(),
             },
+            context.scratch.clone(),
         ),
     };