39 basic rust types (#52)

* Add support for rust
* Add generic type reification
* Add cyclic reference detection

Author: cuzfrog

.github/workflows/ci.yaml

@@ -89,7 +89,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 22
       - uses: actions/download-artifact@v4
         with:
           name: generated-sources
@@ -102,6 +102,14 @@ jobs:
           npm i
           npm run test
 
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.83.0
+      - name: Test Rust
+        working-directory: client-test/rust
+        run: cargo test
+
 #  clean-artifact:
 #    needs: [ jdk_compatibility_test, client_test ]
 #    runs-on: ubuntu-latest

.gitignore

@@ -33,3 +33,6 @@ build/
 ### VS Code ###
 .vscode/*
 !.vscode/settings.json
+
+### MacOS ###
+.DS_Store

README.md

@@ -1,4 +1,6 @@
 [![CI](https://github.com/cuzfrog/sharedtype/actions/workflows/ci.yaml/badge.svg)](https://github.com/cuzfrog/sharedtype/actions/workflows/ci.yaml)
+![Maven Central Version](https://img.shields.io/maven-central/v/online.sharedtype/sharedtype?style=plastic)
+
 # SharedType - Sharing Java Types made easy
 From Java:
 ```java
@@ -21,34 +23,32 @@ type User struct {
     Email string
 }
 ```
-Rust (Planed):
+Rust:
 ```rust
-struct User {
+pub struct User {
     name: String,
     age: i32,
     email: String,
 }
 ```
-And more.
 
 ## Features
-* Java8 support. No hassles.
+* Java8 support.
 * Generics support.
 * (Planed) Constant support.
-* Client source dependency is only `@SharedType`. Nothing gets into bytecode/runtime.
-* SharedType AP jars <100KB, only 2 small dependencies: jsr305 annotations and [mustache](https://github.com/spullara/mustache.java). Download less.
-* Parsing takes milliseconds with `-proc:only`. Implemented with performance in head.
-* Intuitive defaults, put `@SharedType` and there you go.
-* Global + class level options. Fine tune your configs.
-
-## Similar Projects
-* [bsorrentino/java2typescript](https://github.com/bsorrentino/java2typescript)
-* [vojtechhabarta/typescript-generator](https://github.com/vojtechhabarta/typescript-generator)
+* Client source dependency is only `@SharedType` retained at source code level.
+* SharedType AP jar <150KB, only 2 small dependencies: jsr305 annotations and [mustache](https://github.com/spullara/mustache.java).
+* Parsing takes milliseconds with `-proc:only`.
+* Intuitive defaults, put `@SharedType` and there you go. Global + class level options.
 
 ## Documentation
 * [User Guide](doc/Usage.md)
 * [Developer Guide](doc/Development.md)
 
+## Similar Projects
+* [bsorrentino/java2typescript](https://github.com/bsorrentino/java2typescript)
+* [vojtechhabarta/typescript-generator](https://github.com/vojtechhabarta/typescript-generator)
+
 ## Authors
 Cause Chung (cuzfrog@gmail.com)
 

annotation/src/main/java/online/sharedtype/SharedType.java

@@ -30,19 +30,52 @@
  * </p>
  *
  * <p>
- * <b>Inner class:</b><br>
+ * <b>Inheritance:</b>
+ * In different target schemas, inheritance may be transferred differently.
+ * <ul>
+ *     <li>Typescript: Inheritance is mimicked. A subtype's inherited properties will not be included in its own declared properties,
+ *     while the supertype is also emitted. </li>
+ *     <li>Rust: Inheritance is not supported.
+ *     Type hierarchy will be flattened that a subtype's inherited properties will be included in its own declared properties,
+ *     while, by default, any supertypes will not be emitted again.</li>
+ * </ul>
+ * </p>
+ *
+ * <p>
+ * <b>Inner classes:</b><br>
  * Declared inner and nested types will not be included by default, unless they are referenced by other types.
  * Non-static inner classes are not supported.
  * </p>
  *
  * <p>
+ * <b>Cyclic Reference:</b><br>
+ * <ul>
+ *     <li>Rust: Cyclic references will be wrapped in {@code Option<Box<T>>}.</li>
+ * </ul>
+ * </p>
+ *
+ * <p>
+ * <b>Constants:</b><br>
+ * Support is planned in upcoming versions. Only compile-time resolvable values or their combinations are supported.
+ * </p>
+ *
+ * <p>
  * <b>Generics:</b><br>
- * Generics are supported. But it's also limited to target schema's capacity.
+ * Generics are supported. But it's also limited to target schema's capacity. Currently, type bounds are not supported.
  * </p>
  *
  * <p>
  * <b>Collections:</b><br>
- * Iterables and arrays are treated as arrays. Map is mapped to:
+ * Iterables and arrays are treated as arrays and, by default, are mapped to:
+ * <ul>
+ *     <li>Typescript: {@code T[]}</li>
+ *     <li>Rust: {@code Vec<T>}</li>
+ * </ul>
+ *
+ * Maps are mapped to:
+ * <p>
+ * <b>Maps:</b><br>
+ * (Not supported yet.)
  * <ul>
  *     <li>Typescript: {@code [key: string]: T} where {@code T} can be a reified type.</li>
  * </ul>
@@ -52,6 +85,7 @@
  * @author Cause Chung
  * @implNote generics type bounds are not supported yet, Map is not supported yet.
  */
+// TODO: test user-defined array-like types
 @Retention(RetentionPolicy.SOURCE)
 @Target({java.lang.annotation.ElementType.TYPE})
 @Documented
@@ -86,6 +120,15 @@
      */
     ComponentType[] includes() default {ComponentType.FIELDS, ComponentType.ACCESSORS, ComponentType.CONSTANTS};
 
+    /**
+     * Macros to be added to the type in generated Rust code. E.g. "Debug" will generate {@code #[derive](Debug)}.
+     * This property only affects this annotated type. By default, "Debug" and "PartialEq" are added to all types, which can be configured via global properties.
+     * Resulted macros contain both global default and this property.
+     *
+     * @return Rust macro traits. E.g. "serde::Serialize".
+     */
+    String[] rustMacroTraits() default {};
+
     /**
      * Mark a method as an accessor regardless of its name.
      * Getter prefixes are configured in global properties.
@@ -100,7 +143,7 @@
      * Exclude fields, record components, accessors in a type, or a dependency type, e.g. a supertype.
      * <p>
      * <b>When placed on a type:</b> a subtype of this type will not extend this type in target code.
-     * But if this type is referenced directly as type of a field or return type of an accessor, a compilation error will be reported,
+     * But if this type is referenced directly as type of field or return type of accessor, a compilation error will be reported,
      * unless the field or accessor is also ignored.
      * </p>
      */

client-test/rust/Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "sharedtype-client-test-rust"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

client-test/rust/Cargo.toml

@@ -0,0 +1,54 @@
+mod types;
+
+#[cfg(test)]
+mod tests {
+    use super::types::*;
+
+    #[test]
+    fn cyclic_dependencies() {
+        let dep_a = DependencyClassA {
+            b: Some(Box::new(DependencyClassB {
+                c: Some(Box::new(DependencyClassC {
+                    a: Some(Box::new(DependencyClassA {
+                      b: None,
+                      a: 6,
+                      value: 33,
+                      notIgnoredImplementedMethod: 999,
+                    })),
+                })),
+            })),
+            a: 5,
+            value: 4,
+            notIgnoredImplementedMethod: 5,
+        };
+        let json = serde_json::to_string(&dep_a).unwrap();
+
+        let dep_a_deser: DependencyClassA = serde_json::from_str(&json).unwrap();
+        assert_eq!(dep_a_deser, dep_a);
+
+        print!("{}", &json);
+        assert_eq!(&json, r#"{"b":{"c":{"a":{"b":null,"a":6,"value":33,"notIgnoredImplementedMethod":999}}},"a":5,"value":4,"notIgnoredImplementedMethod":5}"#);
+    }
+
+    #[test]
+    fn recursieve_type() {
+        let recusive_class = RecursiveClass {
+            directRef: Some(Box::new(RecursiveClass {
+                directRef: None,
+                arrayRef: vec![],
+            })),
+            arrayRef: vec![Box::new(RecursiveClass {
+                directRef: None,
+                arrayRef: vec![],
+            })],
+        };
+
+        let json = serde_json::to_string(&recusive_class).unwrap();
+
+        let recusive_class_deser: RecursiveClass = serde_json::from_str(&json).unwrap();
+        assert_eq!(recusive_class_deser, recusive_class);
+
+        print!("{}", &json);
+        assert_eq!(&json, r#"{"directRef":{"directRef":null,"arrayRef":[]},"arrayRef":[{"directRef":null,"arrayRef":[]}]}"#);
+    }
+}

client-test/rust/src/lib.rs

@@ -0,0 +1 @@
+../../../it/java17/target/generated-sources/types.rs

client-test/rust/src/types.rs

@@ -1,5 +1,5 @@
 #!/bin/bash
 
-export PATH=$NODE20_HOME/bin:./node_modules/.bin:$PATH
+export PATH=$NODE22_HOME/bin:./node_modules/.bin:$PATH
 echo Node:"$(node -v)"
 

client-test/typescript/setenv

@@ -1,4 +1,4 @@
-import type {DependencyClassA, DependencyClassB, DependencyClassC, EnumGalaxy, EnumSize, EnumTShirt, JavaRecord, AnotherJavaClass} from "../src/index.java17.js";
+import type { DependencyClassA, DependencyClassB, DependencyClassC, EnumGalaxy, EnumSize, EnumTShirt, JavaRecord, AnotherJavaClass, RecursiveClass } from "../src/index.java17.js";
 
 export const list1: EnumGalaxy[] = ["Andromeda", "MilkyWay", "Triangulum"];
 export const record1: Record<EnumTShirt, number> = {
@@ -8,7 +8,9 @@ export const record1: Record<EnumTShirt, number> = {
 }
 export const size1: EnumSize = 1;
 
-export const dependencyClassC: DependencyClassC = {} as DependencyClassC;
+export const dependencyClassC: DependencyClassC = {
+    a: {} as DependencyClassA, // TODO: optional for cyclic dependency
+};
 
 export const dependencyClassB: DependencyClassB = {
     c: dependencyClassC
@@ -22,7 +24,7 @@ export const dependencyClassA: DependencyClassA = {
 };
 dependencyClassC.a = dependencyClassA
 
-export const obj: Omit<JavaRecord<string, number>, "aVoid" | "genericMap"> = {
+export const obj: Omit<JavaRecord<string>, "aVoid" | "genericMap"> = {
     boxedBoolean: false,
     boxedByte: 0,
     boxedChar: "",
@@ -58,3 +60,11 @@ export const obj: Omit<JavaRecord<string, number>, "aVoid" | "genericMap"> = {
 export const anotherJavaClass: AnotherJavaClass = {
     value: 333,
 }
+
+export const recursiveClass: RecursiveClass = {
+    directRef: {
+        directRef: {} as RecursiveClass, // TODO: optional for cyclic dependency
+        arrayRef: [],
+    },
+    arrayRef: [],
+}