Struct ruast::Fn

pub struct Fn {
    pub ident: String,
    pub generics: Vec<GenericParam>,
    pub fn_decl: FnDecl,
    pub body: Option<Block>,
}

Fields

ident: String

generics: Vec<GenericParam>

fn_decl: FnDecl

body: Option<Block>

Implementations

impl Fn

pub fn new( ident: impl Into<String>, generics: Vec<GenericParam>, fn_decl: FnDecl, body: Block ) -> Self

pub fn main(output: Option<Type>, body: Block) -> Self

Examples found in repository

examples/hello.rs (lines 5-8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use ruast::*;

    let mut krate = Crate::new();
    let def = Fn::main(
        None,
        Block::from(Path::single("println").mac_call(vec![Token::lit("Hello, world!")])),
    );
    krate.add_item(def);
    println!("{krate}");
    // krate.dump("hello.rs")?;
    Ok(())
}

pub fn empty(ident: impl Into<String>) -> Self

pub fn empty_method(ident: impl Into<String>, self_pat: Pat) -> Self

Examples found in repository

examples/enum.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use ruast::*;

    let mut krate = Crate::new();
    let def = EnumDef::empty("Foo")
        .with_variant(Variant::empty("Bar"))
        .with_variant(Variant::tuple("Baz", vec![FieldDef::anonymous("u32")]));
    krate.add_item(def);
    let imp = Impl::empty("Foo").with_item(Fn::empty_method("test", Pat::ref_self()));
    krate.add_item(imp);
    println!("{krate}");
    Ok(())
}

examples/struct.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use ruast::*;

    let mut krate = Crate::new();
    let def = StructDef::empty("Foo")
        .with_field(FieldDef::inherited("foo", Type::from("u32")))
        .with_field(FieldDef::inherited("bar", Type::from("u32")));
    krate.add_item(def);
    let imp = Impl::empty("Foo").with_item(Fn::empty_method("test", Pat::ref_self()));
    krate.add_item(imp);
    println!("{krate}");
    Ok(())
}

pub fn add_stmt(&mut self, stmt: impl Into<Stmt>)

pub fn add_semi_stmt(&mut self, expr: impl Into<Expr>)

pub fn with_stmt(self, stmt: impl Into<Stmt>) -> Self

pub fn with_semi_stmt(self, expr: impl Into<Expr>) -> Self

pub fn remove_stmt(&mut self, index: usize) -> Option<Stmt>

Trait Implementations

impl Clone for Fn

fn clone(&self) -> Fn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Fn

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

Formats the value using the given formatter.

impl Display for Fn

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

Formats the value using the given formatter.

impl EmptyItem for Fn

type Input = String

fn empty(ident: impl Into<Self::Input>) -> Self

impl From<Fn> for AssocItemKind

fn from(item: Fn) -> Self

Converts to this type from the input type.

impl From<Fn> for ItemKind

fn from(item: Fn) -> Self

Converts to this type from the input type.

impl From<Fn> for Stmt

fn from(item: Fn) -> Self

Converts to this type from the input type.

impl From<Fn> for TokenStream

fn from(value: Fn) -> Self

Converts to this type from the input type.

impl Hash for Fn

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 Ident for Fn

fn ident(&self) -> &str

impl PartialEq for Fn

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Fn

impl StructuralEq for Fn

impl StructuralPartialEq for Fn