Keep order of generic args (fixes #400)

This is a breaking change to public interface (Reference::generics,
Reference::generics_mut), but I think it's justified
(returning HashMap there was misleading).

Author: Vlad-Shcherbina

specta-serde/src/validate.rs

@@ -99,7 +99,8 @@ fn inner(
                 checked_references.insert(r.sid());
                 // TODO: We don't error here for `Any`/`Unknown` in the TS exporter
                 if let Some(ty) = types.get(r.sid()) {
-                    inner(ty.ty(), types, r.generics(), checked_references)?;
+                    let generics_map: BTreeMap<_, _> = r.generics().iter().cloned().collect();
+                    inner(ty.ty(), types, &generics_map, checked_references)?;
                 }
             }
         }
@@ -177,8 +178,8 @@ fn is_valid_map_key(
         }
         DataType::Reference(r) => {
             let ty = types.get(r.sid()).expect("Type was never populated"); // TODO: Error properly
-
-            is_valid_map_key(ty.ty(), types, r.generics())
+            let generics_map: BTreeMap<_, _> = r.generics().iter().cloned().collect();
+            is_valid_map_key(ty.ty(), types, &generics_map)
         }
         DataType::Generic(g) => {
             let ty = generics.get(g).expect("bruh");

specta-typescript/src/inline.rs

@@ -150,8 +150,8 @@ fn inner(
                         false,
                         truely_force_inline,
                         &r.generics()
-                            .clone()
-                            .into_iter()
+                            .iter()
+                            .cloned()
                             .map(|(g, mut dt)| {
                                 resolve_generics(&mut dt, generics);
                                 (g, dt)

specta/src/datatype/reference.rs

@@ -1,7 +1,5 @@
 //! Helpers for generating [Type::reference] implementations.
 
-use std::collections::BTreeMap;
-
 use crate::SpectaID;
 
 use super::{DataType, Generic};
@@ -11,15 +9,15 @@ use super::{DataType, Generic};
 #[non_exhaustive]
 pub struct Reference {
     pub(crate) sid: SpectaID,
-    pub(crate) generics: BTreeMap<Generic, DataType>,
+    pub(crate) generics: Vec<(Generic, DataType)>,
     pub(crate) inline: bool,
 }
 
 impl Reference {
     /// TODO: Explain invariant.
     pub fn construct(
         sid: SpectaID,
-        generics: impl Into<BTreeMap<Generic, DataType>>,
+        generics: impl Into<Vec<(Generic, DataType)>>,
         inline: bool,
     ) -> Self {
         Self {
@@ -35,12 +33,12 @@ impl Reference {
     }
 
     /// Get the generic parameters set on this reference which will be filled in by the [NamedDataType].
-    pub fn generics(&self) -> &BTreeMap<Generic, DataType> {
+    pub fn generics(&self) -> &[(Generic, DataType)] {
         &self.generics
     }
 
     /// Get the generic parameters set on this reference which will be filled in by the [NamedDataType].
-    pub fn generics_mut(&mut self) -> &mut BTreeMap<Generic, DataType> {
+    pub fn generics_mut(&mut self) -> &mut Vec<(Generic, DataType)> {
         &mut self.generics
     }
 

tests/tests/ts_rs/generics.rs

@@ -219,3 +219,25 @@ fn inline() {
 
 //     assert_ts_export!(D::<&str, 41>, "export type D<T> = { t: Array<T>, }")
 // }
+
+// https://github.com/specta-rs/specta/issues/400
+#[test]
+fn generic_parameter_order_preserved() {
+    #[derive(Type)]
+    #[specta(export = false)]
+    struct Pair<Z, A> {
+        first: Z,
+        second: A,
+    }
+
+    #[derive(Type)]
+    #[specta(export = false)]
+    struct Container {
+        pair: Pair<i32, String>,
+    }
+
+    assert_ts_export!(
+        Container,
+        "export type Container = { pair: Pair<number, string> };"
+    );
+}