Struct rust_codegen::Function

source · [−]

pub struct Function {
    pub body: Option<Vec<Body>>,
    /* private fields */
}

Expand description

Defines a function.

Fields

body: Option<Vec<Body>>

Body contents.

Implementations

source

impl Function

source

pub fn new(name: &str) -> Self

Return a new function definition.

Arguments

name - The name of the function.

Examples

use rust_codegen::Function;
 
let foo_fn = Function::new("foo_fn");

source

pub fn doc(&mut self, docs: &str) -> &mut Self

Set the function documentation.

Arguments

docs - The docs to set for the function.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.doc("Sample Foo function documentation.");

source

pub fn allow(&mut self, allow: &str) -> &mut Self

Specify lint attribute to supress a warning or error.

Arguments

allow - The lint attribute to add.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.allow("dead_code");

source

pub fn vis(&mut self, vis: &str) -> &mut Self

Set the function visibility.

Arguments

vis - The visiblity to set for the function.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.vis("pub");

source

pub fn set_async(&mut self, async: bool) -> &mut Self

Set whether this function is async or not.

Arguments

async - Indicates whether this function is async or not.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.set_async(true);

source

pub fn generic(&mut self, name: &str) -> &mut Self

Add a generic to the function.

Arguments

name - The name of the generic to add.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.generic("T");

source

pub fn arg_self(&mut self) -> &mut Self

Add self as a function argument.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.arg_self();

source

pub fn arg_ref_self(&mut self) -> &mut Self

Add &self as a function argument.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.arg_ref_self();

source

pub fn arg_mut_self(&mut self) -> &mut Self

Add &mut self as a function argument.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.arg_mut_self();

source

pub fn arg<T>(&mut self, name: &str, ty: T) -> &mut Self where
T: Into<Type>,

Add a function argument.

Arguments

name - The name of the argument.
ty - The type of the argument.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.arg("name", "&str");

source

pub fn ret<T>(&mut self, ty: T) -> &mut Self where
T: Into<Type>,

Set the function return type.

Arguments

ty - The return type.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.ret("String");

source

pub fn bound<T>(&mut self, name: &str, ty: T) -> &mut Self where
T: Into<Type>,

Add a where bound to the function.

Arguments

name - The name of the bound.
ty - The type of the bound.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.bound("A", "TraitA");

source

pub fn line<T>(&mut self, line: T) -> &mut Self where
T: ToString,

Push a line to the function implementation.

Arguments

line - The line to add to the function.

Examples

use rust_codegen::Function;
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.line("println!(\"Hello, world!\")");

source

pub fn attr(&mut self, attribute: &str) -> &mut Self

Add an attribute to the function.

Arguments

attribute - The attribute to add.

Examples

use rust_codegen::Function;

let mut foo_fn = Function::new("foo_fn");
foo_fn.attr("test");

source

pub fn extern_abi(&mut self, abi: &str) -> &mut Self

Specify an extern ABI for the function.

Arguments

abi - The extern ABI to add.

Examples

use rust_codegen::Function;

let mut foo_fn = Function::new("foo_fn");
foo_fn.extern_abi("C");

source

pub fn push_block(&mut self, block: Block) -> &mut Self

Push a block to the function implementation.

Arguments

block - The block to push to the function.

Examples

use rust_codegen::*;

let mut foo_fn = Function::new("foo_fn");
 
let mut block = Block::new("");
block.line("println!(\"Hello, world!\");");
 
foo_fn.push_block(block);

source

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

Formats the function using the given formatter.

Arguments

is_trait - Indicates whether it is a trait or not.
fmt - The formatter to use.

Examples

use rust_codegen::*;
 
let mut dest = String::new();
let mut fmt = Formatter::new(&mut dest);
 
let mut foo_fn = Function::new("foo_fn");
foo_fn.fmt(false, &mut fmt);