[T; N] as Typescript tuple

specta-rs · Nov 22, 2023 · 7039fba · 7039fba
1 parent 0470a6a
commit 7039fba
Show file tree

Hide file tree

Showing 13 changed files with 123 additions and 32 deletions.
diff --git a/src/datatype/list.rs b/src/datatype/list.rs
@@ -0,0 +1,19 @@
+use crate::DataType;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct List {
+    // The type of the elements in the list.
+    pub(crate) ty: Box<DataType>,
+    // Length is set for `[Type; N]` arrays.
+    pub(crate) length: Option<usize>,
+}
+
+impl List {
+    pub fn ty(&self) -> &DataType {
+        &self.ty
+    }
+
+    pub fn length(&self) -> Option<usize> {
+        self.length
+    }
+}
diff --git a/src/datatype/mod.rs b/src/datatype/mod.rs
@@ -6,13 +6,15 @@ use std::{
 
 mod r#enum;
 mod fields;
+mod list;
 mod literal;
 mod named;
 mod primitive;
 mod r#struct;
 mod tuple;
 
 pub use fields::*;
+pub use list::*;
 pub use literal::*;
 pub use named::*;
 pub use primitive::*;
@@ -47,7 +49,7 @@ pub enum DataType {
     Primitive(PrimitiveType),
     Literal(LiteralType),
     /// Either a `Set` or a `Vec`
-    List(Box<DataType>),
+    List(List),
     Nullable(Box<DataType>),
     Map(Box<(DataType, DataType)>),
     // Anonymous Reference types

diff --git a/src/lang/ts/mod.rs b/src/lang/ts/mod.rs
@@ -216,13 +216,26 @@ pub(crate) fn datatype_inner(ctx: ExportContext, typ: &DataType, type_map: &Type
         }
         // We use `T[]` instead of `Array<T>` to avoid issues with circular references.
         DataType::List(def) => {
-            let dt = datatype_inner(ctx, def, type_map)?;
-            if (dt.contains(' ') && !dt.ends_with('}'))
+            let dt = datatype_inner(ctx, &def.ty, type_map)?;
+            let dt = if (dt.contains(' ') && !dt.ends_with('}'))
                 // This is to do with maintaining order of operations.
                 // Eg `{} | {}` must be wrapped in parens like `({} | {})[]` but `{}` doesn't cause `{}[]` is valid
                 || (dt.contains(' ') && (dt.contains("&") || dt.contains("|")))
             {
-                format!("({dt})[]")
+                format!("({dt})")
+            } else {
+                format!("{dt}")
+            };
+
+            if let Some(length) = def.length {
+                format!(
+                    "[{}]",
+                    (0..length)
+                        .into_iter()
+                        .map(|_| dt.clone())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
             } else {
                 format!("{dt}[]")
             }

diff --git a/src/serde.rs b/src/serde.rs
@@ -2,7 +2,7 @@ use thiserror::Error;
 
 use crate::{
     internal::{skip_fields, skip_fields_named},
-    DataType, EnumRepr, EnumType, EnumVariants, GenericType, LiteralType, PrimitiveType,
+    DataType, EnumRepr, EnumType, EnumVariants, GenericType, List, LiteralType, PrimitiveType,
     StructFields, TypeMap,
 };
 
@@ -247,7 +247,10 @@ fn validate_internally_tag_enum_datatype(
 fn resolve_generics(mut dt: DataType, generics: &Vec<(GenericType, DataType)>) -> DataType {
     match dt {
         DataType::Primitive(_) | DataType::Literal(_) | DataType::Any | DataType::Unknown => dt,
-        DataType::List(v) => DataType::List(Box::new(resolve_generics(*v, generics))),
+        DataType::List(v) => DataType::List(List {
+            ty: Box::new(resolve_generics(*v.ty, generics)),
+            length: v.length,
+        }),
         DataType::Nullable(v) => DataType::Nullable(Box::new(resolve_generics(*v, generics))),
         DataType::Map(v) => DataType::Map(Box::new({
             let (k, v) = *v;

diff --git a/src/type/impls.rs b/src/type/impls.rs
@@ -122,7 +122,45 @@ impl<'a, T: Type> Type for &'a [T] {
 
 impl<const N: usize, T: Type> Type for [T; N] {
     fn inline(opts: DefOpts, generics: &[DataType]) -> DataType {
-        <Vec<T>>::inline(opts, generics)
+        DataType::List(List {
+            ty: Box::new(
+                // TODO: This is cursed. Fix it properly!!!
+                match Vec::<T>::inline(
+                    DefOpts {
+                        parent_inline: opts.parent_inline,
+                        type_map: opts.type_map,
+                    },
+                    generics,
+                ) {
+                    DataType::List(List { ty, .. }) => *ty,
+                    _ => unreachable!(),
+                },
+            ),
+            length: Some(N),
+        })
+    }
+
+    fn reference(opts: DefOpts, generics: &[DataType]) -> Reference {
+        Reference {
+            inner: DataType::List(List {
+                ty: Box::new(
+                    // TODO: This is cursed. Fix it properly!!!
+                    match Vec::<T>::reference(
+                        DefOpts {
+                            parent_inline: opts.parent_inline,
+                            type_map: opts.type_map,
+                        },
+                        generics,
+                    )
+                    .inner
+                    {
+                        DataType::List(List { ty, .. }) => *ty,
+                        _ => unreachable!(),
+                    },
+                ),
+                length: Some(N),
+            }),
+        }
     }
 }
 

diff --git a/src/type/macros.rs b/src/type/macros.rs
@@ -60,7 +60,6 @@ macro_rules! impl_containers {
                     inner: generics.get(0).cloned().unwrap_or_else(
                         || T::reference(opts, generics).inner,
                     ),
-                    _priv: (),
                 }
             }
         }
@@ -100,18 +99,23 @@ macro_rules! impl_for_list {
     ($($ty:path as $name:expr)+) => {$(
         impl<T: Type> Type for $ty {
             fn inline(opts: DefOpts, generics: &[DataType]) -> DataType {
-                DataType::List(Box::new(generics.get(0).cloned().unwrap_or_else(|| T::inline(
-                    opts,
-                    generics,
-                ))))
+                DataType::List(List {
+                    ty: Box::new(generics.get(0).cloned().unwrap_or_else(|| T::inline(
+                        opts,
+                        generics,
+                    ))),
+                    length: None,
+                })
             }
 
             fn reference(opts: DefOpts, generics: &[DataType]) -> Reference {
                 Reference {
-                    inner: DataType::List(Box::new(generics.get(0).cloned().unwrap_or_else(
-                        || T::reference(opts, generics).inner,
-                    ))),
-                    _priv: (),
+                    inner: DataType::List(List {
+                        ty: Box::new(generics.get(0).cloned().unwrap_or_else(
+                            || T::reference(opts, generics).inner,
+                        )),
+                        length: None,
+                    }),
                 }
             }
         }
@@ -168,7 +172,6 @@ macro_rules! impl_for_map {
                             .inner
                         }),
                     ))),
-                    _priv: (),
                 }
             }
         }

diff --git a/src/type/mod.rs b/src/type/mod.rs
@@ -83,15 +83,14 @@ pub mod reference {
     /// A reference datatype.
     ///
     // This type exists to force the user to use [reference::inline] or [reference::reference] which provides some extra safety.
+    #[non_exhaustive]
     pub struct Reference {
         pub inner: DataType,
-        pub(crate) _priv: (),
     }
 
     pub fn inline<T: Type + ?Sized>(opts: DefOpts, generics: &[DataType]) -> Reference {
         Reference {
             inner: T::inline(opts, generics),
-            _priv: (),
         }
     }
 
@@ -115,7 +114,6 @@ pub mod reference {
 
         Reference {
             inner: DataType::Reference(reference),
-            _priv: (),
         }
     }
 }

diff --git a/tests/const_types.rs b/tests/const_types.rs
@@ -0,0 +1,8 @@
+use crate::ts::assert_ts;
+
+#[test]
+fn const_types() {
+    assert_ts!((String, String), "[string, string]");
+    assert_ts!([String; 5], "[string, string, string, string, string]");
+    assert_ts!([String; 0], "[]");
+}
diff --git a/tests/lib.rs b/tests/lib.rs
@@ -3,6 +3,7 @@
 mod advanced_types;
 mod bigints;
 mod comments;
+mod const_types;
 mod datatype;
 mod deprecated;
 mod duplicate_ty_name;

diff --git a/tests/ts.rs b/tests/ts.rs
@@ -97,7 +97,7 @@ fn typescript_types() {
 
     assert_ts!(Vec<i32>, "number[]");
     assert_ts!(&[i32], "number[]");
-    assert_ts!(&[i32; 5], "number[]");
+    assert_ts!(&[i32; 3], "[number, number, number]");
 
     assert_ts!(Option<i32>, "number | null");
 
@@ -177,7 +177,10 @@ fn typescript_types() {
     // assert_ts!(() => ..=5, r#"{ end: 5 }"#);
 
     // https://github.com/oscartbeaumont/specta/issues/66
-    assert_ts!([Option<u8>; 16], r#"(number | null)[]"#);
+    assert_ts!(
+        [Option<u8>; 3],
+        r#"[(number | null), (number | null), (number | null)]"#
+    );
 
     // https://github.com/oscartbeaumont/specta/issues/65
     assert_ts!(HashMap<BasicEnum, ()>, r#"{ [key in "A" | "B"]: null }"#);

diff --git a/tests/ts_rs/arrays.rs b/tests/ts_rs/arrays.rs
@@ -3,7 +3,7 @@ use specta::Type;
 
 #[test]
 fn free() {
-    assert_ts!([String; 10], "string[]")
+    assert_ts!([String; 3], "[string, string, string]")
 }
 
 #[test]
@@ -12,17 +12,17 @@ fn interface() {
     #[specta(export = false)]
     struct Interface {
         #[allow(dead_code)]
-        a: [i32; 10],
+        a: [i32; 3],
     }
 
-    assert_ts!(Interface, "{ a: number[] }")
+    assert_ts!(Interface, "{ a: [number, number, number] }")
 }
 
 #[test]
 fn newtype() {
     #[derive(Type)]
     #[specta(export = false)]
-    struct Newtype(#[allow(dead_code)] [i32; 10]);
+    struct Newtype(#[allow(dead_code)] [i32; 3]);
 
-    assert_ts!(Newtype, "number[]")
+    assert_ts!(Newtype, "[number, number, number]")
 }
diff --git a/tests/ts_rs/generic_fields.rs b/tests/ts_rs/generic_fields.rs
@@ -44,7 +44,7 @@ fn named() {
     }
     assert_ts!(
         Struct1,
-        "{ a: string[]; b: [string[], string[]]; c: string[][] }"
+        "{ a: string[]; b: [string[], string[]]; c: [string[], string[], string[]] }"
     );
 }
 
@@ -59,7 +59,7 @@ fn named_nested() {
     }
     assert_ts!(
         Struct2,
-        "{ a: string[][]; b: [string[][], string[][]]; c: string[][][] }"
+        "{ a: string[][]; b: [string[][], string[][]]; c: [string[][], string[][], string[][]] }"
     );
 }
 
@@ -68,7 +68,10 @@ fn tuple() {
     #[derive(Type)]
     #[specta(export = false)]
     struct Tuple1(Vec<i32>, (Vec<i32>, Vec<i32>), [Vec<i32>; 3]);
-    assert_ts!(Tuple1, "[number[], [number[], number[]], number[][]]");
+    assert_ts!(
+        Tuple1,
+        "[number[], [number[], number[]], [number[], number[], number[]]]"
+    );
 }
 
 #[test]
@@ -82,6 +85,6 @@ fn tuple_nested() {
     );
     assert_ts!(
         Tuple2,
-        "[number[][], [number[][], number[][]], number[][][]]"
+        "[number[][], [number[][], number[][]], [number[][], number[][], number[][]]]"
     );
 }
diff --git a/tests/ts_rs/generics.rs b/tests/ts_rs/generics.rs
@@ -116,7 +116,7 @@ fn generic_struct() {
 
     assert_ts_export!(
         GenericStruct2::<()>,
-        "export type GenericStruct2<T> = { a: T; b: [T, T]; c: [T, [T, T]]; d: T[]; e: ([T, T])[]; f: T[]; g: T[][]; h: (([T, T])[])[] }"
+        "export type GenericStruct2<T> = { a: T; b: [T, T]; c: [T, [T, T]]; d: [T, T, T]; e: [([T, T]), ([T, T]), ([T, T])]; f: T[]; g: T[][]; h: ([([T, T]), ([T, T]), ([T, T])])[] }"
     )
 }