You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: resolve.rs
    path of file: ./repos/c2rust/c2rust-refactor/src
    
    the code of the file until where you have to start completion: use rustc::hir::def::{DefKind, Res};
use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX
    
fn push_hir_mod_children(tcx: TyCtxt, m: &Mod, children: &mut Vec<(Symbol, Res)>) {
    use rustc::hir::ItemKind::*;

    for &iid in &m.item_ids {
        let node = tcx.hir().get(iid.id);
        let item = expect!([node] Node::Item(i) => i);
        let item_did = tcx.hir().local_def_id(item.hir_id);

        match item.kind {
            ForeignMod(ref fm) => {
                push_hir_foreign_mod_children(tcx, fm, children);
            }

            ExternCrate(..) => {
                let krate = tcx
                    .extern_mod_stmt_cnum(item_did)
                    .expect("no cnum available for `extern crate`");
                let krate_did = DefId {
                    krate,
                    index: CRATE_DEF_INDEX,
                };
                // This is a little bogus (the thing at `krate_did` isn't really a module), but it
                // works well enough.
                let krate_def = Res::Def(DefKind::Mod, krate_did);
                children.push((item.ident.name, krate_def));
            }

            // We could do something clever for `Use`, but it would be a little tricky in the
            // case where the `use` resolves to an extern crate's item.  For now we just use the
            // default logic, which omits the `use` (there is no `Def::Use` variant).
            _ => {
                if let Some(def) = tcx.def_kind(item_did) {
                    children.push((item.ident.name, Res::Def(def, item_did)));
                }
            }
        }
    }
}