Function summary_key_str

src/analysis/memory/utils.rs:222–263

Constructs a string that uniquely identifies a definition to serve as a key to the summary cache, which is a key value store. The string will always be the same as long as the definition does not change its name or location, so it can be used to transfer information from one compilation to the next, making incremental analysis possible.

(tcx: TyCtxt<'_>, def_id: DefId)

/// long as the definition does not change its name or location, so it can be used to
/// transfer information from one compilation to the next, making incremental analysis possible.
pub fn summary_key_str(tcx: TyCtxt<'_>, def_id: DefId) -> Rc<String> {
    let mut name = crate_name(tcx, def_id);
    let mut type_ns: Option<String> = None;
    for component in &tcx.def_path(def_id).data {
        if name.ends_with("foreign_contracts") {
            // By stripping off this special prefix, we allow this crate (or module) to define
            // functions that appear to be from other crates.
            // We use this to provide contracts for functions defined in crates we do not
            // wish to modify in place.
            name.clear();
        } else if !name.ends_with('.') {
            name.push('.');
        }
        push_component_name(component.data, &mut name);
        if let DefPathData::TypeNs(sym) = component.data {
            type_ns = Some(sym.as_str().to_string());
        }
        if component.disambiguator != 0 {
            name.push('_');
            if component.data == DefPathData::Impl {
                #[allow(irrefutable_let_patterns)]
                if let parent_def_id = tcx.parent(def_id) {
                    if let Some(type_ns) = &type_ns {
                        if type_ns == "num"
                            && tcx.crate_name(parent_def_id.krate).as_str() == "core"
                        {
                            append_mangled_type(&mut name, tcx.type_of(parent_def_id).skip_binder(), tcx);
                            continue;
                        }
                    }
                }
                if let Some(type_ns) = &type_ns {
                    name.push_str(&type_ns);
                    continue;
                }
            }
            let da = component.disambiguator.to_string();
            name.push_str(da.as_str());
        }
    }
    Rc::new(name)
}


// fn push_component_name(component_data: DefPathData, target: &mut String) {