Struct InvocationMeta

pub struct InvocationMeta {
    pub origin: Origin,
    pub name: Option<&'static str>,
    pub doc: Option<&'static str>,
    pub receiver: Option<TypeHint>,
    pub inputs: Option<Vec<Param>>,
    pub output: TypeHint,
}

Metadata for a function-like object.

Typically, this object describes the signatures of exported Rust functions and methods, but it can also describe a broader range of exported objects that support the invocation operation.

This object aids in the static semantic analysis of Script source code.

The Display implementation of this object renders a canonical, user-facing view of the function’s signature, such as fn foo(x: usize, y: bool) -> f32.

Generally, you don’t need to instantiate this object manually, unless your crate introduces new types of invokable objects. In such cases, you should store this object in a static context.

use ad_astra::{
    lady_deirdre::sync::Lazy,
    runtime::{InvocationMeta, Origin, Param, ScriptType},
};

static INVOKE_META: Lazy<InvocationMeta> = Lazy::new(|| {
    InvocationMeta {
        name: Some("foo"),
        inputs: Some(vec![Param {
            name: None,
            hint: <usize>::type_meta().into(),
        }]),
        ..InvocationMeta::new(Origin::nil())
    }
});

assert_eq!(INVOKE_META.name, Some("foo"));

Fields

origin: Origin

The source code range in Rust or Script where the function signature was introduced.

Typically, the resulting Origin points to the Rust code.

name: Option<&'static str>

The name of the function, if the function has a name.

doc: Option<&'static str>

The RustDoc documentation for this function, if available.

receiver: Option<TypeHint>

The type of the method’s receiver (e.g., self, &self, and similar Rust function parameters), if the function has a receiver.

inputs: Option<Vec<Param>>

The signature of the function parameters, excluding the receiver, if the signature metadata is available.

output: TypeHint

The type of the object returned after the function invocation.

If the return type is not specified, the output corresponds to the TypeHint::dynamic.

Implementations

impl InvocationMeta

pub fn new(origin: Origin) -> Self

Creates a new invocation metadata object with all fields set to their default values.

pub fn arity(&self) -> Option<usize>

Returns the arity of the function, which is the number of function parameters excluding the receiver.

This is a helper function similar in semantics to self.inputs.as_ref().map(|inputs| inputs.len()).

Trait Implementations

impl Clone for InvocationMeta

fn clone(&self) -> InvocationMeta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InvocationMeta

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

Formats the value using the given formatter.

impl Display for InvocationMeta

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

Formats the value using the given formatter.

impl From<&'static InvocationMeta> for TypeHint

fn from(value: &'static InvocationMeta) -> Self

Converts to this type from the input type.

impl Hash for &'static InvocationMeta

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 PartialEq for &'static InvocationMeta

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for &'static InvocationMeta