Method path

libs/@local/hashql/hir/src/reify/mod.rs:375–423

(&mut self, path: Path<'heap>)

    }

    fn path(&mut self, path: Path<'heap>) -> Option<NodeKind<'heap>> {
        let span = path.span;
        let variable = match path.into_generic_ident() {
            Ok((ident, args)) => {
                // undeclared variables should have been resolved in the AST (import resolution)
                let binder = self.binder_scope[&ident.value];

                Variable::Local(LocalVariable {
                    id: Spanned {
                        span: ident.span,
                        value: binder,
                    },
                    arguments: self.path_segment_arguments(args)?,
                })
            }
            Err(mut path) => {
                if !path.rooted {
                    self.diagnostics.push(internal_error(
                        span,
                        "relative paths should have been resolved during import resolution",
                    ));
                    return None;
                }

                let arguments = mem::replace(
                    &mut path
                        .segments
                        .last_mut()
                        .unwrap_or_else(|| unreachable!())
                        .arguments,
                    Vec::new_in(self.context.heap), // capacity of 0 does not allocate
                );

                let mut segments = SmallVec::with_capacity(path.segments.len());
                for segment in path.segments {
                    segments.push(segment.name);
                }

                Variable::Qualified(QualifiedVariable {
                    path: QualifiedPath::new_unchecked(
                        self.context.interner.intern_idents(&segments),
                    ),
                    arguments: self.path_segment_arguments(arguments)?,
                })
            }
        };

        Some(NodeKind::Variable(variable))
    }

    fn let_expr(
        &mut self,