Trait moore::arenas::Alloc

pub trait Alloc<'a, 't, T> where
    T: 't, {
    pub fn alloc(&'a self, value: T) -> &'t mut T;
}

Allocates values.

Required methods

pub fn alloc(&'a self, value: T) -> &'t mut T

Allocate a value of type T.

Loading content...

Trait Implementations

impl<'z, 'a, 'p, 't, T> Alloc<'z, 't, T> for &'p (dyn Alloc<'a, 't, T> + 'p) where
    'p: 'a,
    T: 't, 

pub fn alloc(&'z self, value: T) -> &'t mut T

Allocate a value of type T.

impl<'a, 't, T> AllocOwned<'a, 't, T> for dyn Alloc<'a, 't, T> + 'static where
    T: 't + ToOwned<Owned = T>, 

pub fn alloc_owned(&'a self, value: T) -> &'t T

Allocate a value of type T: ToOwned into this arena.

pub fn maybe_alloc(&'a self, value: Cow<'t, T>) -> &'t T

Conditionally allocate a value of type Cow<T>.

pub fn force_alloc(&'a self, value: Cow<'_, T>) -> &'t T

Forcefully allocate a value of type Cow<T>.

Implementations on Foreign Types

impl<'a, 'hir> Alloc<'a, 'a, EventExpr> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: EventExpr) -> &'a mut EventExpr

impl<'a, 'hir> Alloc<'a, 'a, InstTarget<'hir>> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: InstTarget<'hir>) -> &'a mut InstTarget<'hir>

impl<'a, 'hir> Alloc<'a, 'a, Stmt> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Stmt) -> &'a mut Stmt

impl<'a, 'hir> Alloc<'a, 'a, GenvarDecl> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: GenvarDecl) -> &'a mut GenvarDecl

impl<'a, 'hir> Alloc<'a, 'a, Inst<'hir>> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Inst<'hir>) -> &'a mut Inst<'hir>

impl<'a, 'hir> Alloc<'a, 'a, Proc> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Proc) -> &'a mut Proc

impl<'a, 'hir> Alloc<'a, 'a, EnumVariant> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: EnumVariant) -> &'a mut EnumVariant

impl<'a, 'hir> Alloc<'a, 'a, Module<'hir>> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Module<'hir>) -> &'a mut Module<'hir>

impl<'a, 'hir> Alloc<'a, 'a, TypeParam> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: TypeParam) -> &'a mut TypeParam

impl<'a, 'hir> Alloc<'a, 'a, Gen> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Gen) -> &'a mut Gen

impl<'a, 'hir> Alloc<'a, 'a, Subroutine> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Subroutine) -> &'a mut Subroutine

impl<'a, 'hir> Alloc<'a, 'a, Typedef> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Typedef) -> &'a mut Typedef

impl<'a, 'hir> Alloc<'a, 'a, Port> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Port) -> &'a mut Port

impl<'a, 'hir> Alloc<'a, 'a, VarDecl> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: VarDecl) -> &'a mut VarDecl

impl<'a, 'hir> Alloc<'a, 'a, Assign> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Assign) -> &'a mut Assign

impl<'a, 'hir> Alloc<'a, 'a, ValueParam> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: ValueParam) -> &'a mut ValueParam

impl<'a, 'hir> Alloc<'a, 'a, Package> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Package) -> &'a mut Package

impl<'a, 'hir> Alloc<'a, 'a, Interface<'hir>> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Interface<'hir>) -> &'a mut Interface<'hir>

impl<'a, 'hir> Alloc<'a, 'a, Type> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Type) -> &'a mut Type

impl<'a, 'hir> Alloc<'a, 'a, Expr<'hir>> for Arena<'hir> where
    'hir: 'a, 

pub fn alloc(&'a self, value: Expr<'hir>) -> &'a mut Expr<'hir>

impl<'t, T> Alloc<'t, 't, T> for GlobalArenas<'t> where
    T: 't,
    Arena<'t>: Alloc<'t, 't, T>, 

Allow AST nodes to be allocated into GlobalArenas.

pub fn alloc(&'t self, value: T) -> &'t mut T

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PortDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PortDeclData<'a>>
) -> &'arena mut Node<'a, PortDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, GenerateForData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, GenerateForData<'a>>
) -> &'arena mut Node<'a, GenerateForData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PortData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PortData<'a>>
) -> &'arena mut Node<'a, PortData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, VarDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, VarDeclData<'a>>
) -> &'arena mut Node<'a, VarDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ForeachIndexData>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ForeachIndexData>
) -> &'arena mut Node<'a, ForeachIndexData>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ParamValueDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ParamValueDeclData<'a>>
) -> &'arena mut Node<'a, ParamValueDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ExprData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ExprData<'a>>
) -> &'arena mut Node<'a, ExprData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PathSegmentData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PathSegmentData<'a>>
) -> &'arena mut Node<'a, PathSegmentData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, StructMemberData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, StructMemberData<'a>>
) -> &'arena mut Node<'a, StructMemberData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ClassDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ClassDeclData<'a>>
) -> &'arena mut Node<'a, ClassDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ModportData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ModportData<'a>>
) -> &'arena mut Node<'a, ModportData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, TypedefData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, TypedefData<'a>>
) -> &'arena mut Node<'a, TypedefData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, StmtData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, StmtData<'a>>
) -> &'arena mut Node<'a, StmtData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PatternFieldData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PatternFieldData<'a>>
) -> &'arena mut Node<'a, PatternFieldData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, DpiDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, DpiDeclData<'a>>
) -> &'arena mut Node<'a, DpiDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ImportDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ImportDeclData<'a>>
) -> &'arena mut Node<'a, ImportDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PortConnData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PortConnData<'a>>
) -> &'arena mut Node<'a, PortConnData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, SubroutineDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, SubroutineDeclData<'a>>
) -> &'arena mut Node<'a, SubroutineDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, DataTypeData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, DataTypeData<'a>>
) -> &'arena mut Node<'a, DataTypeData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, EnumData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, EnumData<'a>>
) -> &'arena mut Node<'a, EnumData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, GenerateBlockData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, GenerateBlockData<'a>>
) -> &'arena mut Node<'a, GenerateBlockData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ImplicitDataTypeData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ImplicitDataTypeData<'a>>
) -> &'arena mut Node<'a, ImplicitDataTypeData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ContAssignData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ContAssignData<'a>>
) -> &'arena mut Node<'a, ContAssignData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, RootData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, RootData<'a>>
) -> &'arena mut Node<'a, RootData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, InstNameData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, InstNameData<'a>>
) -> &'arena mut Node<'a, InstNameData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ParamDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ParamDeclData<'a>>
) -> &'arena mut Node<'a, ParamDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, StructData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, StructData<'a>>
) -> &'arena mut Node<'a, StructData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, InterfaceData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, InterfaceData<'a>>
) -> &'arena mut Node<'a, InterfaceData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PackageData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PackageData<'a>>
) -> &'arena mut Node<'a, PackageData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, NetDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, NetDeclData<'a>>
) -> &'arena mut Node<'a, NetDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ItemData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ItemData<'a>>
) -> &'arena mut Node<'a, ItemData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, TypeOrExpr<'a>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(&'arena self, value: TypeOrExpr<'a>) -> &'arena mut TypeOrExpr<'a>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, TypeKindData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, TypeKindData<'a>>
) -> &'arena mut Node<'a, TypeKindData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, SubroutinePortData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, SubroutinePortData<'a>>
) -> &'arena mut Node<'a, SubroutinePortData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, SourceFileData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, SourceFileData<'a>>
) -> &'arena mut Node<'a, SourceFileData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, VarDeclNameData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, VarDeclNameData<'a>>
) -> &'arena mut Node<'a, VarDeclNameData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, TypeData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, TypeData<'a>>
) -> &'arena mut Node<'a, TypeData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, VarDimData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, VarDimData<'a>>
) -> &'arena mut Node<'a, VarDimData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ModuleData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ModuleData<'a>>
) -> &'arena mut Node<'a, ModuleData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ModportNameData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ModportNameData<'a>>
) -> &'arena mut Node<'a, ModportNameData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, UnpackedDimData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, UnpackedDimData<'a>>
) -> &'arena mut Node<'a, UnpackedDimData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, GenvarDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, GenvarDeclData<'a>>
) -> &'arena mut Node<'a, GenvarDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ImportItemData>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ImportItemData>
) -> &'arena mut Node<'a, ImportItemData>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, SubroutinePrototypeData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, SubroutinePrototypeData<'a>>
) -> &'arena mut Node<'a, SubroutinePrototypeData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ParamTypeDeclData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ParamTypeDeclData<'a>>
) -> &'arena mut Node<'a, ParamTypeDeclData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, PackedDimData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, PackedDimData<'a>>
) -> &'arena mut Node<'a, PackedDimData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ProcedureData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ProcedureData<'a>>
) -> &'arena mut Node<'a, ProcedureData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ModportPortData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ModportPortData<'a>>
) -> &'arena mut Node<'a, ModportPortData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, EnumNameData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, EnumNameData<'a>>
) -> &'arena mut Node<'a, EnumNameData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, ModportSimplePortData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, ModportSimplePortData<'a>>
) -> &'arena mut Node<'a, ModportSimplePortData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, GenerateIfData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, GenerateIfData<'a>>
) -> &'arena mut Node<'a, GenerateIfData<'a>>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, GenerateCaseData>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, GenerateCaseData>
) -> &'arena mut Node<'a, GenerateCaseData>

impl<'arena, 'a> Alloc<'arena, 'arena, Node<'a, InstData<'a>>> for Arena<'a> where
    'a: 'arena, 

pub fn alloc(
    &'arena self,
    value: Node<'a, InstData<'a>>
) -> &'arena mut Node<'a, InstData<'a>>

Loading content...

Implementors

impl<'z, 'a, 'p, 't, T> Alloc<'z, 't, T> for &'p (dyn Alloc<'a, 't, T> + 'p) where
    'p: 'a,
    T: 't, 

pub fn alloc(&'z self, value: T) -> &'t mut T

Loading content...