Struct StructType 

pub struct StructType { /* private fields */ }

Represents a c-like struct type. Limitations and warnings on its usage are similar to that in MLIR. <https://mlir.llvm.org/docs/Dialects/LLVM/#structure-types>

1. Anonymous (aka unnamed) structs cannot be recursive.
2. Named structs are uniqued only by name, and may be recursive.
3. LLVM calls anonymous structs as literal structs and named structs as identified structs.
4. Named structs may be opaque, i.e., no body specificed. Recursive types may be created by first creating an opaque struct and later setting its fields (body).

Implementations

impl StructType

pub fn get_named( ctx: &Context, name: Identifier, fields: Option<Vec<TypeHandle>>, ) -> Result<TypedHandle<Self>>

Get or create a named StructType. If fields is None, it indicates an opaque struct. A body can be added to opaque structs by calling this again later. Returns an error if all of the below conditions are true: a. The name is already registered b. The body is already set (i.e, the struct is not oqaue) c. The fields provided here don’t match with the existing body. Since named structs only rely on the name for uniqueness, It is not an error to provide fields as None even when the named struct already exists and has its body set.

pub fn get_unnamed(ctx: &Context, fields: Vec<TypeHandle>) -> TypedHandle<Self>

Get or create a new unnamed (anonymous) struct. These are finalized upon creation, and uniqued based on the fields.

pub fn is_opaque(&self) -> bool

Does this struct not have its body set?

pub fn is_named(&self) -> bool

Is this a named struct?

pub fn name(&self) -> Option<Identifier>

Get this struct’s name, if it has one.

pub fn field_type(&self, field_idx: usize) -> TypeHandle

Get type of the idx’th field.

pub fn num_fields(&self) -> usize

Get the number of fields this struct has

pub fn fields(&self) -> impl Iterator<Item = TypeHandle> + '_

Get an iterator over the fields of this struct

Trait Implementations

impl Debug for StructType

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

Formats the value using the given formatter.

impl Hash for StructType

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 Parsable for StructType

type Arg = ()

Type of the argument that must be passed to the parser.

type Parsed = TypedHandle<StructType>

The type of the parsed entity.

fn parse<'a>( state_stream: &mut StateStream<'a>, _arg: Self::Arg, ) -> ParseResult<'a, Self::Parsed>

where Self: Sized,

Define a parser using existing combinators and call into on [Parser::parse_stream] to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = Self::Parsed> + 'a>

where Self::Parsed: 'a,

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for StructType

fn eq(&self, other: &Self) -> 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 Printable for StructType

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

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl Type for StructType

fn hash_type(&self) -> TypeValueHash

Compute and get the hash for this instance of Self. Hash collisions can be a possibility.

fn eq_type(&self, other: &dyn Type) -> bool

Is self equal to an other Type?

fn get_type_id(&self) -> TypeId

Get a Type’s static name. This is not per instantiation of the type. It is mostly useful for printing and parsing the type. Uniquing does not use this, but instead uses core::any::TypeId.

fn get_type_id_static() -> TypeId

Same as get_type_id, but without the self reference.

fn get_self_handle(&self, ctx: &Context) -> TypeHandle

Get a copyable handle to this type.

fn instantiate(t: Self, ctx: &Context) -> TypedHandle<Self>

where Self: Sized,

Instantiate a type in the provided Context, returning a TypeHandle to self.

fn register(ctx: &mut Context)

where Self: Sized + Parsable<Arg = (), Parsed = TypedHandle<Self>>,

Register this Type’s TypeId in the dialect it belongs to.

impl Verify for StructType

fn verify(&self, _ctx: &Context) -> Result<()>

impl Eq for StructType