chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

events-macros: Pass EventKind and EventKindVariation by value

Browse Source
This commit is contained in:
Jonas Platte 2021-10-06 22:08:11 +02:00
parent a3ef0ad2a4
commit 0a679816a9
No known key found for this signature in database
GPG Key ID: CC154DE0E30B7C67
4 changed files with 67 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
crates/ruma-events-macros/src/event.rs
View File

@ -41,10 +41,10 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
)); ));
}; };
let conversion_impl = expand_from_into(&input, &kind, &var, &fields, &ruma_events); let conversion_impl = expand_from_into(&input, kind, var, &fields, &ruma_events);
let serialize_impl = expand_serialize_event(&input, &var, &fields, &ruma_events); let serialize_impl = expand_serialize_event(&input, var, &fields, &ruma_events);
let deserialize_impl = expand_deserialize_event(&input, &kind, &var, &fields, &ruma_events)?; let deserialize_impl = expand_deserialize_event(&input, kind, var, &fields, &ruma_events)?;
let redact_impl = expand_redact_event(&input, &kind, &var, &fields, &ruma_events); let redact_impl = expand_redact_event(&input, kind, var, &fields, &ruma_events);
let eq_impl = expand_eq_ord_event(&input, &fields); let eq_impl = expand_eq_ord_event(&input, &fields);
Ok(quote! { Ok(quote! {
@ -58,7 +58,7 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
fn expand_serialize_event( fn expand_serialize_event(
input: &DeriveInput, input: &DeriveInput,
var: &EventKindVariation, var: EventKindVariation,
fields: &[Field], fields: &[Field],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
@ -125,8 +125,8 @@ fn expand_serialize_event(
fn expand_deserialize_event( fn expand_deserialize_event(
input: &DeriveInput, input: &DeriveInput,
_kind: &EventKind, _kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
fields: &[Field], fields: &[Field],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
@ -401,16 +401,16 @@ fn expand_deserialize_event(
fn expand_redact_event( fn expand_redact_event(
input: &DeriveInput, input: &DeriveInput,
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
fields: &[Field], fields: &[Field],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers }; let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
let redacted_type = kind.to_event_ident(&var.to_redacted()?)?; let redacted_type = kind.to_event_ident(var.to_redacted()?)?;
let redacted_content_trait = let redacted_content_trait =
format_ident!("{}Content", kind.to_event_ident(&EventKindVariation::Redacted).unwrap()); format_ident!("{}Content", kind.to_event_ident(EventKindVariation::Redacted).unwrap());
let ident = &input.ident; let ident = &input.ident;
let mut generics = input.generics.clone(); let mut generics = input.generics.clone();
@ -473,8 +473,8 @@ fn expand_redact_event(
fn expand_from_into( fn expand_from_into(
input: &DeriveInput, input: &DeriveInput,
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
fields: &[Field], fields: &[Field],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
@ -487,7 +487,7 @@ fn expand_from_into(
let fields: Vec<_> = fields.iter().flat_map(|f| &f.ident).collect(); let fields: Vec<_> = fields.iter().flat_map(|f| &f.ident).collect();
if let EventKindVariation::Sync | EventKindVariation::RedactedSync = var { if let EventKindVariation::Sync | EventKindVariation::RedactedSync = var {
let full_struct = kind.to_event_ident(&var.to_full().unwrap()).unwrap(); let full_struct = kind.to_event_ident(var.to_full().unwrap()).unwrap();
Some(quote! { Some(quote! {
#[automatically_derived] #[automatically_derived]
impl #impl_generics ::std::convert::From<#full_struct #ty_gen> impl #impl_generics ::std::convert::From<#full_struct #ty_gen>

18
crates/ruma-events-macros/src/event_content.rs
View File

@ -46,9 +46,9 @@ impl EventMeta {
} }
} }
fn get_event_kind(&self) -> Option<&EventKind> { fn get_event_kind(&self) -> Option<EventKind> {
match self { match self {
Self::Kind(k) => Some(k), Self::Kind(k) => Some(*k),
_ => None, _ => None,
} }
} }
@ -88,7 +88,7 @@ impl MetaAttrs {
self.0.iter().find_map(|a| a.get_event_type()) self.0.iter().find_map(|a| a.get_event_type())
} }
fn get_event_kind(&self) -> Option<&EventKind> { fn get_event_kind(&self) -> Option<EventKind> {
self.0.iter().find_map(|a| a.get_event_kind()) self.0.iter().find_map(|a| a.get_event_kind())
} }
} }
@ -173,7 +173,7 @@ fn generate_redacted_event_content(
input: &DeriveInput, input: &DeriveInput,
event_type: &LitStr, event_type: &LitStr,
ruma_events: &TokenStream, ruma_events: &TokenStream,
event_kind: Option<&EventKind>, event_kind: Option<EventKind>,
) -> Result<TokenStream, syn::Error> { ) -> Result<TokenStream, syn::Error> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers }; let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
let serde = quote! { #ruma_events::exports::serde }; let serde = quote! { #ruma_events::exports::serde };
@ -326,7 +326,7 @@ fn generate_redacted_event_content(
} }
fn generate_event_type_aliases( fn generate_event_type_aliases(
event_kind: &EventKind, event_kind: EventKind,
ident: &Ident, ident: &Ident,
event_type: &str, event_type: &str,
ruma_events: &TokenStream, ruma_events: &TokenStream,
@ -350,7 +350,7 @@ fn generate_event_type_aliases(
EventKindVariation::RedactedSync, EventKindVariation::RedactedSync,
] ]
.iter() .iter()
.filter_map(|kind| Some((kind, event_kind.to_event_ident(kind)?))) .filter_map(|&kind| Some((kind, event_kind.to_event_ident(kind)?)))
.map(|(kind, ev_struct)| { .map(|(kind, ev_struct)| {
let ev_type = format_ident!("{}{}", kind, ev_type_s); let ev_type = format_ident!("{}{}", kind, ev_type_s);
@ -383,7 +383,7 @@ fn generate_event_type_aliases(
} }
fn generate_marker_trait_impl( fn generate_marker_trait_impl(
event_kind: &EventKind, event_kind: EventKind,
ident: &Ident, ident: &Ident,
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
@ -442,7 +442,7 @@ fn generate_event_content_impl(
fn generate_static_event_content_impl( fn generate_static_event_content_impl(
ident: &Ident, ident: &Ident,
event_kind: &EventKind, event_kind: EventKind,
redacted: bool, redacted: bool,
event_type: &LitStr, event_type: &LitStr,
ruma_events: &TokenStream, ruma_events: &TokenStream,
@ -467,7 +467,7 @@ fn generate_static_event_content_impl(
} }
} }
fn needs_redacted(input: &[MetaAttrs], event_kind: Option<&EventKind>) -> bool { fn needs_redacted(input: &[MetaAttrs], event_kind: Option<EventKind>) -> bool {
// `is_custom` means that the content struct does not need a generated // `is_custom` means that the content struct does not need a generated
// redacted struct also. If no `custom_redacted` attrs are found the content // redacted struct also. If no `custom_redacted` attrs are found the content
// needs a redacted struct generated. // needs a redacted struct generated.

81
crates/ruma-events-macros/src/event_enum.rs
View File

@ -6,7 +6,7 @@ use syn::{Attribute, Data, DataEnum, DeriveInput, Ident, LitStr};
use crate::event_parse::{EventEnumDecl, EventEnumEntry, EventKind, EventKindVariation}; use crate::event_parse::{EventEnumDecl, EventEnumEntry, EventKind, EventKindVariation};
fn is_non_stripped_room_event(kind: &EventKind, var: &EventKindVariation) -> bool { fn is_non_stripped_room_event(kind: EventKind, var: EventKindVariation) -> bool {
matches!(kind, EventKind::Message | EventKind::State) matches!(kind, EventKind::Message | EventKind::State)
&& matches!( && matches!(
var, var,
@ -17,12 +17,12 @@ fn is_non_stripped_room_event(kind: &EventKind, var: &EventKindVariation) -> boo
) )
} }
fn has_prev_content_field(kind: &EventKind, var: &EventKindVariation) -> bool { fn has_prev_content_field(kind: EventKind, var: EventKindVariation) -> bool {
matches!(kind, EventKind::State) matches!(kind, EventKind::State)
&& matches!(var, EventKindVariation::Full | EventKindVariation::Sync) && matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
} }
type EventKindFn = fn(&EventKind, &EventKindVariation) -> bool; type EventKindFn = fn(EventKind, EventKindVariation) -> bool;
/// This const is used to generate the accessor methods for the `Any*Event` enums. /// This const is used to generate the accessor methods for the `Any*Event` enums.
/// ///
@ -34,7 +34,7 @@ const EVENT_FIELDS: &[(&str, EventKindFn)] = &[
&& matches!(var, EventKindVariation::Full | EventKindVariation::Redacted) && matches!(var, EventKindVariation::Full | EventKindVariation::Redacted)
}), }),
("event_id", is_non_stripped_room_event), ("event_id", is_non_stripped_room_event),
("sender", |kind, &var| { ("sender", |kind, var| {
matches!(kind, EventKind::Message | EventKind::State | EventKind::ToDevice) matches!(kind, EventKind::Message | EventKind::State | EventKind::ToDevice)
&& var != EventKindVariation::Initial && var != EventKindVariation::Initial
}), }),
@ -48,19 +48,18 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
let ruma_events = crate::import_ruma_events(); let ruma_events = crate::import_ruma_events();
let kind = &input.kind; let kind = input.kind;
let attrs = &input.attrs; let attrs = &input.attrs;
let events: Vec<_> = input.events.iter().map(|entry| entry.ev_type.clone()).collect(); let events: Vec<_> = input.events.iter().map(|entry| entry.ev_type.clone()).collect();
let variants: Vec<_> = let variants: Vec<_> =
input.events.iter().map(EventEnumEntry::to_variant).collect::<syn::Result<_>>()?; input.events.iter().map(EventEnumEntry::to_variant).collect::<syn::Result<_>>()?;
let event_enum = expand_event_enum(kind, &events, attrs, &variants, &V::Full, &ruma_events); let event_enum = expand_event_enum(kind, &events, attrs, &variants, V::Full, &ruma_events);
let sync_event_enum = let sync_event_enum = expand_event_enum(kind, &events, attrs, &variants, V::Sync, &ruma_events);
expand_event_enum(kind, &events, attrs, &variants, &V::Sync, &ruma_events);
let stripped_event_enum = let stripped_event_enum =
expand_event_enum(kind, &events, attrs, &variants, &V::Stripped, &ruma_events); expand_event_enum(kind, &events, attrs, &variants, V::Stripped, &ruma_events);
let initial_event_enum = let initial_event_enum =
expand_event_enum(kind, &events, attrs, &variants, &V::Initial, &ruma_events); expand_event_enum(kind, &events, attrs, &variants, V::Initial, &ruma_events);
let redacted_event_enums = let redacted_event_enums =
expand_redacted_event_enum(kind, &events, attrs, &variants, &ruma_events); expand_redacted_event_enum(kind, &events, attrs, &variants, &ruma_events);
let event_content_enum = expand_content_enum(kind, &events, attrs, &variants, &ruma_events); let event_content_enum = expand_content_enum(kind, &events, attrs, &variants, &ruma_events);
@ -76,11 +75,11 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
} }
fn expand_event_enum( fn expand_event_enum(
kind: &EventKind, kind: EventKind,
events: &[LitStr], events: &[LitStr],
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
var: &EventKindVariation, var: EventKindVariation,
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let serde = quote! { #ruma_events::exports::serde }; let serde = quote! { #ruma_events::exports::serde };
@ -187,8 +186,8 @@ fn expand_from_impl(
} }
fn expand_conversion_impl( fn expand_conversion_impl(
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
@ -197,7 +196,7 @@ fn expand_conversion_impl(
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var)?;
match var { match var {
EventKindVariation::Full | EventKindVariation::Redacted => { EventKindVariation::Full | EventKindVariation::Redacted => {
let sync = kind.to_event_enum_ident(&var.to_sync().unwrap())?; let sync = kind.to_event_enum_ident(var.to_sync().unwrap())?;
let ident_variants = variants.iter().map(|v| v.match_arm(&ident)); let ident_variants = variants.iter().map(|v| v.match_arm(&ident));
let self_variants = variants.iter().map(|v| v.ctor(quote! { Self })); let self_variants = variants.iter().map(|v| v.ctor(quote! { Self }));
@ -220,7 +219,7 @@ fn expand_conversion_impl(
}) })
} }
EventKindVariation::Sync | EventKindVariation::RedactedSync => { EventKindVariation::Sync | EventKindVariation::RedactedSync => {
let full = kind.to_event_enum_ident(&var.to_full().unwrap())?; let full = kind.to_event_enum_ident(var.to_full().unwrap())?;
let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self })); let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self }));
let full_variants = variants.iter().map(|v| v.ctor(&full)); let full_variants = variants.iter().map(|v| v.ctor(&full));
@ -256,7 +255,7 @@ fn expand_conversion_impl(
/// No content enums are generated since no part of the API deals with /// No content enums are generated since no part of the API deals with
/// redacted event's content. There are only five state variants that contain content. /// redacted event's content. There are only five state variants that contain content.
fn expand_redacted_event_enum( fn expand_redacted_event_enum(
kind: &EventKind, kind: EventKind,
events: &[LitStr], events: &[LitStr],
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
@ -265,8 +264,8 @@ fn expand_redacted_event_enum(
use EventKindVariation as V; use EventKindVariation as V;
if matches!(kind, EventKind::Message | EventKind::State) { if matches!(kind, EventKind::Message | EventKind::State) {
let full = expand_event_enum(kind, events, attrs, variants, &V::Redacted, ruma_events); let full = expand_event_enum(kind, events, attrs, variants, V::Redacted, ruma_events);
let sync = expand_event_enum(kind, events, attrs, variants, &V::RedactedSync, ruma_events); let sync = expand_event_enum(kind, events, attrs, variants, V::RedactedSync, ruma_events);
quote! { quote! {
#full #full
@ -279,7 +278,7 @@ fn expand_redacted_event_enum(
/// Create a content enum from `EventEnumInput`. /// Create a content enum from `EventEnumInput`.
fn expand_content_enum( fn expand_content_enum(
kind: &EventKind, kind: EventKind,
events: &[LitStr], events: &[LitStr],
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
@ -366,14 +365,14 @@ fn expand_content_enum(
fn expand_redact( fn expand_redact(
ident: &Ident, ident: &Ident,
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers }; let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
let redacted_enum = kind.to_event_enum_ident(&var.to_redacted()?)?; let redacted_enum = kind.to_event_enum_ident(var.to_redacted()?)?;
let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self })); let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self }));
let redacted_variants = variants.iter().map(|v| v.ctor(&redacted_enum)); let redacted_variants = variants.iter().map(|v| v.ctor(&redacted_enum));
@ -403,8 +402,8 @@ fn expand_redact(
} }
fn expand_redacted_enum( fn expand_redacted_enum(
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let serde = quote! { #ruma_events::exports::serde }; let serde = quote! { #ruma_events::exports::serde };
@ -413,7 +412,7 @@ fn expand_redacted_enum(
if let EventKind::State | EventKind::Message = kind { if let EventKind::State | EventKind::Message = kind {
let ident = format_ident!("AnyPossiblyRedacted{}", kind.to_event_ident(var)?); let ident = format_ident!("AnyPossiblyRedacted{}", kind.to_event_ident(var)?);
let regular_enum_ident = kind.to_event_enum_ident(var)?; let regular_enum_ident = kind.to_event_enum_ident(var)?;
let redacted_enum_ident = kind.to_event_enum_ident(&var.to_redacted()?)?; let redacted_enum_ident = kind.to_event_enum_ident(var.to_redacted()?)?;
Some(quote! { Some(quote! {
/// An enum that holds either regular un-redacted events or redacted events. /// An enum that holds either regular un-redacted events or redacted events.
@ -451,13 +450,13 @@ fn expand_redacted_enum(
} }
} }
fn generate_event_idents(kind: &EventKind, var: &EventKindVariation) -> Option<(Ident, Ident)> { fn generate_event_idents(kind: EventKind, var: EventKindVariation) -> Option<(Ident, Ident)> {
kind.to_event_ident(var).zip(kind.to_event_enum_ident(var)) kind.to_event_ident(var).zip(kind.to_event_enum_ident(var))
} }
fn generate_custom_variant( fn generate_custom_variant(
event_struct: &Ident, event_struct: &Ident,
var: &EventKindVariation, var: EventKindVariation,
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> (TokenStream, TokenStream) { ) -> (TokenStream, TokenStream) {
use EventKindVariation as V; use EventKindVariation as V;
@ -506,7 +505,7 @@ fn generate_custom_variant(
} }
} }
fn marker_trait(kind: &EventKind, ruma_events: &TokenStream) -> TokenStream { fn marker_trait(kind: EventKind, ruma_events: &TokenStream) -> TokenStream {
let marker_trait = match kind { let marker_trait = match kind {
EventKind::State => quote! { StateEventContent }, EventKind::State => quote! { StateEventContent },
EventKind::Message => quote! { MessageEventContent }, EventKind::Message => quote! { MessageEventContent },
@ -525,8 +524,8 @@ fn marker_trait(kind: &EventKind, ruma_events: &TokenStream) -> TokenStream {
} }
fn accessor_methods( fn accessor_methods(
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
@ -606,8 +605,8 @@ fn accessor_methods(
/// Redacted events do NOT generate `content` or `prev_content` methods like /// Redacted events do NOT generate `content` or `prev_content` methods like
/// un-redacted events; otherwise, they are the same. /// un-redacted events; otherwise, they are the same.
fn redacted_accessor_methods( fn redacted_accessor_methods(
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
@ -626,8 +625,8 @@ fn redacted_accessor_methods(
fn to_event_path( fn to_event_path(
name: &LitStr, name: &LitStr,
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let span = name.span(); let span = name.span();
@ -645,8 +644,8 @@ fn to_event_path(
let path = path.iter().map(|s| Ident::new(s, span)); let path = path.iter().map(|s| Ident::new(s, span));
let event_name = if *kind == EventKind::ToDevice { let event_name = if kind == EventKind::ToDevice {
assert_eq!(*var, EventKindVariation::Full); assert_eq!(var, EventKindVariation::Full);
format_ident!("ToDevice{}Event", event) format_ident!("ToDevice{}Event", event)
} else { } else {
format_ident!("{}{}Event", var, event) format_ident!("{}{}Event", var, event)
@ -655,7 +654,7 @@ fn to_event_path(
} }
fn to_event_content_path( fn to_event_content_path(
kind: &EventKind, kind: EventKind,
name: &LitStr, name: &LitStr,
prefix: Option<&str>, prefix: Option<&str>,
ruma_events: &TokenStream, ruma_events: &TokenStream,
@ -710,8 +709,8 @@ fn to_camel_case(name: &LitStr) -> syn::Result<Ident> {
fn generate_accessor( fn generate_accessor(
name: &str, name: &str,
kind: &EventKind, kind: EventKind,
var: &EventKindVariation, var: EventKindVariation,
is_event_kind: EventKindFn, is_event_kind: EventKindFn,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_events: &TokenStream, ruma_events: &TokenStream,
@ -736,7 +735,7 @@ fn generate_accessor(
fn field_return_type( fn field_return_type(
name: &str, name: &str,
var: &EventKindVariation, var: EventKindVariation,
ruma_events: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let ruma_common = quote! { #ruma_events::exports::ruma_common }; let ruma_common = quote! { #ruma_events::exports::ruma_common };

8
crates/ruma-events-macros/src/event_parse.rs
View File

@ -71,7 +71,7 @@ impl EventKindVariation {
} }
// If the variants of this enum change `to_event_path` needs to be updated as well. // If the variants of this enum change `to_event_path` needs to be updated as well.
#[derive(Debug, Eq, PartialEq)] #[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EventKind { pub enum EventKind {
GlobalAccountData, GlobalAccountData,
RoomAccountData, RoomAccountData,
@ -121,7 +121,7 @@ impl IdentFragment for EventKindVariation {
} }
impl EventKind { impl EventKind {
pub fn to_event_ident(&self, var: &EventKindVariation) -> Option<Ident> { pub fn to_event_ident(self, var: EventKindVariation) -> Option<Ident> {
use EventKindVariation as V; use EventKindVariation as V;
// this match is only used to validate the input // this match is only used to validate the input
@ -134,12 +134,12 @@ impl EventKind {
} }
} }
pub fn to_event_enum_ident(&self, var: &EventKindVariation) -> Option<Ident> { pub fn to_event_enum_ident(self, var: EventKindVariation) -> Option<Ident> {
Some(format_ident!("Any{}", self.to_event_ident(var)?)) Some(format_ident!("Any{}", self.to_event_ident(var)?))
} }
/// `Any[kind]EventContent` /// `Any[kind]EventContent`
pub fn to_content_enum(&self) -> Ident { pub fn to_content_enum(self) -> Ident {
format_ident!("Any{}Content", self) format_ident!("Any{}Content", self)
} }
} }