named_datatype (#122)

* named_datatype

* GenericType

* docs better

---------

Co-authored-by: Oscar Beaumont <[email protected]>

src/datatype/enum.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use crate::{
     datatype::{DataType, ObjectType, TupleType},
-    ExportError, ImplLocation,
+    ExportError, GenericType, ImplLocation,
 };
 
 /// Enum type which dictates how the enum is represented.
@@ -16,11 +16,11 @@ use crate::{
 pub enum EnumType {
     Untagged {
         variants: Vec<EnumVariant>,
-        generics: Vec<Cow<'static, str>>,
+        generics: Vec<GenericType>,
     },
     Tagged {
         variants: Vec<(Cow<'static, str>, EnumVariant)>,
-        generics: Vec<Cow<'static, str>>,
+        generics: Vec<GenericType>,
         repr: EnumRepr,
     },
 }
@@ -32,7 +32,7 @@ impl From<EnumType> for DataType {
 }
 
 impl EnumType {
-    pub(crate) fn generics(&self) -> &Vec<Cow<'static, str>> {
+    pub(crate) fn generics(&self) -> &Vec<GenericType> {
         match self {
             Self::Untagged { generics, .. } => generics,
             Self::Tagged { generics, .. } => generics,

src/datatype/mod.rs

@@ -1,4 +1,7 @@
-use std::{borrow::Cow, collections::BTreeMap};
+use std::{
+    borrow::{Borrow, Cow},
+    collections::BTreeMap,
+};
 
 mod r#enum;
 mod literal;
@@ -109,6 +112,32 @@ pub enum NamedDataTypeItem {
     Tuple(TupleType),
 }
 
+impl NamedDataTypeItem {
+    /// Converts a [`NamedDataTypeItem`] into a [`DataType`]
+    pub fn datatype(self) -> DataType {
+        match self {
+            Self::Object(o) => o.into(),
+            Self::Enum(e) => e.into(),
+            Self::Tuple(t) => t.into(),
+        }
+    }
+
+    /// Returns the generics arguments for the type
+    pub fn generics(&self) -> Vec<GenericType> {
+        match self {
+            // Named struct
+            Self::Object(ObjectType { generics, .. }) => generics.clone(),
+            // Enum
+            Self::Enum(e) => e.generics().clone(),
+            // Struct with unnamed fields
+            Self::Tuple(tuple) => match tuple {
+                TupleType::Unnamed => vec![],
+                TupleType::Named { generics, .. } => generics.clone(),
+            },
+        }
+    }
+}
+
 /// A reference to a [`DataType`] that can be used before a type is resolved in order to
 /// support recursive types without causing an infinite loop.
 ///
@@ -126,11 +155,21 @@ pub struct DataTypeReference {
     pub generics: Vec<DataType>,
 }
 
-/// A generic parameter to another type.
+/// A generic ("placeholder") argument to a Specta-enabled type.
+///
+/// A generic does not hold a specific type instead it acts as a slot where a type can be provided when referencing this type.
+///
+/// A `GenericType` holds the identifier of the generic. Eg. Given a generic type `struct A<T>(T);` the generics will be represented as `vec![GenericType("A".into())]`
 #[derive(Debug, Clone, PartialEq)]
 #[allow(missing_docs)]
 pub struct GenericType(pub Cow<'static, str>);
 
+impl Borrow<str> for GenericType {
+    fn borrow(&self) -> &str {
+        &self.0
+    }
+}
+
 impl From<GenericType> for DataType {
     fn from(t: GenericType) -> Self {
         Self::Generic(t)

src/datatype/object.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use crate::{DataType, NamedDataType, NamedDataTypeItem};
+use crate::{DataType, GenericType, NamedDataType, NamedDataTypeItem};
 
 /// A field in an [`ObjectType`].
 #[derive(Debug, Clone, PartialEq)]
@@ -16,7 +16,7 @@ pub struct ObjectField {
 /// Could be from a struct or named enum variant.
 #[derive(Debug, Clone, PartialEq)]
 pub struct ObjectType {
-    pub generics: Vec<Cow<'static, str>>,
+    pub generics: Vec<GenericType>,
     pub fields: Vec<ObjectField>,
     pub tag: Option<Cow<'static, str>>,
 }

src/datatype/tuple.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use crate::{DataType, NamedDataType, NamedDataTypeItem};
+use crate::{DataType, GenericType, NamedDataType, NamedDataTypeItem};
 
 /// Type of a tuple.
 /// Could be from an actual tuple or unnamed struct.
@@ -16,7 +16,7 @@ pub enum TupleType {
     /// Be aware `()` is treated specially as `null` in Typescript.
     Named {
         fields: Vec<DataType>,
-        generics: Vec<Cow<'static, str>>,
+        generics: Vec<GenericType>,
     },
 }