Type Alias Res

type Res = Res<NodeId>;

Aliased Type

enum Res {
    Def(DefKind, DefId),
    PrimTy(PrimTy),
    SelfTyParam {
        trait_: DefId,
    },
    SelfTyAlias {
        alias_to: DefId,
        forbid_generic: bool,
        is_trait_impl: bool,
    },
    SelfCtor(DefId),
    Local(NodeId),
    ToolMod,
    NonMacroAttr(NonMacroAttrKind),
    Err,
}

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.

SelfTyParam

The Self type, as used within a trait.

Belongs to the type namespace.

See the examples on [Res::SelfTyAlias] for details.

Fields

trait_: DefId

The trait this Self is a generic parameter for.

SelfTyAlias

The Self type, as used somewhere other than within a trait.

Belongs to the type namespace.

Examples:

struct Bar(Box<Self>); // SelfTyAlias

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

impl Bar {
    fn blah() {
        let _: Self; // SelfTyAlias
    }
}

impl Foo for Bar {
    fn foo() -> Box<Self> { // SelfTyAlias
        let _: Self;        // SelfTyAlias

        todo!()
    }
}

See also [Res::SelfCtor].

Fields

alias_to: DefId

The item introducing the Self type alias. Can be used in the type_of query to get the underlying type.

forbid_generic: bool

Whether the Self type is disallowed from mentioning generics (i.e. when used in an anonymous constant).

HACK(min_const_generics): 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; size_of::<Self>()] { todo!() } }

struct Bar([u8; baz::<Self>()]);
const fn baz<T>() -> usize { 10 }

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:

fn foo<T>() {
    let _bar = [1_u8; size_of::<*mut T>()];
}

is_trait_impl: bool

Is this within an impl Foo for bar?

SelfCtor(DefId)

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

Belongs to the value namespace.

See also [Res::SelfTyParam] and [Res::SelfTyAlias].

Local(NodeId)

A local variable or function parameter.

Belongs to the value namespace.

ToolMod

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

Belongs to the type 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.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.