feat: test test test

Author: indietyp

libs/@local/graph/api/src/rest/hashql/compile.rs

@@ -130,6 +130,7 @@ impl<'heap> Compilation<'heap> {
                 HashQlDiagnosticCategory::Mir(MirDiagnosticCategory::Reify(category))
             })
             .with_diagnostics(advisories)?;
+        scratch.reset();
 
         // Lower the MIR
         let Success {

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

@@ -11,6 +11,7 @@
     macro_metavar_expr_concat,
     never_type,
     const_trait_impl,
+    stmt_expr_attributes,
 
     // Library Features
     allocator_api,

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

@@ -1,6 +1,6 @@
 use core::alloc::Allocator;
 
-use hashql_core::{id::Id as _, r#type::kind::TypeKind, value::Primitive};
+use hashql_core::{id::Id as _, span::Spanned, r#type::kind::TypeKind, value::Primitive};
 use hashql_hir::{
     node::{
         Node,
@@ -23,6 +23,7 @@ use crate::{
         operand::Operand,
         place::{FieldIndex, Place, Projection, ProjectionKind},
     },
+    def::DefId,
     interpret::value::{Int, TryFromPrimitiveError},
     reify::{
         error::{field_index_too_large, local_variable_unmapped},
@@ -157,16 +158,42 @@ impl<'heap, A: Allocator, S: Allocator> Reifier<'_, '_, '_, '_, 'heap, A, S> {
         }
     }
 
-    pub(super) fn qualified_variable(&mut self, path: QualifiedPath<'heap>, requires_thunk: bool) {
-        todo!()
+    pub(super) fn operand_qualified_variable(
+        &mut self,
+        node: Node<'heap>,
+        path: QualifiedPath<'heap>,
+    ) -> Option<DefId> {
+        let synthetic = self.state.synthetics.find_or_insert(
+            self.context,
+            &mut self.state.diagnostics,
+            Spanned {
+                span: node.span,
+                value: node.id,
+            },
+            path,
+        )?;
+
+        // The value is called as a thunk, and therefore must be generated as such
+        let thunk = synthetic.thunk(self.context.bodies, self.context.mir.heap);
+        Some(thunk)
     }
 
     pub(super) fn operand(&mut self, node: Node<'heap>) -> Operand<'heap> {
         match node.kind {
-            NodeKind::Variable(Variable::Qualified(_)) => {
-                self.state
-                    .diagnostics
-                    .push(external_modules_unsupported(node.span).generalize());
+            NodeKind::Variable(Variable::Qualified(variable)) => {
+                let diagnostics = self.state.diagnostics.critical();
+
+                if let Some(thunk) = self.operand_qualified_variable(node, variable.path) {
+                    return Operand::Constant(Constant::FnPtr(thunk));
+                }
+
+                // The variable used is not a qualified variable, and therefore we must issue a
+                // diagnostic.
+                if diagnostics == self.state.diagnostics.critical() {
+                    self.state
+                        .diagnostics
+                        .push(external_modules_unsupported(node.span).generalize());
+                }
 
                 // Return a bogus value so that lowering can continue
                 // In the future this would be a simple FnPtr

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

@@ -44,6 +44,7 @@ use self::{
     error::{
         expected_anf_thunk, expected_anf_variable, external_modules_unsupported, local_not_thunk,
     },
+    synthetic::Synthetics,
     types::unwrap_closure_type,
 };
 use crate::{
@@ -107,6 +108,9 @@ struct CrossCompileState<'heap, S: Allocator> {
     /// Mapping of variable IDs to their thunk definitions.
     thunks: Thunks<S>,
 
+    /// Synthetic bodies that have been generated during reification.
+    synthetics: Synthetics<S>,
+
     /// Collection of diagnostics encountered during reification.
     diagnostics: ReifyDiagnosticIssues,
 
@@ -507,6 +511,7 @@ pub fn from_hir<'heap, A: Allocator, S: Allocator + Clone>(
     };
     let mut state = CrossCompileState {
         thunks,
+        synthetics: Synthetics::new_in(context.scratch.clone()),
         ctor: FastHashMap::default(),
         diagnostics: ReifyDiagnosticIssues::new(),
         var_pool: MixedBitSetPool::with_recycler_in(

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

@@ -2,6 +2,7 @@ use core::alloc::Allocator;
 
 use hashql_core::{
     id::{Id as _, IdVec},
+    span::Spanned,
     symbol::sym,
     r#type::{TypeBuilder, Typed, builder},
     value::Primitive,
@@ -17,6 +18,7 @@ use hashql_hir::node::{
         BinaryOperation, InputOperation, Operation, TypeConstructor, TypeOperation, UnaryOperation,
     },
     thunk::Thunk,
+    variable::Variable,
 };
 
 use super::{
@@ -200,6 +202,10 @@ impl<'mir, 'heap, A: Allocator, S: Allocator> Reifier<'_, 'mir, '_, '_, 'heap, A
         function: Node<'heap>,
         call_arguments: &[CallArgument<'heap>],
     ) -> RValue<'heap> {
+        if let Some(value) = self.rvalue_call_thin_specialize(function, call_arguments) {
+            return value;
+        }
+
         let mut arguments = IdVec::with_capacity_in(call_arguments.len(), self.context.mir.heap);
 
         for CallArgument { span: _, value } in call_arguments {
@@ -214,6 +220,57 @@ impl<'mir, 'heap, A: Allocator, S: Allocator> Reifier<'_, 'mir, '_, '_, 'heap, A
         })
     }
 
+    /// Attempts to beta-reduce a thin call to a qualified intrinsic into a closure aggregate.
+    ///
+    /// The thunking phase wraps every qualified variable in `Call(Thin, Qualified(...), [])`.
+    /// When the target is a known intrinsic, this produces the closure aggregate directly
+    /// instead of going through a thunk body that later passes would eliminate.
+    ///
+    /// Returns [`None`] if the call has arguments, the target is not a qualified variable,
+    /// or the path is not a known intrinsic.
+    fn rvalue_call_thin_specialize(
+        &mut self,
+        function: Node<'heap>,
+        call_arguments: &[CallArgument<'heap>],
+    ) -> Option<RValue<'heap>> {
+        if !call_arguments.is_empty() {
+            return None;
+        }
+
+        let NodeKind::Variable(Variable::Qualified(variable)) = function.kind else {
+            return None;
+        };
+
+        let diagnostics = self.state.diagnostics.critical();
+
+        let Some(synthetic) = self.state.synthetics.find_or_insert(
+            self.context,
+            &mut self.state.diagnostics,
+            Spanned {
+                span: function.span,
+                value: function.id,
+            },
+            variable.path,
+        ) else {
+            // A diagnostic was already emitted (e.g. non-first-classable intrinsic).
+            // Return a bogus value to prevent the fallback from emitting a duplicate.
+            if diagnostics != self.state.diagnostics.critical() {
+                return Some(RValue::Load(Operand::Constant(Constant::Unit)));
+            }
+
+            return None;
+        };
+
+        let mut operands = IdVec::with_capacity_in(2, self.context.mir.heap);
+        operands.push(Operand::Constant(Constant::FnPtr(synthetic.body)));
+        operands.push(Operand::Constant(Constant::Unit));
+
+        Some(RValue::Aggregate(Aggregate {
+            kind: AggregateKind::Closure,
+            operands,
+        }))
+    }
+
     fn rvalue_call_fat(
         &mut self,
         function: Node<'heap>,