Method lower_impl

libs/@local/hashql/mir/src/reify/mod.rs:175–291

Core implementation for lowering HIR constructs to MIR bodies. This method handles the common logic for converting thunks, closures, and type constructors into MIR function bodies. It manages parameter binding, capture handling, and basic block construction. # Parameters - `source`: The type of construct being lowered (thunk, closure, constructor) - `span`: Source location for error reporting -

(
        mut self,
        source: Source<'heap>,
        span: SpanId,
        params: impl IntoIterator<Item = Typed<Binder<'heap>>>,
        returns: TypeId,
        captures: Option<(&MixedBitSet

    ///
    /// The definition ID of the newly created MIR body.
    fn lower_impl(
        mut self,
        source: Source<'heap>,
        span: SpanId,
        params: impl IntoIterator<Item = Typed<Binder<'heap>>>,
        returns: TypeId,
        captures: Option<(&MixedBitSet<VarId>, TypeId)>,
        on_block: impl FnOnce(&mut Self, &mut CurrentBlock<'mir, 'heap>) -> Spanned<Operand<'heap>>,
    ) -> DefId {
        let mut args = 0;

        // Closures and type constructors are fat pointers, the reason is that they are
        // constructible by users and therefore always correspond to a fat call.
        // In the future we might want to specialize `ctor` in a way that allows us to move them to
        // be thin calls (although that would require that we move functions into a separate type
        // from closures).
        let env = if matches!(
            source,
            Source::Closure(_, _) | Source::Ctor(_) | Source::GraphReadFilter(_)
        ) {
            let r#type = if let Some((_, type_id)) = captures {
                debug_assert_matches!(source, Source::Closure(..) | Source::GraphReadFilter(..));
                type_id
            } else {
                // In case there are no captures, the environment will always be a unit type (aka
                // Tuple).
                debug_assert_matches!(source, Source::Ctor(..));
                TypeBuilder::spanned(span, self.context.mir.env).tuple([] as [TypeId; 0])
            };

            let local = self.local_decls.push(LocalDecl {
                span,
                r#type,
                name: None,
            });

            args += 1;

            local
        } else {
            debug_assert!(captures.is_none());

            // ends up never being used
            Local::MAX
        };

        for Typed {
            value: Binder { id, span, name },
            r#type,
        } in params
        {
            let local = self.local_decls.push(LocalDecl { span, r#type, name });
            args += 1;

            self.locals.insert(id, local);
        }

        let mut block = CurrentBlock::new(self.context.mir.heap, self.context.mir.interner);