BE-208: HashQL: Introduce graph data structures (#8060)

Author: indietyp

libs/@local/graph/api/src/rest/entity_query_request.rs

@@ -39,7 +39,7 @@ use hash_graph_store::{
 };
 use hashql_ast::error::AstDiagnosticCategory;
 use hashql_core::{
-    collections::fast_hash_map,
+    collections::fast_hash_map_with_capacity,
     heap::Heap,
     module::ModuleRegistry,
     span::{SpanId, SpanTable},
@@ -399,7 +399,7 @@ impl<'q> EntityQuery<'q> {
 
         // Evaluate the HIR
         // TODO: https://linear.app/hash/issue/BE-41/hashql-expose-input-in-graph-api
-        let inputs = fast_hash_map(0);
+        let inputs = fast_hash_map_with_capacity(0);
         let mut compiler = hashql_eval::graph::read::GraphReadCompiler::new(heap, &inputs);
 
         compiler.visit_node(hir);

libs/@local/hashql/ast/src/lowering/special_form_expander/mod.rs

@@ -6,7 +6,7 @@ use core::{
 };
 
 use hashql_core::{
-    collections::{FastHashMap, fast_hash_map},
+    collections::{FastHashMap, fast_hash_map_with_capacity},
     heap::{self, Heap},
     span::SpanId,
     symbol::{Ident, IdentKind},
@@ -520,7 +520,7 @@ impl<'heap> SpecialFormExpander<'heap> {
     ) -> Option<heap::Vec<'heap, GenericConstraint<'heap>>> {
         let mut constraints = self.heap.vec(Some(arguments.len()));
 
-        let mut seen = fast_hash_map(arguments.len());
+        let mut seen = fast_hash_map_with_capacity(arguments.len());
 
         for argument in arguments {
             match argument {

libs/@local/hashql/ast/src/lowering/type_extractor/contractive.rs

@@ -1,5 +1,5 @@
 use hashql_core::{
-    collections::{FastHashSet, fast_hash_set},
+    collections::{FastHashSet, fast_hash_set_with_capacity},
     intern::Interned,
     span::SpanId,
     r#type::{
@@ -112,7 +112,7 @@ pub(crate) fn is_contractive<'heap>(
     root: Interned<'heap, TypeKind<'heap>>,
 ) -> Result<(), SpanId> {
     // if this ever becomes a bottleneck, consider using the temporary heap
-    let mut visited = fast_hash_set(4);
+    let mut visited = fast_hash_set_with_capacity(4);
 
     is_contractive_kind(env, root, root, &mut visited)
 }

libs/@local/hashql/ast/src/lowering/type_extractor/definition.rs

@@ -2,7 +2,7 @@ use alloc::borrow::Cow;
 use core::mem;
 
 use hashql_core::{
-    collections::{FastHashMap, TinyVec, fast_hash_map},
+    collections::{FastHashMap, TinyVec, fast_hash_map_with_capacity},
     module::{
         ModuleRegistry,
         locals::{Local, Locals, TypeLocals},
@@ -154,7 +154,7 @@ impl<'env, 'heap> TypeDefinitionExtractor<'env, 'heap> {
             }
         }
 
-        let mut constraints = fast_hash_map(allocated_generic_constraints);
+        let mut constraints = fast_hash_map_with_capacity(allocated_generic_constraints);
 
         let mut unit = TranslationUnit {
             env: self.environment,

libs/@local/hashql/ast/src/lowering/type_extractor/translate.rs

@@ -8,7 +8,7 @@
 use alloc::borrow::Cow;
 
 use hashql_core::{
-    collections::{FastHashMap, FastHashSet, SmallVec, TinyVec, fast_hash_set},
+    collections::{FastHashMap, FastHashSet, SmallVec, TinyVec, fast_hash_set_with_capacity},
     intern::Provisioned,
     module::{
         ModuleRegistry, Universe,
@@ -56,7 +56,7 @@ impl<'env, 'heap> GenericArgumentVisitor<'env, 'heap> {
     fn new(scope: &'env [GenericArgumentReference<'heap>]) -> Self {
         Self {
             scope,
-            used: fast_hash_set(scope.len()),
+            used: fast_hash_set_with_capacity(scope.len()),
         }
     }
 }

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

@@ -21,13 +21,22 @@ pub type FastHashSetEntry<'map, T, A = Global> =
 
 #[inline]
 #[must_use]
-pub fn fast_hash_map<K, V>(capacity: usize) -> FastHashMap<K, V> {
-    FastHashMap::with_capacity_and_hasher(capacity, foldhash::fast::RandomState::default())
+pub fn fast_hash_map_in<K, V, A: Allocator>(allocator: A) -> FastHashMap<K, V, A> {
+    FastHashMap::with_hasher_in(foldhash::fast::RandomState::default(), allocator)
 }
 
 #[inline]
 #[must_use]
-pub fn fast_hash_map_in<K, V, A: Allocator>(capacity: usize, allocator: A) -> FastHashMap<K, V, A> {
+pub fn fast_hash_map<K, V>() -> FastHashMap<K, V> {
+    fast_hash_map_in(Global)
+}
+
+#[inline]
+#[must_use]
+pub fn fast_hash_map_with_capacity_in<K, V, A: Allocator>(
+    capacity: usize,
+    allocator: A,
+) -> FastHashMap<K, V, A> {
     FastHashMap::with_capacity_and_hasher_in(
         capacity,
         foldhash::fast::RandomState::default(),
@@ -37,19 +46,40 @@ pub fn fast_hash_map_in<K, V, A: Allocator>(capacity: usize, allocator: A) -> Fa
 
 #[inline]
 #[must_use]
-pub fn fast_hash_set<T>(capacity: usize) -> FastHashSet<T> {
-    FastHashSet::with_capacity_and_hasher(capacity, foldhash::fast::RandomState::default())
+pub fn fast_hash_map_with_capacity<K, V>(capacity: usize) -> FastHashMap<K, V> {
+    fast_hash_map_with_capacity_in(capacity, Global)
 }
 
 #[inline]
 #[must_use]
-pub fn fast_hash_set_in<T, A: Allocator>(capacity: usize, allocator: A) -> FastHashSet<T, A> {
+pub fn fast_hash_set_with_capacity_in<T, A: Allocator>(
+    capacity: usize,
+    allocator: A,
+) -> FastHashSet<T, A> {
     FastHashSet::with_capacity_and_hasher_in(
         capacity,
         foldhash::fast::RandomState::default(),
         allocator,
     )
 }
 
+#[inline]
+#[must_use]
+pub fn fast_hash_set_in<T, A: Allocator>(allocator: A) -> FastHashSet<T, A> {
+    FastHashSet::with_hasher_in(foldhash::fast::RandomState::default(), allocator)
+}
+
+#[inline]
+#[must_use]
+pub fn fast_hash_set_with_capacity<T>(capacity: usize) -> FastHashSet<T> {
+    fast_hash_set_with_capacity_in(capacity, Global)
+}
+
+#[inline]
+#[must_use]
+pub fn fast_hash_set<T>() -> FastHashSet<T> {
+    fast_hash_set_in(Global)
+}
+
 pub type TinyVec<T> = smallvec::SmallVec<T, 4>;
 pub type SmallVec<T> = smallvec::SmallVec<T, 16>;