Struct LLVMSumType

pub struct LLVMSumType<'c>(/* private fields */);

The opaque representation of a HugrSumType.

Provides an impls of BasicType, allowing interoperation with other inkwell tools.

To obtain an LLVMSumType corresponding to a HugrSumType use LLVMSumType::try_new or LLVMSumType::try_from_hugr_type.

Any such LLVMSumType has a fixed underlying LLVM type, which can be obtained by BasicType::as_basic_type_enum or LLVMSumType::value_type. Note this type is unspecified, and we go to some effort to ensure that it is minimal and efficient. Users should not expect this type to remain the same across versions.

Unit types such as empty structs({}) are elided from the LLVM type where possible. See elidable_type for the specification of which types are elided.

Each LLVMSumType has an associated IntType tag type, which can be obtained via LLVMSumType::tag_type.

The value type LLVMSumValue represents values of this type. To obtain an LLVMSumValue use LLVMSumType::build_tag or LLVMSumType::value.

Implementations

impl<'c> LLVMSumType<'c>

pub fn value_type(&self) -> BasicTypeEnum<'c>

The underlying LLVM type.

pub fn tag_type(&self) -> IntType<'c>

The type of the value that would be returned by LLVMSumValue::build_get_tag.

pub fn num_variants(&self) -> usize

The number of variants in the represented HugrSumType.

pub fn num_fields_for_variant(&self, tag: usize) -> usize

The number of fields in the tagth variant of the represented HugrSumType. Panics if tag is out of bounds.

pub fn fields_for_variant(&self, tag: usize) -> &[BasicTypeEnum<'c>]

The LLVM types representing the fields in the tag variant of the represented HugrSumType. Panics if tag is out of bounds.

pub fn try_from_hugr_type( session: &TypingSession<'c, '_>, sum_type: HugrSumType, ) -> Result<Self>

Constructs a new LLVMSumType from a HugrSumType, using session to determine the types of the fields.

Returns an error if the type of any field cannot be converted by session, or if sum_type has no variants.

pub fn try_new( context: &'c Context, variant_types: impl Into<Vec<Vec<BasicTypeEnum<'c>>>>, ) -> Result<Self>

Constructs a new LLVMSumType from a Vec of variants. Each variant is a Vec of LLVM types each corresponding to a field in the sum.

Returns an error if variant_types is empty;

pub fn get_undef(&self) -> impl BasicValue<'c> + use<'c>

Returns an constant undef value of the underlying LLVM type.

pub fn get_poison(&self) -> impl BasicValue<'c> + use<'c>

Returns an constant poison value of the underlying LLVM type.

pub fn build_tag( &self, builder: &Builder<'c>, tag: usize, vs: Vec<BasicValueEnum<'c>>, ) -> Result<LLVMSumValue<'c>>

Emits instructions to construct an LLVMSumValue of this type. The value will represent the tagth variant.

pub fn value(&self, value: impl BasicValue<'c>) -> Result<LLVMSumValue<'c>>

Returns an LLVMSumValue of this type.

Returns an error if value.get_type() != self.value_type().

Trait Implementations

impl<'c> AnyType<'c> for LLVMSumType<'c>

fn as_any_type_enum(&self) -> AnyTypeEnum<'ctx>

Returns an AnyTypeEnum that represents the current type.

fn print_to_string(&self) -> LLVMString

Prints the definition of a Type to a LLVMString.

impl AsTypeRef for LLVMSumType<'_>

fn as_type_ref(&self) -> LLVMTypeRef

Returns the internal LLVM reference behind the type

impl<'c> BasicType<'c> for LLVMSumType<'c>

fn as_basic_type_enum(&self) -> BasicTypeEnum<'ctx>

Returns a BasicTypeEnum that represents the current type.

fn fn_type( &self, param_types: &[BasicMetadataTypeEnum<'ctx>], is_var_args: bool, ) -> FunctionType<'ctx>

Create a FunctionType with this BasicType as its return type.

fn is_sized(&self) -> bool

Determines whether or not this BasicType is sized or not. For example, opaque structs are unsized.

fn size_of(&self) -> Option<IntValue<'ctx>>

Gets the size of this BasicType. Value may vary depending on the target architecture.

fn array_type(&self, size: u32) -> ArrayType<'ctx>

Create an ArrayType with this BasicType as its elements.

fn ptr_type(&self, address_space: AddressSpace) -> PointerType<'ctx>

Create a PointerType that points to this BasicType.

impl<'c> Clone for LLVMSumType<'c>

fn clone(&self) -> LLVMSumType<'c>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'c> Debug for LLVMSumType<'c>

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

Formats the value using the given formatter.

impl<'c> Display for LLVMSumType<'c>

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

Formats the value using the given formatter.