Struct Options 

#[non_exhaustive]
pub struct Options {
    pub macro_name: Option<Ident>,
    pub mock: Option<Path>,
    pub repeater: Option<Path>,
    pub allow_primitive: bool,
    pub allow_std_prelude: bool,
    pub krate: Option<Path>,
    pub emit_item: bool,
    pub layout: Layout,
    pub docs: bool,
    pub checks: Vec<Check>,
    pub metas: Vec<Check>,
    /* private fields */
}

The parsed arguments of #[announce(..)].

Parse it from the attribute’s tokens with syn::parse2; the grammar and the meaning of every option are those of the #[announce] attribute (announce::announce). Build one in code with Options::default and the public fields. Turn it back into attribute arguments with ToTokens (opts.to_token_stream()), for example to hand it to announce().

The most useful field for a library is krate: the path to the announce crate that the generated code uses (see Options::krate()). Without it the path is read from the Cargo.toml of the crate being compiled, which only works when that crate depends on announce itself.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

macro_name: Option<Ident>

macro_name = Name: name of the emitted macro. Default: the item’s name. All the announcements of one item must give the same name, the item’s name where it is not set: one item has one trampoline.

mock: Option<Path>

mock = path: the item is a stand-in for the item at path.

repeater: Option<Path>

repeater = path: emit the type-leak table against this repeater trait.

allow_primitive: bool

type-leak: primitives resolve everywhere (default true).

allow_std_prelude: bool

type-leak: std prelude names resolve everywhere (default false).

krate: Option<Path>

crate = path: path to the announce crate in generated code. When it is None, Options::krate() looks the crate up in Cargo.toml.

emit_item: bool

emit_item = false: do not re-emit the item (it is emitted by someone else). Default true.

layout: Layout

layout = auto | single | direct: how the trampoline holds the item. Default auto: by the size of the item (advanced).

docs: bool

docs = true: keep the doc attributes (#[doc = ".."], so /// and //! too) in the item that callbacks and checks receive. Default false: they are removed there, which makes the trampoline smaller. The item that is compiled keeps its docs either way.

checks: Vec<Check>

Checks: bare path / path(args) entries. They run at the definition.

metas: Vec<Check>

meta = path(args): listed in META like a check, but never invoked.

Implementations

impl Options

pub fn krate(&self) -> Path

The path to the announce crate that the generated code uses.

crate = .. (the krate field) wins. Otherwise it is the name that the Cargo.toml of the crate being compiled (CARGO_MANIFEST_DIR) gives to its announce dependency, renames included, else ::announce.

Trait Implementations

impl Clone for Options

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Options

fn default() -> Self

Returns the “default value” for a type.

impl Parse for Options

fn parse(input: ParseStream<'_>) -> Result<Self>

impl ToTokens for Options

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.