Enum hir::Adt

pub enum Adt {
    Struct(Struct),
    Union(Union),
    Enum(Enum),
}

A Data Type

Variants

Struct(Struct)

Union(Union)

Enum(Enum)

Implementations

impl Adt

pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool

pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError>

pub fn ty(self, db: &dyn HirDatabase) -> Type

Turns this ADT into a type. Any type parameters of the ADT will be turned into unknown types, which is good for e.g. finding the most general set of completions, but will not look very nice when printed.

pub fn ty_with_args( self, db: &dyn HirDatabase, args: impl Iterator<Item = Type>, ) -> Type

Turns this ADT into a type with the given type parameters. This isn’t the greatest API, FIXME find a better one.

pub fn module(self, db: &dyn HirDatabase) -> Module

pub fn name(self, db: &dyn HirDatabase) -> Name

pub fn lifetime(&self, db: &dyn HirDatabase) -> Option<LifetimeParamData>

Returns the lifetime of the DataType

pub fn as_struct(&self) -> Option<Struct>

pub fn as_enum(&self) -> Option<Enum>

Trait Implementations

impl Clone for Adt

fn clone(&self) -> Adt

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Adt

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

Formats the value using the given formatter.

impl From<Adt> for AdtId

fn from(id: Adt) -> Self

Converts to this type from the input type.

impl From<Adt> for GenericDef

fn from(it: Adt) -> GenericDef

Converts to this type from the input type.

impl From<Adt> for GenericDefId

fn from(id: Adt) -> Self

Converts to this type from the input type.

impl From<Adt> for ModuleDef

fn from(it: Adt) -> ModuleDef

Converts to this type from the input type.

impl From<AdtId> for Adt

fn from(id: AdtId) -> Self

Converts to this type from the input type.

impl From<Enum> for Adt

fn from(it: Enum) -> Adt

Converts to this type from the input type.

impl From<Struct> for Adt

fn from(it: Struct) -> Adt

Converts to this type from the input type.

impl From<Union> for Adt

fn from(it: Union) -> Adt

Converts to this type from the input type.

impl HasAttrs for Adt

fn attrs(self, db: &dyn HirDatabase) -> AttrsWithOwner

impl HasCrate for Adt

fn krate(&self, db: &dyn HirDatabase) -> Crate

impl HasSource for Adt

type Ast = Adt

fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>>

Fetches the definition’s source node. Using [crate::Semantics::source] is preferred when working with crate::Semantics, as that caches the parsed file in the semantics’ cache.

impl HasVisibility for Adt

fn visibility(&self, db: &dyn HirDatabase) -> Visibility

fn is_visible_from(&self, db: &dyn HirDatabase, module: Module) -> bool

impl Hash for Adt

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl HirDisplay for Adt

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError>

fn into_displayable<'a>( &'a self, db: &'a dyn HirDatabase, max_size: Option<usize>, limited_size: Option<usize>, omit_verbose_types: bool, display_target: DisplayTarget, closure_style: ClosureStyle, show_container_bounds: bool, ) -> HirDisplayWrapper<'a, Self>

where Self: Sized,

Returns a Displayable type that is human-readable.

fn display<'a>( &'a self, db: &'a dyn HirDatabase, edition: Edition, ) -> HirDisplayWrapper<'a, Self>

where Self: Sized,

Returns a Displayable type that is human-readable. Use this for showing types to the user (e.g. diagnostics)

fn display_truncated<'a>( &'a self, db: &'a dyn HirDatabase, max_size: Option<usize>, edition: Edition, ) -> HirDisplayWrapper<'a, Self>

where Self: Sized,

Returns a Displayable type that is human-readable and tries to be succinct. Use this for showing types to the user where space is constrained (e.g. doc popups)

fn display_limited<'a>( &'a self, db: &'a dyn HirDatabase, limited_size: Option<usize>, edition: Edition, ) -> HirDisplayWrapper<'a, Self>

where Self: Sized,

Returns a Displayable type that is human-readable and tries to limit the number of items inside. Use this for showing definitions which may contain too many items, like trait, struct, enum

fn display_source_code<'a>( &'a self, db: &'a dyn HirDatabase, module_id: ModuleId, allow_opaque: bool, ) -> Result<String, DisplaySourceCodeError>

Returns a String representation of self that can be inserted into the given module. Use this when generating code (e.g. assists)

fn display_test<'a>( &'a self, db: &'a dyn HirDatabase, ) -> HirDisplayWrapper<'a, Self>

where Self: Sized,

Returns a String representation of self for test purposes

fn display_with_container_bounds<'a>( &'a self, db: &'a dyn HirDatabase, show_container_bounds: bool, edition: Edition, ) -> HirDisplayWrapper<'a, Self>

where Self: Sized,

Returns a String representation of self that shows the constraint from the container for functions

impl PartialEq for Adt

fn eq(&self, other: &Adt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Adt

impl Eq for Adt

impl StructuralPartialEq for Adt