rustc_mir_build/thir/
util.rs

1use std::assert_matches::assert_matches;
2
3use rustc_hir as hir;
4use rustc_hir::def::DefKind;
5use rustc_middle::bug;
6use rustc_middle::ty::{self, CanonicalUserType, TyCtxt};
7use tracing::debug;
8
9/// Looks up the type associated with this hir-id and applies the
10/// user-given generic parameters; the hir-id must map to a suitable
11/// type.
12pub(crate) fn user_args_applied_to_ty_of_hir_id<'tcx>(
13    tcx: TyCtxt<'tcx>,
14    typeck_results: &ty::TypeckResults<'tcx>,
15    hir_id: hir::HirId,
16) -> Option<CanonicalUserType<'tcx>> {
17    let user_provided_types = typeck_results.user_provided_types();
18    let mut user_ty = *user_provided_types.get(hir_id)?;
19    {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event compiler/rustc_mir_build/src/thir/util.rs:19",
                        "rustc_mir_build::thir::util", ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("compiler/rustc_mir_build/src/thir/util.rs"),
                        ::tracing_core::__macro_support::Option::Some(19u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_mir_build::thir::util"),
                        ::tracing_core::field::FieldSet::new(&["message"],
                            ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                let mut iter = __CALLSITE.metadata().fields().iter();
                __CALLSITE.metadata().fields().value_set(&[(&::tracing::__macro_support::Iterator::next(&mut iter).expect("FieldSet corrupted (this is a bug)"),
                                    ::tracing::__macro_support::Option::Some(&format_args!("user_subts_applied_to_ty_of_hir_id: user_ty={0:?}",
                                                    user_ty) as &dyn Value))])
            });
    } else { ; }
};debug!("user_subts_applied_to_ty_of_hir_id: user_ty={:?}", user_ty);
20    let ty = typeck_results.node_type(hir_id);
21    match ty.kind() {
22        ty::Adt(adt_def, ..) => {
23            // This "fixes" user type annotations for tupled ctor patterns for ADTs.
24            // That's because `type_of(ctor_did)` returns a FnDef, but we actually
25            // want to be annotating the type of the ADT itself. It's a bit goofy,
26            // but it's easier to adjust this here rather than in the path lowering
27            // code for patterns in HIR.
28            if let ty::UserTypeKind::TypeOf(did, _) = &mut user_ty.value.kind {
29                // This is either already set up correctly (struct, union, enum, or variant),
30                // or needs adjusting (ctor). Make sure we don't start adjusting other
31                // user annotations like consts or fn calls.
32                match tcx.def_kind(*did) {
    DefKind::Ctor(..) | DefKind::Struct | DefKind::Enum | DefKind::Union |
        DefKind::Variant => {}
    ref left_val => {
        ::core::panicking::assert_matches_failed(left_val,
            "DefKind::Ctor(..) | DefKind::Struct | DefKind::Enum | DefKind::Union |\nDefKind::Variant",
            ::core::option::Option::None);
    }
};assert_matches!(
33                    tcx.def_kind(*did),
34                    DefKind::Ctor(..)
35                        | DefKind::Struct
36                        | DefKind::Enum
37                        | DefKind::Union
38                        | DefKind::Variant
39                );
40                *did = adt_def.did();
41            }
42            Some(user_ty)
43        }
44        ty::FnDef(..) => Some(user_ty),
45        _ => ::rustc_middle::util::bug::bug_fmt(format_args!("ty: {0:?} should not have user provided type {1:?} recorded ",
        ty, user_ty))bug!("ty: {:?} should not have user provided type {:?} recorded ", ty, user_ty),
46    }
47}