in checker/src/known_names.rs [142:480]
fn get_known_name_for(tcx: TyCtxt<'_>, def_id: DefId) -> KnownNames {
use std::ops::Deref;
use DefPathData::*;
let def_path = &tcx.def_path(def_id);
let def_path_data_iter = def_path.data.iter();
// helper to get next elem from def path and return its name, if it has one
let get_path_data_elem_name =
|def_path_data_elem: Option<&rustc_hir::definitions::DisambiguatedDefPathData>| {
def_path_data_elem.and_then(|ref elem| {
let DisambiguatedDefPathData { data, .. } = elem;
match &data {
TypeNs(name) | ValueNs(name) => Some(*name),
_ => None,
}
})
};
let is_foreign_module =
|def_path_data_elem: Option<&rustc_hir::definitions::DisambiguatedDefPathData>| {
if let Some(elem) = def_path_data_elem {
let DisambiguatedDefPathData { data, .. } = elem;
matches!(&data, ForeignMod)
} else {
false
}
};
let path_data_elem_as_disambiguator = |def_path_data_elem: Option<
&rustc_hir::definitions::DisambiguatedDefPathData,
>| {
def_path_data_elem.map(|DisambiguatedDefPathData { disambiguator, .. }| *disambiguator)
};
let get_known_name_for_alloc_namespace = |mut def_path_data_iter: Iter<'_>| {
if is_foreign_module(def_path_data_iter.next()) {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"__rust_alloc" => KnownNames::RustAlloc,
"__rust_alloc_zeroed" => KnownNames::RustAllocZeroed,
"__rust_dealloc" => KnownNames::RustDealloc,
"__rust_realloc" => KnownNames::RustRealloc,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
} else {
KnownNames::None
}
};
let get_known_name_for_clone_trait = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"clone" => KnownNames::StdCloneClone,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_clone_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"Clone" => get_known_name_for_clone_trait(def_path_data_iter),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_future_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"from_generator" => KnownNames::StdFutureFromGenerator,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_intrinsics_namespace = |mut def_path_data_iter: Iter<'_>| {
let current_elem = def_path_data_iter.next();
match path_data_elem_as_disambiguator(current_elem) {
Some(0) => get_path_data_elem_name(current_elem)
.map(|n| match n.as_str().deref() {
"copy" => KnownNames::StdIntrinsicsCopy,
"copy_nonoverlapping" => KnownNames::StdIntrinsicsCopyNonOverlapping,
"write_bytes" => KnownNames::StdIntrinsicsWriteBytes,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
Some(1) => get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"arith_offset" => KnownNames::StdIntrinsicsArithOffset,
"bitreverse" => KnownNames::StdIntrinsicsBitreverse,
"bswap" => KnownNames::StdIntrinsicsBswap,
"ceilf32" => KnownNames::StdIntrinsicsCeilf32,
"ceilf64" => KnownNames::StdIntrinsicsCeilf64,
"copysignf32" => KnownNames::StdIntrinsicsCopysignf32,
"copysignf64" => KnownNames::StdIntrinsicsCopysignf64,
"cosf32" => KnownNames::StdIntrinsicsCosf32,
"cosf64" => KnownNames::StdIntrinsicsCosf64,
"ctlz" => KnownNames::StdIntrinsicsCtlz,
"ctlz_nonzero" => KnownNames::StdIntrinsicsCtlzNonzero,
"ctpop" => KnownNames::StdIntrinsicsCtpop,
"cttz" => KnownNames::StdIntrinsicsCttz,
"cttz_nonzero" => KnownNames::StdIntrinsicsCttzNonzero,
"discriminant_value" => KnownNames::StdIntrinsicsDiscriminantValue,
"exp2f32" => KnownNames::StdIntrinsicsExp2f32,
"exp2f64" => KnownNames::StdIntrinsicsExp2f64,
"expf32" => KnownNames::StdIntrinsicsExpf32,
"expf64" => KnownNames::StdIntrinsicsExpf64,
"fabsf32" => KnownNames::StdIntrinsicsFabsf32,
"fabsf64" => KnownNames::StdIntrinsicsFabsf64,
"fadd_fast" => KnownNames::StdIntrinsicsFaddFast,
"fdiv_fast" => KnownNames::StdIntrinsicsFdivFast,
"floorf32" => KnownNames::StdIntrinsicsFloorf32,
"floorf64" => KnownNames::StdIntrinsicsFloorf64,
"fmul_fast" => KnownNames::StdIntrinsicsFmulFast,
"frem_fast" => KnownNames::StdIntrinsicsFremFast,
"fsub_fast" => KnownNames::StdIntrinsicsFsubFast,
"log10f32" => KnownNames::StdIntrinsicsLog10f32,
"log10f64" => KnownNames::StdIntrinsicsLog10f64,
"log2f32" => KnownNames::StdIntrinsicsLog2f32,
"log2f64" => KnownNames::StdIntrinsicsLog2f64,
"logf32" => KnownNames::StdIntrinsicsLogf32,
"logf64" => KnownNames::StdIntrinsicsLogf64,
"maxnumf32" => KnownNames::StdIntrinsicsMaxnumf32,
"maxnumf64" => KnownNames::StdIntrinsicsMaxnumf64,
"min_align_of_val" => KnownNames::StdIntrinsicsMinAlignOfVal,
"minnumf32" => KnownNames::StdIntrinsicsMinnumf32,
"minnumf64" => KnownNames::StdIntrinsicsMinnumf64,
"mul_with_overflow" => KnownNames::StdIntrinsicsMulWithOverflow,
"nearbyintf32" => KnownNames::StdIntrinsicsNearbyintf32,
"nearbyintf64" => KnownNames::StdIntrinsicsNearbyintf64,
"needs_drop" => KnownNames::StdIntrinsicsNeedsDrop,
"offset" => KnownNames::StdIntrinsicsOffset,
"powf32" => KnownNames::StdIntrinsicsPowf32,
"powf64" => KnownNames::StdIntrinsicsPowf64,
"powif32" => KnownNames::StdIntrinsicsPowif32,
"powif64" => KnownNames::StdIntrinsicsPowif64,
"raw_eq" => KnownNames::StdIntrinsicsRawEq,
"rintf32" => KnownNames::StdIntrinsicsRintf32,
"rintf64" => KnownNames::StdIntrinsicsRintf64,
"roundf32" => KnownNames::StdIntrinsicsRintf32,
"roundf64" => KnownNames::StdIntrinsicsRintf64,
"sinf32" => KnownNames::StdIntrinsicsSinf32,
"sinf64" => KnownNames::StdIntrinsicsSinf64,
"size_of" => KnownNames::StdIntrinsicsSizeOf,
"size_of_val" => KnownNames::StdIntrinsicsSizeOfVal,
"sqrtf32" => KnownNames::StdIntrinsicsSqrtf32,
"sqrtf64" => KnownNames::StdIntrinsicsSqrtf64,
"transmute" => KnownNames::StdIntrinsicsTransmute,
"truncf32" => KnownNames::StdIntrinsicsTruncf32,
"truncf64" => KnownNames::StdIntrinsicsTruncf64,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
_ => KnownNames::None,
}
};
let get_known_name_for_marker_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"PhantomData" => KnownNames::StdMarkerPhantomData,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_mem_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"replace" => KnownNames::StdMemReplace,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_ops_function_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"Fn" | "FnMut" | "FnOnce" => get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"call" => KnownNames::StdOpsFunctionFnCall,
"call_mut" => KnownNames::StdOpsFunctionFnMutCallMut,
"call_once" | "call_once_force" => {
KnownNames::StdOpsFunctionFnOnceCallOnce
}
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_ops_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"function" => get_known_name_for_ops_function_namespace(def_path_data_iter),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_panicking_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"assert_failed" => KnownNames::StdPanickingAssertFailed,
"begin_panic" | "panic" => KnownNames::StdPanickingBeginPanic,
"begin_panic_fmt" | "panic_fmt" => KnownNames::StdPanickingBeginPanicFmt,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_ptr_mut_ptr_namespace =
|mut def_path_data_iter: Iter<'_>| match path_data_elem_as_disambiguator(
def_path_data_iter.next(),
) {
Some(0) => get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"write_bytes" => KnownNames::StdIntrinsicsWriteBytes,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
_ => KnownNames::None,
};
let get_known_name_for_ptr_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"swap_nonoverlapping" => KnownNames::StdPtrSwapNonOverlapping,
"mut_ptr" => get_known_name_for_ptr_mut_ptr_namespace(def_path_data_iter),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_slice_cmp_namespace =
|mut def_path_data_iter: Iter<'_>| match path_data_elem_as_disambiguator(
def_path_data_iter.next(),
) {
Some(0) => get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"memcmp" => KnownNames::StdSliceCmpMemcmp,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
_ => KnownNames::None,
};
let get_known_name_for_sync_once_namespace =
|mut def_path_data_iter: Iter<'_>| match path_data_elem_as_disambiguator(
def_path_data_iter.next(),
) {
Some(2) => get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"call_once" | "call_once_force" => KnownNames::StdOpsFunctionFnOnceCallOnce,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
_ => KnownNames::None,
};
let get_known_name_for_raw_vec_namespace =
|mut def_path_data_iter: Iter<'_>| match path_data_elem_as_disambiguator(
def_path_data_iter.next(),
) {
Some(1) => get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"MIN_NON_ZERO_CAP" => KnownNames::AllocRawVecMinNonZeroCap,
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None),
_ => KnownNames::None,
};
let get_known_name_for_slice_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"cmp" => get_known_name_for_slice_cmp_namespace(def_path_data_iter),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
//get_known_name_for_sync_namespace
let get_known_name_for_sync_namespace = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"once" => get_known_name_for_sync_once_namespace(def_path_data_iter),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let get_known_name_for_known_crate = |mut def_path_data_iter: Iter<'_>| {
get_path_data_elem_name(def_path_data_iter.next())
.map(|n| match n.as_str().deref() {
"alloc" => get_known_name_for_alloc_namespace(def_path_data_iter),
"clone" => get_known_name_for_clone_namespace(def_path_data_iter),
"future" => get_known_name_for_future_namespace(def_path_data_iter),
"intrinsics" => get_known_name_for_intrinsics_namespace(def_path_data_iter),
"marker" => get_known_name_for_marker_namespace(def_path_data_iter),
"mem" => get_known_name_for_mem_namespace(def_path_data_iter),
"ops" => get_known_name_for_ops_namespace(def_path_data_iter),
"panicking" => get_known_name_for_panicking_namespace(def_path_data_iter),
"ptr" => get_known_name_for_ptr_namespace(def_path_data_iter),
"mirai_abstract_value" => KnownNames::MiraiAbstractValue,
"mirai_add_tag" => KnownNames::MiraiAddTag,
"mirai_assume" => KnownNames::MiraiAssume,
"mirai_assume_preconditions" => KnownNames::MiraiAssumePreconditions,
"mirai_does_not_have_tag" => KnownNames::MiraiDoesNotHaveTag,
"mirai_get_model_field" => KnownNames::MiraiGetModelField,
"mirai_has_tag" => KnownNames::MiraiHasTag,
"mirai_postcondition" => KnownNames::MiraiPostcondition,
"mirai_precondition_start" => KnownNames::MiraiPreconditionStart,
"mirai_precondition" => KnownNames::MiraiPrecondition,
"mirai_result" => KnownNames::MiraiResult,
"mirai_set_model_field" => KnownNames::MiraiSetModelField,
"mirai_verify" => KnownNames::MiraiVerify,
"raw_vec" => get_known_name_for_raw_vec_namespace(def_path_data_iter),
"rt" => get_known_name_for_panicking_namespace(def_path_data_iter),
"slice" => get_known_name_for_slice_namespace(def_path_data_iter),
"sync" => get_known_name_for_sync_namespace(def_path_data_iter),
_ => KnownNames::None,
})
.unwrap_or(KnownNames::None)
};
let crate_name = tcx.crate_name(def_id.krate);
match crate_name.as_str().deref() {
"alloc" | "core" | "mirai_annotations" | "std" => {
get_known_name_for_known_crate(def_path_data_iter)
}
_ => KnownNames::None,
}
}