use std::collections::HashMap;
use crate::parse::{Cardinality, ChildMethodInfo, ChildMethodKind, MethodInfo, ParamInfo};
use proc_macro2::{Span, TokenStream};
use proc_macro_crate::{crate_name, FoundCrate};
use quote::{format_ident, quote};
use syn::Type;
pub(crate) fn resolve_client_path(err_span: Span) -> syn::Result<syn::Path> {
match crate_name("plexus-client") {
Ok(FoundCrate::Itself) => Ok(syn::parse_quote!(crate)),
Ok(FoundCrate::Name(name)) => {
let ident = syn::Ident::new(&name, err_span);
Ok(syn::parse_quote!(::#ident))
}
Err(e) => Err(syn::Error::new(
err_span,
format!(
"#[plexus_macros::activation(client)] could not locate the \
`plexus-client` dependency in Cargo.toml ({e}). The generated \
client links against it. Add `plexus-client` as a dependency, \
or remove the `client` flag."
),
)),
}
}
fn is_option_type(ty: &Type) -> bool {
let Type::Path(p) = ty else { return false };
p.qself.is_none()
&& p.path
.segments
.last()
.is_some_and(|s| s.ident == "Option" && matches!(s.arguments, syn::PathArguments::AngleBracketed(_)))
}
pub(crate) fn param_link(param: &ParamInfo) -> TokenStream {
let ident = ¶m.name;
let wire_name = param.name.to_string();
if is_option_type(¶m.ty) {
quote! { .optional(#wire_name, #ident) }
} else {
quote! { .param(#wire_name, #ident) }
}
}
pub(crate) fn method_const_ident(m: &MethodInfo) -> syn::Ident {
format_ident!("METHOD_{}", m.method_name.to_uppercase().replace(['.', '-'], "_"))
}
fn pascal(name: &str) -> String {
name.split(['_', '-', '.'])
.filter(|w| !w.is_empty())
.map(|w| {
let mut chars = w.chars();
match chars.next() {
Some(first) => first.to_uppercase().chain(chars).collect::<String>(),
None => String::new(),
}
})
.collect()
}
fn derived_ident(name: &str, what: &str, span: Span) -> syn::Result<syn::Ident> {
syn::parse_str::<syn::Ident>(name)
.map(|mut ident| {
ident.set_span(span);
ident
})
.map_err(|_| {
syn::Error::new(
span,
format!(
"#[plexus_macros::activation(client)]: {what} derives the \
identifier `{name}`, which is not a valid Rust identifier"
),
)
})
}
pub(crate) fn aggregate_name(namespace: &str) -> String {
format!("{}Event", pascal(namespace))
}
pub(crate) fn stream_alias_name(namespace: &str, wire_method: &str, methods: &[MethodInfo]) -> String {
let name = format!("{}{}Stream", pascal(namespace), pascal(wire_method));
let named = |ty: &Type| match ty {
Type::Path(tp) => tp.path.segments.last().is_some_and(|s| s.ident == name),
_ => false,
};
if methods.iter().any(|m| named(&m.ok_ty) || m.err_ty.as_ref().is_some_and(named)) {
format!("{}{}MethodStream", pascal(namespace), pascal(wire_method))
} else {
name
}
}
fn path_string(tokens: TokenStream) -> String {
tokens.to_string().replace(' ', "")
}
pub(crate) fn aggregate_name_for(namespace: &str, methods: &[MethodInfo]) -> String {
let name = aggregate_name(namespace);
let named = |ty: &Type| match ty {
Type::Path(tp) => tp.path.segments.last().is_some_and(|s| s.ident == name),
_ => false,
};
if methods.iter().any(|m| named(&m.ok_ty) || m.err_ty.as_ref().is_some_and(named)) {
format!("{}Aggregate", pascal(namespace))
} else {
name
}
}
pub(crate) fn generate(
client_ty: &syn::Ident,
namespace: &str,
methods: &[MethodInfo],
children: &[ChildMethodInfo],
client_path: &syn::Path,
) -> syn::Result<(TokenStream, TokenStream)> {
let event_ty = derived_ident(
&aggregate_name_for(namespace, methods),
&format!("the namespace `{namespace}`"),
Span::call_site(),
)?;
let tree = children
.iter()
.filter(|c| !c.opaque)
.map(|c| ChildNode::of(c, client_ty, &event_ty, client_path))
.collect::<syn::Result<Vec<ChildNode>>>()?;
let reserved = Reserved {
statics: children
.iter()
.filter(|c| matches!(c.kind, ChildMethodKind::Static))
.map(|c| c.fn_name.to_string())
.collect(),
};
let child_accessors: Vec<TokenStream> =
tree.iter().map(|n| child_accessor(n, namespace, client_ty, &event_ty, client_path, &reserved)).collect();
let wraps: Vec<TokenStream> = tree
.iter()
.filter(|n| !n.dynamic)
.map(|n| {
let wrap_ty = wrap_ident(client_ty, &n.variant);
let child_event = &n.child_event;
let variant = &n.variant;
let wrapped = if n.boxed { quote! { ::std::boxed::Box::new(event) } } else { quote! { event } };
let doc = format!("RETURNS-46: `{client_ty}`'s `{}` child's event into `{event_ty}::{variant}`.", n.segment);
quote! {
#[doc = #doc]
#[doc(hidden)]
#[derive(Debug, Clone, Copy, Default)]
pub struct #wrap_ty;
impl #client_path::Wrap<#child_event> for #wrap_ty {
type Into = #event_ty;
#[inline(always)]
fn wrap(&self, event: #child_event) -> #event_ty {
#event_ty::#variant(#wrapped)
}
}
}
})
.collect();
let server_checks: Vec<TokenStream> = tree
.iter()
.filter(|n| !n.recursive)
.map(|n| {
let ty = &n.child_ty;
quote! {
const _: fn() = || {
fn __plexus_child_needs_a_client<C: #client_path::HasClient>() {}
__plexus_child_needs_a_client::<#ty>();
};
}
})
.collect();
let wire_result_path = path_string(quote! { #client_path::wire_result });
let serde_path = path_string(quote! { #client_path::__rt::serde });
let mut variants: Vec<TokenStream> = Vec::new();
let mut method_items: Vec<TokenStream> = Vec::new();
let mut ctors: Vec<TokenStream> = Vec::new();
let mut consts: Vec<TokenStream> = Vec::new();
let mut seen: HashMap<String, String> = HashMap::new();
let mut claim = |variant_name: &str, what: String, span: Span| -> syn::Result<()> {
match seen.insert(variant_name.to_string(), what.clone()) {
None => Ok(()),
Some(other) => Err(syn::Error::new(
span,
format!(
"#[plexus_macros::activation(client)]: {other} and {what} both derive \
the `{event_ty}::{variant_name}` variant of the activation's aggregate \
(methods and children share one route namespace); rename one of them"
),
)),
}
};
for m in methods {
let wire_method = &m.method_name;
let variant_name = pascal(wire_method);
claim(&variant_name, format!("the method `{wire_method}`"), m.fn_name.span())?;
let variant = derived_ident(
&variant_name,
&format!("the method `{wire_method}`"),
m.fn_name.span(),
)?;
let ok_ty = &m.ok_ty;
let (item_ty, decoder, payload) = match &m.err_ty {
None => (
quote! { #ok_ty },
quote! { #client_path::Content::decode::<#ok_ty> },
quote! { #ok_ty },
),
Some(err_ty) => (
quote! { ::core::result::Result<#ok_ty, #err_ty> },
quote! { #client_path::wire_result::from_content::<#ok_ty, #err_ty> },
quote! {
#[serde(with = #wire_result_path)]
::core::result::Result<#ok_ty, #err_ty>
},
),
};
let variant_doc = format!("An item of `{namespace}.{wire_method}`.");
variants.push(quote! {
#[doc = #variant_doc]
#[serde(rename = #wire_method)]
#variant(#payload),
});
let fn_ident = &m.fn_name;
let const_ident = method_const_ident(m);
let mut sig_params: Vec<TokenStream> = m
.params
.iter()
.map(|p| {
let name = &p.name;
let ty = &p.ty;
quote! { #name: #ty }
})
.collect();
let lifetime = m.input.as_ref().map(|_| quote! { <'__plexus_a> });
let this = if m.input.is_some() { quote! { &'__plexus_a self } } else { quote! { &self } };
let items_life = if m.input.is_some() { quote! { '__plexus_a } } else { quote! { '_ } };
if let Some(i) = &m.input {
let (name, item) = (&i.name, &i.item);
sig_params.insert(i.at, quote! {
#name: impl #client_path::__rt::Stream<Item = #item> + #client_path::MaybeSend + '__plexus_a
});
}
let input_arg = m.input.as_ref().map(|i| {
let name = &i.name;
quote! { #client_path::encode_input(#name), }
});
let links: Vec<TokenStream> = m.params.iter().map(param_link).collect();
let params = quote! { #client_path::Params::new() #(#links)* .build() };
let calls = format!("Calls `{namespace}.{wire_method}`.");
let doc = if m.description.is_empty() {
calls
} else {
format!("{}\n\n{calls}", m.description)
};
consts.push(quote! {
#[doc = #doc]
pub const #const_ident: #client_path::MethodRef =
#client_path::MethodRef::new(#namespace, #wire_method);
});
let (call_one, call_many) = if m.input.is_some() {
(quote! { call_one_with_input }, quote! { call_as_with_input })
} else {
(quote! { call_one }, quote! { call_as })
};
let method = match m.cardinality {
Cardinality::One => {
let doc = format!(
"{doc}\n\nOne item: `Ok(item)` is the activation's answer; `Err` is \
the call failing (`ClientError::Remote` for the server's typed \
error frame)."
);
quote! {
#[allow(clippy::too_many_arguments)]
#[doc = #doc]
pub async fn #fn_ident #lifetime (#this #(, #sig_params)*)
-> ::core::result::Result<#item_ty, #client_path::ClientError>
{
let (__method, __params) = match self.route.method(#client_ty::<T>::#const_ident) {
::core::result::Result::Ok(m) => (m, #params),
::core::result::Result::Err(e) => (#client_ty::<T>::#const_ident, ::core::result::Result::Err(e)),
};
#client_path::#call_one(&self.transport, __method, __params, #input_arg #decoder).await
}
}
}
Cardinality::Many => {
let progress_ty = match &m.progress_ty {
Some(p) => {
let p = p.to_type(client_path);
quote! { #p }
}
None => quote! { #client_path::NoProgress },
};
let alias = derived_ident(
&stream_alias_name(namespace, wire_method, methods),
&format!("the method `{wire_method}`"),
m.fn_name.span(),
)?;
let doc = format!(
"{doc}\n\nMany items, as a stream of `Result<item, ClientError>` — a \
[`{alias}`]; progress is dropped unless opted in with `.with_progress()`, \
and `.events()` yields `{event_ty}::{variant}` — lifted by `L` into the \
aggregate of the client this one was reached from (RETURNS-46)."
);
let ctor = wrap_ident(client_ty, &variant);
let ctor_doc = format!("RETURNS-46: an item of `{namespace}.{wire_method}` as `{event_ty}::{variant}`.");
let alias_doc = format!(
"The stream of a `{namespace}.{wire_method}` call: `MethodStream<'a, item, progress, \
{event_ty}, L, _>`, its variant a hidden zero-sized type (RETURNS-46). `L` is the \
lift of the client the call was made on — `Root` for one made with `new` or `at`, \
a parent's for one an accessor made. Name a held call's type with it."
);
ctors.push(quote! {
#[doc = #alias_doc]
#[allow(private_interfaces)]
pub type #alias<'a, L = #client_path::Root> =
#client_path::MethodStream<'a, #item_ty, #progress_ty, #event_ty, L, #ctor>;
#[doc = #ctor_doc]
#[doc(hidden)]
#[derive(Debug, Clone, Copy, Default)]
pub struct #ctor;
#[allow(private_interfaces)]
impl #client_path::EventOf<#item_ty> for #ctor {
type Aggregate = #event_ty;
#[inline(always)]
fn event(&self, item: #item_ty) -> #event_ty {
#event_ty::#variant(item)
}
}
});
quote! {
#[allow(clippy::too_many_arguments)]
#[doc = #doc]
pub fn #fn_ident #lifetime (#this #(, #sig_params)*) -> #alias<#items_life, L> {
let (__method, __params) = match self.route.method(#client_ty::<T>::#const_ident) {
::core::result::Result::Ok(m) => (m, #params),
::core::result::Result::Err(e) => (#client_ty::<T>::#const_ident, ::core::result::Result::Err(e)),
};
#client_path::MethodStream::#call_many(&self.transport, __method, __params, #input_arg #decoder, #ctor)
.lifted(::core::clone::Clone::clone(&self.lift))
}
}
}
};
method_items.push(method);
}
let mut froms: Vec<TokenStream> = Vec::new();
for n in &tree {
let variant_name = pascal(&n.segment);
let kind = if n.dynamic { "dynamic child" } else { "child" };
claim(&variant_name, format!("the {kind} `{}`", n.segment), n.fn_name.span())?;
let variant = &n.variant;
let segment = &n.segment;
let payload = &n.payload;
if n.dynamic {
let doc = format!(
"An event of an instance of the dynamic child `{segment}` (`{namespace}.<name>`): \
the instance's name, and its aggregate."
);
variants.push(quote! {
#[doc = #doc]
#[serde(rename = #segment)]
#variant {
name: ::std::sync::Arc<str>,
event: #payload,
},
});
} else {
let doc = format!("An event of the child `{namespace}.{segment}`, in its aggregate.");
variants.push(quote! {
#[doc = #doc]
#[serde(rename = #segment)]
#variant(#payload),
});
let shared = tree.iter().filter(|o| !o.dynamic && o.child_client_key == n.child_client_key).count() > 1;
if !shared && !n.recursive {
let child_event = &n.child_event;
let wrapped = if n.boxed { quote! { ::std::boxed::Box::new(event) } } else { quote! { event } };
let doc = format!("`{event_ty}::{variant}`: the child `{segment}`'s event, lifted (RETURNS-46).");
froms.push(quote! {
#[doc = #doc]
impl ::core::convert::From<#child_event> for #event_ty {
fn from(event: #child_event) -> Self {
#event_ty::#variant(#wrapped)
}
}
});
}
}
}
let event_doc = format!(
"The `{namespace}` activation's event: one variant per method, keyed by \
the method's wire name, carrying that method's item, then one per \
`#[child]`, keyed by its route segment, carrying the child's own \
aggregate — derived by `#[plexus_macros::activation(client)]`, never \
sent on the wire.\n\n\
Wire shape `{{\"method\": \"<name>\", \"event\": <item>}}`, a Result \
item as `{{\"ok\"}}` / `{{\"err\"}}`; a static child's event as \
`{{\"method\": \"<child>\", \"event\": <child's aggregate>}}`, a dynamic \
child's as `{{\"method\": \"<child>\", \"event\": {{\"name\": \"<instance>\", \
\"event\": <child's aggregate>}}}}` (RETURNS-46). A many-item call's \
`.events()` yields it — from a call anywhere below a client, that \
client's aggregate; merging several calls into one listener is \
ordinary stream plumbing. Progress and call failures are not items, \
so they are not here."
);
let client_name = client_ty.to_string();
let struct_doc = format!(
"Typed client for the `{namespace}` activation, generated by \
`#[plexus_macros::activation(client)]`.\n\n\
Generic over the transport: construct it with any \
`plexus_client::Transport` — in-process for tests, WebSocket \
JSON-RPC or REST + SSE against a server.\n\n\
A one-item method is an `async fn` returning `Result<item, \
ClientError>`; a many-item method returns a `MethodStream`. The \
parameter and item types are the activation's own, so a change to \
either is a compile error here, not a runtime surprise."
);
Ok((quote! {
#[doc = #event_doc]
#[derive(
::core::fmt::Debug,
#client_path::__rt::serde::Serialize,
#client_path::__rt::serde::Deserialize,
)]
#[serde(crate = #serde_path, tag = "method", content = "event")]
#[allow(private_interfaces)]
pub enum #event_ty {
#(#variants)*
}
#(#froms)*
#(#wraps)*
#(#ctors)*
#[doc = #struct_doc]
pub struct #client_ty<T, L = #client_path::Root> {
transport: T,
route: #client_path::Route,
lift: L,
}
impl<T, L> #client_path::Aggregated for #client_ty<T, L> {
type Event = #event_ty;
}
impl<T: ::core::fmt::Debug, L> ::core::fmt::Debug for #client_ty<T, L> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_struct(#client_name)
.field("transport", &self.transport)
.field("path", &self.path())
.finish()
}
}
impl<T: ::core::clone::Clone, L: ::core::clone::Clone> ::core::clone::Clone for #client_ty<T, L> {
fn clone(&self) -> Self {
Self {
transport: ::core::clone::Clone::clone(&self.transport),
route: ::core::clone::Clone::clone(&self.route),
lift: ::core::clone::Clone::clone(&self.lift),
}
}
}
impl<T: ::core::default::Default> ::core::default::Default for #client_ty<T> {
fn default() -> Self {
Self::new(::core::default::Default::default())
}
}
impl<T> #client_ty<T> {
pub const NAMESPACE: &'static str = #namespace;
pub fn new(transport: T) -> Self {
Self { transport, route: #client_path::Route::ROOT, lift: #client_path::Root }
}
pub fn at(transport: T, path: impl ::core::convert::Into<#client_path::RoutePath>) -> Self {
Self { transport, route: #client_path::Route::at(path, #namespace), lift: #client_path::Root }
}
}
impl<T, L> #client_ty<T, L> {
pub fn lifted(transport: T, route: #client_path::Route, lift: L) -> Self {
Self { transport, route, lift }
}
pub fn path(&self) -> &str {
self.route.path(#namespace)
}
pub fn transport(&self) -> &T {
&self.transport
}
pub fn into_transport(self) -> T {
self.transport
}
}
impl<T: #client_path::Transport> #client_ty<T> {
#(#consts)*
}
impl<T: #client_path::Transport, L: #client_path::Lift<#event_ty>> #client_ty<T, L> {
#(#method_items)*
#(#child_accessors)*
}
}, quote! { #(#server_checks)* }))
}
struct Reserved {
statics: Vec<String>,
}
struct ChildNode {
fn_name: syn::Ident,
description: String,
segment: String,
dynamic: bool,
child_ty: Type,
child_client: TokenStream,
child_client_key: String,
recursive: bool,
child_event: TokenStream,
payload: TokenStream,
boxed: bool,
variant: syn::Ident,
}
impl ChildNode {
fn of(c: &ChildMethodInfo, client_ty: &syn::Ident, event_ty: &syn::Ident, client: &syn::Path) -> syn::Result<Self> {
let dynamic = matches!(c.kind, ChildMethodKind::Dynamic);
let child_ty = if dynamic { option_inner(&c.return_ty).unwrap_or(&c.return_ty) } else { &c.return_ty };
let what = if dynamic { "a dynamic #[child] must return `Option<Child>`" } else { "a static #[child] must return" };
let Type::Path(tp) = child_ty else {
return Err(syn::Error::new_spanned(
&c.return_ty,
format!(
"#[plexus_macros::activation(client)]: {what} its activation type by name \
(`-> Inputs`) so the client can reach it through `InputsClient`, or be \
marked `#[child(opaque)]`"
),
));
};
if tp.qself.is_some() {
return Err(syn::Error::new_spanned(
&c.return_ty,
"#[plexus_macros::activation(client)]: a #[child]'s return type must be a plain path",
));
}
let segment = c.fn_name.to_string();
let variant = derived_ident(&pascal(&segment), &format!("the child `{segment}`"), c.fn_name.span())?;
let is_self = tp.path.is_ident("Self");
let mut path = tp.path.clone();
let (child_client, recursive) = if is_self {
(quote! { #client_ty }, true)
} else {
let single = path.segments.len() == 1;
let Some(last) = path.segments.last_mut() else {
return Err(syn::Error::new_spanned(&c.return_ty, "#[child]: empty return type path"));
};
let child_name = last.ident.to_string();
let stem = crate::codegen::contract::stem_of(&child_name).unwrap_or(&child_name);
last.ident = format_ident!("{}Client", stem, span = last.ident.span());
last.arguments = syn::PathArguments::None;
let recursive = single && last.ident == *client_ty;
(quote! { #path }, recursive)
};
let child_event = if recursive {
quote! { #event_ty }
} else {
quote! { <#child_client<()> as #client::Aggregated>::Event }
};
let boxed = dynamic || recursive;
let payload = if boxed { quote! { ::std::boxed::Box<#child_event> } } else { child_event.clone() };
Ok(Self {
fn_name: c.fn_name.clone(),
description: c.description.clone(),
child_client_key: child_client.to_string(),
child_ty: child_ty.clone(),
segment,
dynamic,
child_client,
recursive,
child_event,
payload,
boxed,
variant,
})
}
}
fn option_inner(ty: &Type) -> Option<&Type> {
if !is_option_type(ty) {
return None;
}
let Type::Path(p) = ty else { return None };
let syn::PathArguments::AngleBracketed(args) = &p.path.segments.last()?.arguments else { return None };
match args.args.first()? {
syn::GenericArgument::Type(t) => Some(t),
_ => None,
}
}
fn wrap_ident(client_ty: &syn::Ident, variant: &syn::Ident) -> syn::Ident {
format_ident!("__{}{}", client_ty, variant)
}
fn child_accessor(
n: &ChildNode,
namespace: &str,
client_ty: &syn::Ident,
event_ty: &syn::Ident,
client: &syn::Path,
reserved: &Reserved,
) -> TokenStream {
let fn_name = &n.fn_name;
let segment = &n.segment;
let child_client = &n.child_client;
let child_event = &n.child_event;
let variant = &n.variant;
if n.dynamic {
let statics = &reserved.statics;
let routes = format!(
"The instance `name` of the dynamic child `{segment}` — its methods go to \
`{namespace}.<name>.<method>` (or beneath wherever this client is mounted), and \
its events are this client's, as `{event_ty}::{variant} {{ name, event }}`. A \
name that is empty, holds a `.`, is not a route segment (`[a-z][a-z0-9_]*`) or is \
a static child's segment of `{namespace}` cannot reach the instance: every call \
through it fails at once with `ClientError::InvalidName`, and nothing is sent."
);
let doc = if n.description.is_empty() { routes } else { format!("{}\n\n{routes}", n.description) };
quote! {
#[doc = #doc]
pub fn #fn_name(&self, name: &str)
-> #child_client<&T, #client::Named<L, #child_event, #event_ty>>
{
#child_client::lifted(
&self.transport,
self.route.instance(#namespace, name, &[#(#statics),*]),
#client::Named::new(
::core::clone::Clone::clone(&self.lift),
::std::sync::Arc::from(name),
|name, event| #event_ty::#variant { name, event: ::std::boxed::Box::new(event) },
),
)
}
}
} else {
let joined = format!("{namespace}.{segment}");
let wrap_ty = wrap_ident(client_ty, variant);
let routes = format!(
"The `{segment}` child — its methods go to `{namespace}.{segment}.<method>` (or \
beneath wherever this client is mounted), and its events are this client's, as \
`{event_ty}::{variant}`."
);
let doc = if n.description.is_empty() { routes } else { format!("{}\n\n{routes}", n.description) };
quote! {
#[doc = #doc]
pub fn #fn_name(&self) -> #child_client<&T, #client::Static<L, #wrap_ty>> {
#child_client::lifted(
&self.transport,
self.route.child(#segment, #joined),
#client::Static::new(::core::clone::Clone::clone(&self.lift), #wrap_ty),
)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pascal_case_of_wire_names() {
assert_eq!(pascal("ping"), "Ping");
assert_eq!(pascal("get_status"), "GetStatus");
assert_eq!(pascal("claude_code"), "ClaudeCode");
assert_eq!(pascal("claudecode"), "Claudecode");
assert_eq!(pascal("set-status"), "SetStatus");
assert_eq!(pascal("a.b"), "AB");
assert_eq!(pascal("getHTTP"), "GetHTTP");
}
#[test]
fn a_stream_alias_is_pascal_namespace_and_method_plus_stream() {
assert_eq!(stream_alias_name("root", "tick", &[]), "RootTickStream");
assert_eq!(stream_alias_name("claude_code", "get_status", &[]), "ClaudeCodeGetStatusStream");
}
#[test]
fn the_aggregate_is_pascal_namespace_plus_event() {
assert_eq!(aggregate_name("conformance"), "ConformanceEvent");
assert_eq!(aggregate_name("tickets"), "TicketsEvent");
assert_eq!(aggregate_name("claude_code"), "ClaudeCodeEvent");
assert_eq!(aggregate_name("hyperforge"), "HyperforgeEvent");
}
#[test]
fn an_identifier_that_is_not_one_is_an_error() {
assert!(derived_ident("Self", "x", Span::call_site()).is_err());
assert!(derived_ident("9Lives", "x", Span::call_site()).is_err());
assert!(derived_ident("GetStatus", "x", Span::call_site()).is_ok());
}
}