mutate-managed-struct.rs

                let mut i: @item = fold::noop_fold_item(i, fld).take_unwrap();
                i.node = match i.node {
                    item_mod(ref m) => {
                        item_mod(self.with_scope(Some(i.ident), || {
                            debug!("Rewriting: with scope %?", i.ident);
                            fld.fold_mod(m)
                        }))
                    },
                    item_foreign_mod(ref foreign_module) => {
                        item_foreign_mod(self.with_scope(Some(i.ident), ||
                            foreign_mod {
                                items: foreign_module.items.iter().transform(|foreign_item| {
                                    match foreign_item.node {
                                        foreign_item_fn(_, _, ref generics) => {
                                            self.with_type_parameter_rib(
                                                HasTypeParameters(
                                                    generics, foreign_item.id, 0,
                                                    NormalRibKind),
                                                || fld.fold_foreign_item(*foreign_item))
                                        }
                                        foreign_item_static(*) => {
                                            fld.fold_foreign_item(*foreign_item)
                                        }
                                    }
                                }).collect(),
                                .. fld.fold_foreign_mod(foreign_module)
                            }
                        ))
                    },
                    n => n
                };
                Some(i)

mutate-managed-struct2.rs

                let i = fold::noop_fold_item(i, fld).take_unwrap();
                Some(@item { 
                    node: match i.node {
                        item_mod(ref m) => {
                            item_mod(self.with_scope(Some(i.ident), || {
                                debug!("Rewriting: with scope %?", i.ident);
                                fld.fold_mod(m)
                            }))
                        },
                        item_foreign_mod(ref foreign_module) => {
                            item_foreign_mod(self.with_scope(Some(i.ident), ||
                                foreign_mod {
                                    items: foreign_module.items.iter().transform(|foreign_item| {
                                        match foreign_item.node {
                                            foreign_item_fn(_, _, ref generics) => {
                                                self.with_type_parameter_rib(
                                                    HasTypeParameters(
                                                        generics, foreign_item.id, 0,
                                                        NormalRibKind),
                                                    || fld.fold_foreign_item(*foreign_item))
                                            }
                                            foreign_item_static(*) => {
                                                fld.fold_foreign_item(*foreign_item)
                                            }
                                        }
                                    }).collect(),
                                    .. fld.fold_foreign_mod(foreign_module)
                                }
                            ))
                        },
                        n => n
                    },
                    .. *i
                })

workaround.rs

                do fold::noop_fold_item(i, fld).take_map |i| {
                    let mut i = (*i).clone();
                    let node = match i.node {
                        item_mod(ref m) => {
                            Some(item_mod(self.with_scope(Some(i.ident), ||
                                fld.fold_mod(m)
                            )))
                        },
                        item_foreign_mod(ref foreign_module) => {
                            Some(item_foreign_mod(self.with_scope(Some(i.ident), ||
                                foreign_mod {
                                    items: foreign_module.items.iter().transform(|foreign_item| {
                                        match foreign_item.node {
                                            foreign_item_fn(_, _, ref generics) => {
                                                self.with_type_parameter_rib(
                                                    HasTypeParameters(
                                                        generics, foreign_item.id, 0,
                                                        NormalRibKind),
                                                    || fld.fold_foreign_item(*foreign_item))
                                            }
                                            foreign_item_static(*) => {
                                                fld.fold_foreign_item(*foreign_item)
                                            }
                                        }
                                    }).collect(),
                                    .. fld.fold_foreign_mod(foreign_module)
                                }
                            )))
                        },
                        _ => None
                    };

                    match node {
                        Some(n) => { i.node = n; }
                        None    => {}
                    }

                    @i
                }