[WIP] E2E tests

.github/workflows/test.yml

@@ -1,6 +1,33 @@
 on: [push, pull_request]
 name: Test
 jobs:
+  e2e-dependencies:
+    name: Run 'dependencies' end-to-end test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: dependencies e2e test
+        working-directory: e2e/dependencies/consumer
+        run: |
+          cargo t 
+          tsc bindings/* --noEmit
+  e2e-workspace:
+    name: Run 'workspace' end-to-end test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: workspace e2e test
+        working-directory: e2e/workspace
+        run: |
+          cargo t 
+          tsc parent/bindings/* --noEmit
+
   readme-up-to-date:
     name: Check that README.md is up-to-date
     runs-on: ubuntu-latest

.gitignore

@@ -1,4 +1,4 @@
-/target
+target/
 Cargo.lock
 /.idea
 *.ts

e2e/README.md

@@ -0,0 +1,8 @@
+# e2e tests
+### [dependencies](./dependencies)
+A user creates the crate `consumer`, which depends on some crate `dependency1`, which possibly lives on [crates.io](https://crates.io). 
+If a struct in `consumer` contains a type from `dependency1`, it should be exported as well.
+
+### [workspace](./workspace)
+A user creates a workspace, containing `crate1`, `crate2`, and `parent`.  
+`crate1` and `crate2` are independent, but `parent` depends on both `crate1` and `crate2`.

e2e/dependencies/consumer/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "consumer"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+[dependencies]
+ts-rs = { path = "../../../ts-rs" }
+dependency1 = { path = "../dependency1" }

e2e/dependencies/consumer/src/main.rs

@@ -0,0 +1,10 @@
+use ts_rs::TS;
+use dependency1::LibraryType;
+
+#[derive(TS)]
+#[ts(export)]
+struct ConsumerType {
+    pub ty: LibraryType
+}
+
+fn main() {}

e2e/dependencies/dependency1/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "dependency1"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+[dependencies]
+ts-rs = { path = "../../../ts-rs" }

e2e/dependencies/dependency1/src/lib.rs

@@ -0,0 +1,6 @@
+use ts_rs::TS;
+
+#[derive(TS)]
+pub struct LibraryType {
+    pub a: i32
+}

e2e/workspace/Cargo.toml

@@ -0,0 +1,2 @@
+[workspace]
+members = ["crate1", "crate2", "parent"]

e2e/workspace/crate1/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "crate1"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ts-rs = { path = "../../../ts-rs" }

e2e/workspace/crate1/src/lib.rs

@@ -0,0 +1,6 @@
+use ts_rs::TS;
+
+#[derive(TS)]
+pub struct Crate1 {
+    pub x: [[[i32; 128]; 128]; 128],
+}

e2e/workspace/crate2/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "crate2"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ts-rs = { path = "../../../ts-rs" }

e2e/workspace/crate2/src/lib.rs

@@ -0,0 +1,6 @@
+use ts_rs::TS;
+
+#[derive(TS)]
+pub struct Crate2 {
+    pub x: [[[i32; 128]; 128]; 128],
+}

e2e/workspace/parent/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "parent"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ts-rs = { path = "../../../ts-rs" }
+crate1 = { path = "../crate1" }
+crate2 = { path = "../crate2" }

e2e/workspace/parent/src/main.rs

@@ -0,0 +1,98 @@
+use ts_rs::TS;
+use crate1::Crate1;
+use crate2::Crate2;
+
+fn main() {
+    println!("Hello, world!");
+}
+
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent2 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent3 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent4 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent5 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent6 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent7 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent8 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent9 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent10 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent11 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent12 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent13 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent14 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}
+#[derive(TS)]
+#[ts(export)]
+pub struct Parent15 {
+    pub crate1: Crate1,
+    pub crate2: Crate2,
+}

macros/src/attr/field.rs

@@ -1,5 +1,5 @@
-use syn::{Attribute, Ident, Result};
 use syn::spanned::Spanned;
+use syn::{Attribute, Ident, Result};
 
 use crate::utils::parse_attrs;
 
@@ -60,7 +60,7 @@ impl FieldAttr {
         self.skip = self.skip || skip;
         self.optional = Optional {
             optional: self.optional.optional || optional,
-            nullable: self.optional.nullable || nullable
+            nullable: self.optional.nullable || nullable,
         };
         self.flatten |= flatten;
     }

macros/src/deps.rs

@@ -9,39 +9,26 @@ impl Dependencies {
     /// Adds all dependencies from the given type
     pub fn append_from(&mut self, ty: &Type) {
         self.0
-            .push(quote!(dependencies.append(&mut <#ty as ts_rs::TS>::dependencies());));
+            .push(quote![.extend(<#ty as ts_rs::TS>::dependency_types())]);
     }
 
     /// Adds the given type if it's *not* transparent.
     /// If it is, all it's child dependencies are added instead.
     pub fn push_or_append_from(&mut self, ty: &Type) {
-        self.0.push(quote! {
-            if <#ty as ts_rs::TS>::transparent() {
-              dependencies.append(&mut <#ty as ts_rs::TS>::dependencies());
-            } else {
-                if let Some(dep) = ts_rs::Dependency::from_ty::<#ty>() {
-                    dependencies.push(dep);
-                }
-            }
-        });
+        self.0.push(quote![.push::<#ty>()]);
     }
 
     pub fn append(&mut self, other: Dependencies) {
-        self.0.push(quote! {
-            dependencies.append(&mut #other);
-        })
+        self.0.push(quote![.extend(#other)]);
     }
 }
 
 impl ToTokens for Dependencies {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let dependencies = &self.0;
-        tokens.extend(quote! {
-            {
-                let mut dependencies = Vec::new();
-                #( #dependencies )*
-                dependencies
-            }
-        })
+        let lines = &self.0;
+        tokens.extend(quote![{
+            use ts_rs::typelist::TypeList;
+            ()#(#lines)*
+        }])
     }
 }

macros/src/lib.rs

@@ -95,12 +95,15 @@ impl DerivedTS {
                     #inline
                 }
                 #inline_flattened
-                fn dependencies() -> Vec<ts_rs::Dependency>
+
+                #[allow(clippy::unused_unit)]
+                fn dependency_types() -> impl ts_rs::typelist::TypeList
                 where
                     Self: 'static,
                 {
                     #dependencies
                 }
+
                 fn transparent() -> bool {
                     false
                 }

macros/src/types/enum.rs

@@ -115,7 +115,9 @@ fn format_variant(
                 let ty = match (type_override, type_as) {
                     (Some(_), Some(_)) => syn_err!("`type` is not compatible with `as`"),
                     (Some(type_override), None) => quote! { #type_override },
-                    (None, Some(type_as)) => format_type(&syn::parse_str::<Type>(&type_as)?, dependencies, generics), 
+                    (None, Some(type_as)) => {
+                        format_type(&syn::parse_str::<Type>(&type_as)?, dependencies, generics)
+                    }
                     (None, None) => format_type(&unnamed.unnamed[0].ty, dependencies, generics),
                 };
 
@@ -159,7 +161,9 @@ fn format_variant(
                     let ty = match (type_override, type_as) {
                         (Some(_), Some(_)) => syn_err!("`type` is not compatible with `as`"),
                         (Some(type_override), None) => quote! { #type_override },
-                        (None, Some(type_as)) => format_type(&syn::parse_str::<Type>(&type_as)?, dependencies, generics), 
+                        (None, Some(type_as)) => {
+                            format_type(&syn::parse_str::<Type>(&type_as)?, dependencies, generics)
+                        }
                         (None, None) => format_type(&unnamed.unnamed[0].ty, dependencies, generics),
                     };
 

macros/src/types/generics.rs

@@ -83,7 +83,7 @@ pub fn format_type(ty: &Type, dependencies: &mut Dependencies, generics: &Generi
         // be cause the T in `[T; N]` is technically not a generic
         Type::Array(type_array) => {
             let formatted = format_type(&type_array.elem, dependencies, generics);
-            return quote!(<#type_array>::name_with_type_args(vec![#formatted]))
+            return quote!(<#type_array>::name_with_type_args(vec![#formatted]));
         }
         // The field is a slice (`[T]`) so it technically doesn't have a
         // generic argument. Therefore, we handle it explicitly here like a `Vec<T>`

ts-rs/src/chrono.rs

@@ -7,14 +7,12 @@ use chrono::{
 };
 
 use super::{impl_primitives, TS};
-use crate::Dependency;
 
 macro_rules! impl_dummy {
     ($($t:ty),*) => {$(
         impl TS for $t {
             fn name() -> String { String::new() }
             fn inline() -> String { String::new() }
-            fn dependencies() -> Vec<Dependency> { vec![] }
             fn transparent() -> bool { false }
         }
     )*};
@@ -33,9 +31,6 @@ impl<T: TimeZone + 'static> TS for DateTime<T> {
     fn inline() -> String {
         "string".to_owned()
     }
-    fn dependencies() -> Vec<Dependency> {
-        vec![]
-    }
     fn transparent() -> bool {
         false
     }
@@ -51,9 +46,6 @@ impl<T: TimeZone + 'static> TS for Date<T> {
     fn inline() -> String {
         "string".to_owned()
     }
-    fn dependencies() -> Vec<Dependency> {
-        vec![]
-    }
     fn transparent() -> bool {
         false
     }