Method emit_expr

cranelift/isle/isle/src/codegen.rs:914–1048

(&self, ctx: &mut BodyContext<W>, result: BindingId)

    }

    fn emit_expr<W: Write>(&self, ctx: &mut BodyContext<W>, result: BindingId) -> std::fmt::Result {
        if ctx.is_bound.contains(&result) {
            return write!(ctx.out, "v{}", result.index());
        }

        let binding = &ctx.ruleset.bindings[result.index()];

        let call = |ctx: &mut BodyContext<W>,
                    term: TermId,
                    parameters: &[BindingId],
                    get_sig: fn(&Term, &TypeEnv) -> Option<ExternalSig>| {
            let termdata = &self.termenv.terms[term.index()];
            let sig = get_sig(termdata, self.typeenv).unwrap();
            if let &[ret_ty] = &sig.ret_tys[..] {
                let (is_ref, _) = self.ty(ret_ty);
                if is_ref {
                    ctx.set_ref(result, true);
                    write!(ctx.out, "&")?;
                }
            }
            write!(ctx.out, "{}(ctx", sig.full_name)?;
            debug_assert_eq!(parameters.len(), sig.param_tys.len());
            for (&parameter, &arg_ty) in parameters.iter().zip(sig.param_tys.iter()) {
                let (is_ref, _) = self.ty(arg_ty);
                write!(ctx.out, ", ")?;
                let (before, after) = match (is_ref, ctx.is_ref.contains(&parameter)) {
                    (false, true) => ("", ".clone()"),
                    (true, false) => ("&", ""),
                    _ => ("", ""),
                };
                write!(ctx.out, "{before}")?;
                self.emit_expr(ctx, parameter)?;
                write!(ctx.out, "{after}")?;
            }
            if let ReturnKind::Iterator = sig.ret_kind {
                write!(ctx.out, ", &mut v{}", result.index())?;
            }
            write!(ctx.out, ")")
        };

        let extract_fields = |ctx: &mut BodyContext<W>,
                              field_bindings: &[BindingId],
                              fields: &Fields|
         -> std::fmt::Result {
            if !field_bindings.is_empty() {
                ctx.begin_block()?;
                for (i, value) in field_bindings.iter().enumerate() {
                    let field_name = match fields {
                        Fields::Unit => panic!(),
                        Fields::Struct(fields) => {
                            Cow::Borrowed(&self.typeenv.syms[fields.fields[i].name.index()])
                        }
                        Fields::Tuple(_) => Cow::Owned(format!("{i}")),
                    };
                    write!(ctx.out, "{}{field_name}: ", &ctx.indent)?;
                    self.emit_expr(ctx, *value)?;
                    if ctx.is_ref.contains(value) {
                        write!(ctx.out, ".clone()")?;