preparation for #209 - allow non const TypeID

macros/src/type/enum.rs

@@ -10,6 +10,7 @@ pub fn parse_enum(
  container_attrs: &ContainerAttr,
  generics: &Generics,
  crate_ref: &TokenStream,
+ sid: &TokenStream,
  data: &DataEnum,
 ) -> syn::Result<(TokenStream, TokenStream, bool)> {
  if container_attrs.transparent {
@@ -232,12 +233,12 @@ pub fn parse_enum(
  let skip_bigint_checs = enum_attrs.unstable_skip_bigint_checks;
 
  Ok((
- quote!(#crate_ref::DataType::Enum(#crate_ref::internal::construct::r#enum(#name.into(), SID, #repr, #skip_bigint_checs, vec![#(#definition_generics),*], vec![#(#variant_types),*]))),
+ quote!(#crate_ref::DataType::Enum(#crate_ref::internal::construct::r#enum(#name.into(), #sid, #repr, #skip_bigint_checs, vec![#(#definition_generics),*], vec![#(#variant_types),*]))),
  quote!({
  let generics = vec![#(#reference_generics),*];
  #crate_ref::reference::reference::<Self>(type_map, #crate_ref::internal::construct::data_type_reference(
  #name.into(),
- SID,
+ #sid,
  generics
  ))
  }),

macros/src/type/mod.rs

@@ -44,14 +44,18 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
  unraw_raw_ident(&format_ident!("{}", raw_ident.to_string())).to_token_stream()
  });
 
+ let sid = quote!(#crate_ref::internal::construct::sid(#name, concat!("::", module_path!(), ":", line!(), ":", column!())));
  let (inlines, reference, can_flatten) = match data {
- Data::Struct(data) => parse_struct(&name, &container_attrs, generics, &crate_ref, data),
+ Data::Struct(data) => {
+ parse_struct(&name, &container_attrs, generics, &crate_ref, &sid, data)
+ }
  Data::Enum(data) => parse_enum(
  &name,
  &EnumAttr::from_attrs(&container_attrs, &mut attrs)?,
  &container_attrs,
  generics,
  &crate_ref,
+ &sid,
  data,
  ),
  Data::Union(data) => Err(syn::Error::new_spanned(
@@ -123,12 +127,10 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
  let comments = &container_attrs.common.doc;
  let deprecated = container_attrs.common.deprecated_as_tokens(&crate_ref);
 
- let sid = quote!(#crate_ref::internal::construct::sid(#name, concat!("::", module_path!(), ":", line!(), ":", column!())));
  let impl_location = quote!(#crate_ref::internal::construct::impl_location(concat!(file!(), ":", line!(), ":", column!())));
 
  Ok(quote! {
  const _: () = {
- const SID: #crate_ref::SpectaID = #sid;
  const IMPL_LOCATION: #crate_ref::ImplLocation = #impl_location;
  const DEFINITION_GENERICS: &[#crate_ref::DataType] = &[#(#definition_generics),*];
 
@@ -150,14 +152,16 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
 
  #[automatically_derived]
  impl #bounds #crate_ref::NamedType for #ident #type_args #where_bound {
- const SID: #crate_ref::SpectaID = SID;
+ fn sid() -> #crate_ref::SpectaID {
+ #sid
+ }
 
  fn named_data_type(type_map: &mut #crate_ref::TypeMap, generics: &[#crate_ref::DataType]) -> #crate_ref::NamedDataType {
  #crate_ref::internal::construct::named_data_type(
  #name.into(),
  #comments.into(),
  #deprecated,
- SID,
+ #sid,
  IMPL_LOCATION,
  <Self as #crate_ref::Type>::inline(type_map, #crate_ref::Generics::Provided(generics))
  )
@@ -168,7 +172,7 @@ pub fn derive(input: proc_macro::TokenStream) -> syn::Result<proc_macro::TokenSt
  #name.into(),
  #comments.into(),
  #deprecated,
- SID,
+ #sid,
  IMPL_LOCATION,
  <Self as #crate_ref::Type>::inline(type_map, #crate_ref::Generics::Definition)
  )

macros/src/type/struct.rs

@@ -40,6 +40,7 @@ pub fn parse_struct(
  container_attrs: &ContainerAttr,
  generics: &Generics,
  crate_ref: &TokenStream,
+ sid: &TokenStream,
  data: &DataStruct,
 ) -> syn::Result<(TokenStream, TokenStream, bool)> {
  let generic_idents = generics
@@ -189,7 +190,7 @@ pub fn parse_struct(
  quote! {
  fn validate_flatten<T: #crate_ref::Flatten>() {}
  validate_flatten::<#field_ty>();
- #crate_ref::internal::flatten::<#field_ty>(SID, type_map, &generics)
+ #crate_ref::internal::flatten::<#field_ty>(#sid, type_map, &generics)
  }
  } else {
  quote! {
@@ -265,7 +266,7 @@ pub fn parse_struct(
  Fields::Unit => quote!(#crate_ref::internal::construct::struct_unit()),
  };
 
- quote!(#crate_ref::DataType::Struct(#crate_ref::internal::construct::r#struct(#name.into(), Some(SID), vec![#(#definition_generics),*], #fields)))
+ quote!(#crate_ref::DataType::Struct(#crate_ref::internal::construct::r#struct(#name.into(), Some(#sid), vec![#(#definition_generics),*], #fields)))
  };
 
  let category = if container_attrs.inline {
@@ -278,7 +279,7 @@ pub fn parse_struct(
  #reference_generics
  #crate_ref::reference::reference::<Self>(type_map, #crate_ref::internal::construct::data_type_reference(
  #name.into(),
- SID,
+ #sid,
  vec![#(#reference_generics2),*]
  ))
  })

src/datatype/reference.rs

@@ -17,10 +17,12 @@ pub fn inline<T: Type + ?Sized>(type_map: &mut TypeMap, generics: &[DataType]) -
 }
 
 pub fn reference<T: NamedType>(type_map: &mut TypeMap, reference: DataTypeReference) -> Reference {
- if type_map.map.get(&T::SID).is_none() {
- type_map.map.entry(T::SID).or_insert(None);
+ let sid = T::sid();
+
+ if type_map.map.get(&sid).is_none() {
+ type_map.map.entry(sid).or_insert(None);
  let dt = T::definition_named_data_type(type_map);
- type_map.map.insert(T::SID, Some(dt));
+ type_map.map.insert(sid, Some(dt));
  }
 
  Reference {

src/type/macros.rs

@@ -77,7 +77,9 @@ macro_rules! impl_containers {
  }
 
  impl<T: NamedType> NamedType for $container<T> {
- const SID: SpectaID = T::SID;
+ fn sid() -> SpectaID {
+ T::sid()
+ }
 
  fn named_data_type(type_map: &mut TypeMap, generics: &[DataType]) -> NamedDataType {
  T::named_data_type(type_map, generics)

src/type/mod.rs

@@ -60,7 +60,8 @@ pub trait Type {
 /// NamedType represents a type that can be converted into [NamedDataType].
 /// This will be implemented for all types with the [Type] derive macro.
 pub trait NamedType: Type {
- const SID: SpectaID;
+ // TODO: I hate this being a method
+ fn sid() -> SpectaID;
 
  // TODO: Should take `Generics` instead of `&[DataType]` but I plan to remove this trait so not fixing it for now.
  /// this is equivalent to [Type::inline] but returns a [NamedDataType] instead.