Function sanitize_class_segment

src/lower1/naming.rs:150–210

(seg: &str)

        link_name
    };
    validate_jvm_internal_class_name(class_name)?;
    Ok(class_name.to_string())
}

pub fn mono_owner_class<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> String {
    let def_id = instance.def_id();
    // The runtime polls an async body through a carrier companion, independently of
    // crate/module layout and generic method-holder partitioning.
    if matches!(tcx.def_kind(def_id), DefKind::Closure) && tcx.coroutine_is_async(def_id) {
        return format!(
            "{}$Body",
            jvm_names::anonymous_class_for_args(tcx, def_id, instance.args, true)
        );
    }
    if tcx.generics_of(def_id).requires_monomorphization(tcx) {
        // Definition-crate ownership agrees across all downstream emitters.
        let identity = super::types::stable_instance_identity(tcx, def_id, instance.args);
        generic_mono_owner(tcx, def_id, &identity)
    } else if let Some(trait_def_id) = tcx
        .opt_associated_item(def_id)
        .and_then(|item| item.trait_container(tcx))
    {
        // A Java interface carries its dynamically dispatched method, but
        // monomorphized Rust default bodies are static functions. Put those
        // bodies beside the trait in its module rather than generating a
        // second class file for the interface name.
        jvm_names::owner_class_for_function(tcx, trait_def_id)
    } else {
        jvm_names::owner_class_for_function(tcx, def_id)
    }
}

fn generic_mono_owner(tcx: TyCtxt<'_>, def_id: DefId, identity: &str) -> String {
    // Bound class-header and ZIP-entry overhead without concentrating a whole
    // module's specializations in one constant pool. The linker splits any
    // bucket that still overflows; method identities remain independent of it.
    format!(
        "{}/mono/Mono_{}",
        jvm_names::crate_root(tcx, def_id.krate),
        &identity[..3],
    )
}

/// Whether a static body belongs to a Java interface, including nested
/// closures and coroutines whose immediate `DefId` is not an associated item.
pub fn instance_is_trait_interface_owned<'tcx>(
    tcx: TyCtxt<'tcx>,
    instance: Instance<'tcx>,
    owner_class: &str,
) -> bool {
    let mut current = Some(instance.def_id());
    while let Some(def_id) = current {
        let trait_def_id = matches!(tcx.def_kind(def_id), DefKind::Trait)
            .then_some(def_id)
            .or_else(|| {
                tcx.opt_associated_item(def_id)
                    .and_then(|item| item.trait_container(tcx))
            });