fn simplify_ast(ii: e::InlinedItemRef) -> ast::InlinedItem {
    let mut fld = NestedItemsDropper;

    match ii {
        // HACK we're not dropping items.
        e::IIItemRef(i) => {
            ast::IIItem(fold::noop_fold_item(P(i.clone()), &mut fld)
                            .expect_one("expected one item"))
        }
        e::IITraitItemRef(d, ti) => {
            ast::IITraitItem(d,
                fold::noop_fold_trait_item(P(ti.clone()), &mut fld)
                    .expect_one("noop_fold_trait_item must produce \
                                 exactly one trait item"))
        }
        e::IIImplItemRef(d, ii) => {
            ast::IIImplItem(d,
                fold::noop_fold_impl_item(P(ii.clone()), &mut fld)
                    .expect_one("noop_fold_impl_item must produce \
                                 exactly one impl item"))
        }
        e::IIForeignRef(i) => {
            ast::IIForeign(fold::noop_fold_foreign_item(P(i.clone()), &mut fld))
        }
    }
}
// Produces a simplified copy of the AST which does not include things
// that we do not need to or do not want to export.  For example, we
// do not include any nested items: if these nested items are to be
// inlined, their AST will be exported separately (this only makes
// sense because, in Rust, nested items are independent except for
// their visibility).
//
// As it happens, trans relies on the fact that we do not export
// nested items, as otherwise it would get confused when translating
// inlined items.
Produces a simplified copy of the AST which does not include things
that we do not need to or do not want to export.  For example, we
do not include any nested items: if these nested items are to be
inlined, their AST will be exported separately (this only makes
sense because, in Rust, nested items are independent except for
their visibility).

As it happens, trans relies on the fact that we do not export
nested items, as otherwise it would get confused when translating
inlined items.
Produces a simplified copy of the AST which does not include things that we do not need to or do not want to export . For example we do not include any nested items : if these nested items are to be inlined their AST will be exported separately ( this only makes sense because in Rust nested items are independent except for their visibility ) . As it happens trans relies on the fact that we do not export nested items as otherwise it would get confused when translating inlined items .
fn simplify_ast(ii: e::InlinedItemRef) -> ast::InlinedItem {
    let mut fld = NestedItemsDropper;
    match ii {
        // HACK we're not dropping items.
        e::IIItemRef(i) => {
            ast::IIItem(fold::noop_fold_item(P(i.clone()), &mut fld)
                            .expect_one("expected one item"))
        }
        e::IITraitItemRef(d, ti) => {
            ast::IITraitItem(d,
                fold::noop_fold_trait_item(P(ti.clone()), &mut fld)
                    .expect_one("noop_fold_trait_item must produce \
                                 exactly one trait item"))
        }
        e::IIImplItemRef(d, ii) => {
            ast::IIImplItem(d,
                fold::noop_fold_impl_item(P(ii.clone()), &mut fld)
                    .expect_one("noop_fold_impl_item must produce \
                                 exactly one impl item"))
        }
        e::IIForeignRef(i) => {
            ast::IIForeign(fold::noop_fold_foreign_item(P(i.clone()), &mut fld))
        }
    }
}
fn simplify_ast ( ii : e :: InlinedItemRef ) -> ast :: InlinedItem { let mut fld = NestedItemsDropper ; match ii { // HACK we're not dropping items. e :: IIItemRef ( i ) => { ast :: IIItem ( fold :: noop_fold_item ( P ( i . clone ( ) ) , & mut fld ) . expect_one ( " " ) ) } e :: IITraitItemRef ( d , ti ) => { ast :: IITraitItem ( d , fold :: noop_fold_trait_item ( P ( ti . clone ( ) ) , & mut fld ) . expect_one ( " \
 " ) ) } e :: IIImplItemRef ( d , ii ) => { ast :: IIImplItem ( d , fold :: noop_fold_impl_item ( P ( ii . clone ( ) ) , & mut fld ) . expect_one ( " \
 " ) ) } e :: IIForeignRef ( i ) => { ast :: IIForeign ( fold :: noop_fold_foreign_item ( P ( i . clone ( ) ) , & mut fld ) ) } } }
Produces a simplified copy of the AST which does not include things
that we do not need to or do not want to export.
Produces a simplified copy of the AST which does not include things that we do not need to or do not want to export .
ii
e::InlinedItemRef