Enum rustc_hir::def::Res

pub enum Res<Id = HirId> {
    Def(DefKind, DefId),
    PrimTy(PrimTy),
    SelfTy(Option<DefId>, Option<(DefId, bool)>),
    ToolMod,
    SelfCtor(DefId),
    Local(Id),
    NonMacroAttr(NonMacroAttrKind),
    Err,
}

The resolution of a path or export.

For every path or identifier in Rust, the compiler must determine what the path refers to. This process is called name resolution, and Res is the primary result of name resolution.

For example, everything prefixed with /* Res */ in this example has an associated Res:

fn str_to_string(s: & /* Res */ str) -> /* Res */ String {
    /* Res */ String::from(/* Res */ s)
}

/* Res */ str_to_string("hello");

The associated Ress will be:

• str will resolve to Res::PrimTy;
• String will resolve to Res::Def, and the Res will include the DefId for String as defined in the standard library;
• String::from will also resolve to Res::Def, with the DefId pointing to String::from;
• s will resolve to Res::Local;
• the call to str_to_string will resolve to Res::Def, with the DefId pointing to the definition of str_to_string in the current crate.

Variants

Def(DefKind, DefId)

Definition having a unique ID (DefId), corresponds to something defined in user code.

Not bound to a specific namespace.

PrimTy(PrimTy)

A primitive type such as i32 or str.

Belongs to the type namespace.

SelfTy(Option<DefId>, Option<(DefId, bool)>)

The Self type, optionally with the trait it is associated with and optionally with the DefId of the impl it is associated with.

Belongs to the type namespace.

For example, the Self in

trait Foo {
    fn foo() -> Box<Self>;
}

would have the DefId of Foo associated with it. The Self in

struct Bar;

impl Bar {
    fn new() -> Self { Bar }
}

would have the DefId of the impl associated with it. Finally, the Self in

impl Foo for Bar {
    fn foo() -> Box<Self> { Box::new(Bar) }
}

would have both the DefId of Foo and the DefId of the impl associated with it.

See also Res::SelfCtor.

---

HACK(min_const_generics): impl self types also have an optional requirement to not mention any generic parameters to allow the following with min_const_generics:

impl Foo { fn test() -> [u8; std::mem::size_of::<Self>()] { todo!() } }

We do however allow Self in repeat expression even if it is generic to not break code which already works on stable while causing the const_evaluatable_unchecked future compat lint.

FIXME(lazy_normalization_consts): Remove this bodge once that feature is stable.

ToolMod

A tool attribute module; e.g., the rustfmt in #[rustfmt::skip].

Belongs to the type namespace.

SelfCtor(DefId)

The Self constructor, along with the DefId of the impl it is associated with.

Belongs to the value namespace.

See also Res::SelfTy.

Local(Id)

A local variable or function parameter.

Belongs to the value namespace.

NonMacroAttr(NonMacroAttrKind)

An attribute that is not implemented via macro. E.g., #[inline] and #[rustfmt::skip], which are essentially directives, as opposed to #[test], which is a builtin macro.

Belongs to the macro namespace.

Err

Name resolution failed. We use a dummy Res variant so later phases of the compiler won’t crash and can instead report more errors.

Not bound to a specific namespace.

Implementations

impl<Id> Res<Id>

pub fn def_id(&self) -> DefId where
    Id: Debug, 

Return the DefId of this Def if it has an ID, else panic.

pub fn opt_def_id(&self) -> Option<DefId>

Return Some(..) with the DefId of this Res if it has a ID, else None.

pub fn mod_def_id(&self) -> Option<DefId>

Return the DefId of this Res if it represents a module.

pub fn descr(&self) -> &'static str

A human readable name for the res kind (“function”, “module”, etc.).

pub fn article(&self) -> &'static str

Gets an English article for the Res.

pub fn map_id<R>(self, map: impl FnMut(Id) -> R) -> Res<R>

pub fn macro_kind(self) -> Option<MacroKind>

pub fn ns(&self) -> Option<Namespace>

Returns None if this is Res::Err

pub fn matches_ns(&self, ns: Namespace) -> bool

Always returns true if self is Res::Err

pub fn expected_in_tuple_struct_pat(&self) -> bool

Returns whether such a resolved path can occur in a tuple struct/variant pattern

Trait Implementations

impl<Id: Clone> Clone for Res<Id>

fn clone(&self) -> Res<Id>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Id: Copy> Copy for Res<Id>

impl<Id: Debug> Debug for Res<Id>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Id, __D: Decoder> Decodable<__D> for Res<Id> where
    Id: Decodable<__D>, 

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<Id, __E: Encoder> Encodable<__E> for Res<Id> where
    Id: Encodable<__E>, 

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl<Id: Eq> Eq for Res<Id>

impl<Id: Hash> Hash for Res<Id>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<Id, __CTX> HashStable<__CTX> for Res<Id> where
    __CTX: HashStableContext,
    Id: HashStable<__CTX>, 

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl<Id: PartialEq> PartialEq<Res<Id>> for Res<Id>

fn eq(&self, other: &Res<Id>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Res<Id>) -> bool

This method tests for !=.

impl<Id> StructuralEq for Res<Id>

impl<Id> StructuralPartialEq for Res<Id>