Trait Builder

pub trait Builder<'a>:
    Clone
    + Sealed
    + 'a {
    type BB<'b, 'e, 'd>: BB<'b, Func<'b>: Value<'b, Kind = Self::ValKind<'e, 'd>>>
       where Self: 'b + 'e + 'd,
             'a: 'b;
    type ValKind<'d, 'b>: ValueKind<Ty<'d> = Self::Ty<'d>, Mod<'b> = Self::Mod<'b>>
       where Self: 'd + 'b;
    type Mod<'b>: Mod<'b, Ctx<'b> = Self::Ctx<'b>>
       where Self: 'b;
    type Ty<'b>: Ty<'b>
       where Self: 'b;
    type Ctx<'b>: Ctx<'b>
       where Self: 'b;

    // Required methods
    fn new_in_ctx(ctx: Self::Ctx<'a>) -> Self;
    fn continue<'b, 'c>(&'b self, bb: Self::BB<'c, '_, '_>)
       where 'a: 'b + 'c;
    fn call<'b, 'c, 'd, 'e, 'f, 'h, 'i, 'g: 'a + 'b + 'c + 'd + 'e + 'f + 'h + 'i>(
        &'b self,
        resty: Self::Ty<'c>,
        fn: <Self::ValKind<'_, '_> as ValueKind>::Val<'d, Normal>,
        args: impl Iterator<Item = <Self::ValKind<'h, 'i> as ValueKind>::Val<'e, Normal>>,
        name: &'f CStr,
    ) -> <Self::ValKind<'_, '_> as ValueKind>::Val<'g, Normal>
       where Self: 'h + 'i;

    // Provided methods
    fn Alloca<'b, 'ty, 'name, 'res: 'ty + 'name + 'b>(
        &'b self,
        ty: Self::Ty<'ty>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'ty + 'name { ... }
    fn Load2<'b, 'ty, 'ptr, 'name, 'res: 'ty + 'ptr + 'name + 'b>(
        &'b self,
        ty: Self::Ty<'ty>,
        pointer: <Self::ValKind<'a, 'a> as ValueKind>::Val<'ptr, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'ty + 'ptr + 'name { ... }
    fn Store<'b, 'val, 'ptr, 'res: 'val + 'ptr + 'b>(
        &'b self,
        value: <Self::ValKind<'a, 'a> as ValueKind>::Val<'val, Normal>,
        pointer: <Self::ValKind<'a, 'a> as ValueKind>::Val<'ptr, Normal>,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'val + 'ptr { ... }
    fn Add<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'rhs + 'name { ... }
    fn And<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'rhs + 'name { ... }
    fn Neg<'b, 'lhs, 'name, 'res: 'lhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'name { ... }
    fn Not<'b, 'lhs, 'name, 'res: 'lhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'name { ... }
    fn TruncOrBitCast<'b, 'lhs, 'ty, 'name, 'res: 'lhs + 'ty + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        ty: Self::Ty<'ty>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'ty + 'name { ... }
    fn Mul<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'rhs + 'name { ... }
    fn Or<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'rhs + 'name { ... }
    fn Sub<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'rhs + 'name { ... }
    fn Xor<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'lhs + 'rhs + 'name { ... }
    fn ICmp<'b, 'op, 'lhs, 'rhs, 'name, 'res: 'op + 'lhs + 'rhs + 'name + 'b>(
        &'b self,
        op: ICmp,
        lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>,
        rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>,
        name: &'name CStr,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'op + 'lhs + 'rhs + 'name { ... }
    fn Br<'b, 'dest, 'res: 'dest + 'b>(
        &'b self,
        dest: Self::BB<'dest, 'a, 'a>,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'dest { ... }
    fn CondBr<'b, 'cond, 'then, 'e, 'res: 'cond + 'then + 'e + 'b>(
        &'b self,
        if: <Self::ValKind<'a, 'a> as ValueKind>::Val<'cond, Normal>,
        then: Self::BB<'then, 'a, 'a>,
        else: Self::BB<'e, 'a, 'a>,
    ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>
       where 'a: 'cond + 'then + 'e { ... }
}

Required Associated Types

type BB<'b, 'e, 'd>: BB<'b, Func<'b>: Value<'b, Kind = Self::ValKind<'e, 'd>>> where Self: 'b + 'e + 'd, 'a: 'b

type ValKind<'d, 'b>: ValueKind<Ty<'d> = Self::Ty<'d>, Mod<'b> = Self::Mod<'b>> where Self: 'd + 'b

type Mod<'b>: Mod<'b, Ctx<'b> = Self::Ctx<'b>> where Self: 'b

type Ty<'b>: Ty<'b> where Self: 'b

type Ctx<'b>: Ctx<'b> where Self: 'b

Required Methods

fn new_in_ctx(ctx: Self::Ctx<'a>) -> Self

fn continue<'b, 'c>(&'b self, bb: Self::BB<'c, '_, '_>)

where 'a: 'b + 'c,

fn call<'b, 'c, 'd, 'e, 'f, 'h, 'i, 'g: 'a + 'b + 'c + 'd + 'e + 'f + 'h + 'i>( &'b self, resty: Self::Ty<'c>, fn: <Self::ValKind<'_, '_> as ValueKind>::Val<'d, Normal>, args: impl Iterator<Item = <Self::ValKind<'h, 'i> as ValueKind>::Val<'e, Normal>>, name: &'f CStr, ) -> <Self::ValKind<'_, '_> as ValueKind>::Val<'g, Normal>

where Self: 'h + 'i,

Provided Methods

fn Alloca<'b, 'ty, 'name, 'res: 'ty + 'name + 'b>( &'b self, ty: Self::Ty<'ty>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'ty + 'name,

fn Load2<'b, 'ty, 'ptr, 'name, 'res: 'ty + 'ptr + 'name + 'b>( &'b self, ty: Self::Ty<'ty>, pointer: <Self::ValKind<'a, 'a> as ValueKind>::Val<'ptr, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'ty + 'ptr + 'name,

fn Store<'b, 'val, 'ptr, 'res: 'val + 'ptr + 'b>( &'b self, value: <Self::ValKind<'a, 'a> as ValueKind>::Val<'val, Normal>, pointer: <Self::ValKind<'a, 'a> as ValueKind>::Val<'ptr, Normal>, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'val + 'ptr,

fn Add<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'rhs + 'name,

fn And<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'rhs + 'name,

fn Neg<'b, 'lhs, 'name, 'res: 'lhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'name,

fn Not<'b, 'lhs, 'name, 'res: 'lhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'name,

fn TruncOrBitCast<'b, 'lhs, 'ty, 'name, 'res: 'lhs + 'ty + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, ty: Self::Ty<'ty>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'ty + 'name,

fn Mul<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'rhs + 'name,

fn Or<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'rhs + 'name,

fn Sub<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'rhs + 'name,

fn Xor<'b, 'lhs, 'rhs, 'name, 'res: 'lhs + 'rhs + 'name + 'b>( &'b self, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'lhs + 'rhs + 'name,

fn ICmp<'b, 'op, 'lhs, 'rhs, 'name, 'res: 'op + 'lhs + 'rhs + 'name + 'b>( &'b self, op: ICmp, lhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'lhs, Normal>, rhs: <Self::ValKind<'a, 'a> as ValueKind>::Val<'rhs, Normal>, name: &'name CStr, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'op + 'lhs + 'rhs + 'name,

fn Br<'b, 'dest, 'res: 'dest + 'b>( &'b self, dest: Self::BB<'dest, 'a, 'a>, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'dest,

fn CondBr<'b, 'cond, 'then, 'e, 'res: 'cond + 'then + 'e + 'b>( &'b self, if: <Self::ValKind<'a, 'a> as ValueKind>::Val<'cond, Normal>, then: Self::BB<'then, 'a, 'a>, else: Self::BB<'e, 'a, 'a>, ) -> <Self::ValKind<'a, 'a> as ValueKind>::Val<'res, Normal>

where 'a: 'cond + 'then + 'e,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors