From 78b6e1574a998a7b5779b532063158ad15e2e1f9 Mon Sep 17 00:00:00 2001
From: Hana <andywangsy@gmail.com>
Date: Sat, 14 Jan 2023 18:27:46 +0800
Subject: [PATCH] fix(napi-derive): fix union type generation for ts function
 notation (#1439)

* fix(backend): fix union type generation for ts function notation

* chore: update snapshot

* fix: naming
---
 crates/backend/src/lib.rs                   |  72 ++++-----
 crates/backend/src/typegen.rs               | 165 ++++++++++++--------
 examples/napi/__test__/typegen.spec.ts.md   |   1 +
 examples/napi/__test__/typegen.spec.ts.snap | Bin 3635 -> 3645 bytes
 examples/napi/index.d.ts                    |   1 +
 examples/napi/src/either.rs                 |   3 +
 6 files changed, 139 insertions(+), 103 deletions(-)

diff --git a/crates/backend/src/lib.rs b/crates/backend/src/lib.rs
index 3ba74cd8..2340ded4 100644
--- a/crates/backend/src/lib.rs
+++ b/crates/backend/src/lib.rs
@@ -56,40 +56,40 @@ napi_ast_impl! {
  (Const, NapiConst),
 }
 
-pub(crate) static PRIMITIVE_TYPES: &[(&str, &str)] = &[
-  ("JsUndefined", "undefined"),
-  ("()", "undefined"),
-  ("Undefined", "undefined"),
-  ("JsNumber", "number"),
-  ("i8", "number"),
-  ("i16", "number"),
-  ("i32", "number"),
-  ("i64", "number"),
-  ("f32", "number"),
-  ("f64", "number"),
-  ("u8", "number"),
-  ("u16", "number"),
-  ("u32", "number"),
-  ("u64", "bigint"),
-  ("i64n", "bigint"),
-  ("u128", "bigint"),
-  ("i128", "bigint"),
-  ("usize", "bigint"),
-  ("isize", "bigint"),
-  ("JsBigInt", "bigint"),
-  ("BigInt", "bigint"),
-  ("JsBoolean", "boolean"),
-  ("bool", "boolean"),
-  ("JsString", "string"),
-  ("String", "string"),
-  ("str", "string"),
-  ("Latin1String", "string"),
-  ("Utf16String", "string"),
-  ("char", "string"),
-  ("Null", "null"),
-  ("JsNull", "null"),
-  ("null", "null"),
-  ("Symbol", "symbol"),
-  ("JsSymbol", "symbol"),
-  ("JsFunction", "(...args: any[]) => any"),
+pub(crate) static PRIMITIVE_TYPES: &[(&str, (&str, bool, bool))] = &[
+  ("JsUndefined", ("undefined", false, false)),
+  ("()", ("undefined", false, false)),
+  ("Undefined", ("undefined", false, false)),
+  ("JsNumber", ("number", false, false)),
+  ("i8", ("number", false, false)),
+  ("i16", ("number", false, false)),
+  ("i32", ("number", false, false)),
+  ("i64", ("number", false, false)),
+  ("f32", ("number", false, false)),
+  ("f64", ("number", false, false)),
+  ("u8", ("number", false, false)),
+  ("u16", ("number", false, false)),
+  ("u32", ("number", false, false)),
+  ("u64", ("bigint", false, false)),
+  ("i64n", ("bigint", false, false)),
+  ("u128", ("bigint", false, false)),
+  ("i128", ("bigint", false, false)),
+  ("usize", ("bigint", false, false)),
+  ("isize", ("bigint", false, false)),
+  ("JsBigInt", ("bigint", false, false)),
+  ("BigInt", ("bigint", false, false)),
+  ("JsBoolean", ("boolean", false, false)),
+  ("bool", ("boolean", false, false)),
+  ("JsString", ("string", false, false)),
+  ("String", ("string", false, false)),
+  ("str", ("string", false, false)),
+  ("Latin1String", ("string", false, false)),
+  ("Utf16String", ("string", false, false)),
+  ("char", ("string", false, false)),
+  ("Null", ("null", false, false)),
+  ("JsNull", ("null", false, false)),
+  ("null", ("null", false, false)),
+  ("Symbol", ("symbol", false, false)),
+  ("JsSymbol", ("symbol", false, false)),
+  ("JsFunction", ("(...args: any[]) => any", true, false)),
 ];
diff --git a/crates/backend/src/typegen.rs b/crates/backend/src/typegen.rs
index 3ca88a06..1e94f9a2 100644
--- a/crates/backend/src/typegen.rs
+++ b/crates/backend/src/typegen.rs
@@ -118,74 +118,75 @@ pub trait ToTypeDef {
   fn to_type_def(&self) -> Option<TypeDef>;
 }
 
-static KNOWN_TYPES: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
+/// Mapping from `rust_type` to (`ts_type`, `is_ts_function_type_notation`, `is_ts_union_type`)
+static KNOWN_TYPES: Lazy<HashMap<&'static str, (&'static str, bool, bool)>> = Lazy::new(|| {
   let mut map = HashMap::default();
   map.extend(crate::PRIMITIVE_TYPES.iter().cloned());
   map.extend([
-    ("JsObject", "object"),
-    ("Object", "object"),
-    ("Array", "unknown[]"),
-    ("Value", "any"),
-    ("Map", "Record<string, any>"),
-    ("HashMap", "Record<{}, {}>"),
-    ("ArrayBuffer", "ArrayBuffer"),
-    ("Int8Array", "Int8Array"),
-    ("Uint8Array", "Uint8Array"),
-    ("Uint8ClampedArray", "Uint8ClampedArray"),
-    ("Int16Array", "Int16Array"),
-    ("Uint16Array", "Uint16Array"),
-    ("Int32Array", "Int32Array"),
-    ("Uint32Array", "Uint32Array"),
-    ("Float32Array", "Float32Array"),
-    ("Float64Array", "Float64Array"),
-    ("BigInt64Array", "BigInt64Array"),
-    ("BigUint64Array", "BigUint64Array"),
-    ("DataView", "DataView"),
-    ("DateTime", "Date"),
-    ("Date", "Date"),
-    ("JsDate", "Date"),
-    ("JsBuffer", "Buffer"),
-    ("Buffer", "Buffer"),
-    ("Vec", "Array<{}>"),
-    ("Result", "Error | {}"),
-    ("Error", "Error"),
-    ("JsError", "Error"),
-    ("JsTypeError", "TypeError"),
-    ("JsRangeError", "RangeError"),
-    ("ClassInstance", "{}"),
-    ("Either", "{} | {}"),
-    ("Either3", "{} | {} | {}"),
-    ("Either4", "{} | {} | {} | {}"),
-    ("Either5", "{} | {} | {} | {} | {}"),
-    ("Either6", "{} | {} | {} | {} | {} | {}"),
-    ("Either7", "{} | {} | {} | {} | {} | {} | {}"),
-    ("Either8", "{} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either9", "{} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either10", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either11", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either12", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either13", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either14", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either15", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either16", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either17", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either18", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either19", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either20", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either21", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either22", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either23", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either24", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either25", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("Either26", "{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}"),
-    ("external", "object"),
-    ("AbortSignal", "AbortSignal"),
-    ("JsGlobal", "typeof global"),
-    ("External", "ExternalObject<{}>"),
-    ("unknown", "unknown"),
-    ("Unknown", "unknown"),
-    ("JsUnknown", "unknown"),
-    ("This", "this")
+    ("JsObject", ("object", false, false)),
+    ("Object", ("object", false, false)),
+    ("Array", ("unknown[]", false, false)),
+    ("Value", ("any", false, false)),
+    ("Map", ("Record<string, any>", false, false)),
+    ("HashMap", ("Record<{}, {}>", false, false)),
+    ("ArrayBuffer", ("ArrayBuffer", false, false)),
+    ("Int8Array", ("Int8Array", false, false)),
+    ("Uint8Array", ("Uint8Array", false, false)),
+    ("Uint8ClampedArray", ("Uint8ClampedArray", false, false)),
+    ("Int16Array", ("Int16Array", false, false)),
+    ("Uint16Array", ("Uint16Array", false, false)),
+    ("Int32Array", ("Int32Array", false, false)),
+    ("Uint32Array", ("Uint32Array", false, false)),
+    ("Float32Array", ("Float32Array", false, false)),
+    ("Float64Array", ("Float64Array", false, false)),
+    ("BigInt64Array", ("BigInt64Array", false, false)),
+    ("BigUint64Array", ("BigUint64Array", false, false)),
+    ("DataView", ("DataView", false, false)),
+    ("DateTime", ("Date", false, false)),
+    ("Date", ("Date", false, false)),
+    ("JsDate", ("Date", false, false)),
+    ("JsBuffer", ("Buffer", false, false)),
+    ("Buffer", ("Buffer", false, false)),
+    ("Vec", ("Array<{}>", false, false)),
+    ("Result", ("Error | {}", false, true)),
+    ("Error", ("Error", false, false)),
+    ("JsError", ("Error", false, false)),
+    ("JsTypeError", ("TypeError", false, false)),
+    ("JsRangeError", ("RangeError", false, false)),
+    ("ClassInstance", ("{}", false, false)),
+    ("Either", ("{} | {}", false, true)),
+    ("Either3", ("{} | {} | {}", false, true)),
+    ("Either4", ("{} | {} | {} | {}", false, true)),
+    ("Either5", ("{} | {} | {} | {} | {}", false, true)),
+    ("Either6", ("{} | {} | {} | {} | {} | {}", false, true)),
+    ("Either7", ("{} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either8", ("{} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either9", ("{} | {} | {} | {} | {} | {} | {} | {} | {}",false, true)),
+    ("Either10", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either11", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either12", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either13", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either14", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either15", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either16", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either17", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either18", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either19", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either20", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either21", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either22", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either23", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either24", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either25", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("Either26", ("{} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {}", false, true)),
+    ("external", ("object", false, false)),
+    ("AbortSignal", ("AbortSignal", false, false)),
+    ("JsGlobal", ("typeof global", false, false)),
+    ("External", ("ExternalObject<{}>", false, false)),
+    ("unknown", ("unknown", false, false)),
+    ("Unknown", ("unknown", false, false)),
+    ("JsUnknown", ("unknown", false, false)),
+    ("This", ("this", false, false))
   ]);
 
   map
@@ -209,6 +210,30 @@ fn fill_ty(template: &str, args: Vec<String>) -> String {
   ret
 }
 
+fn is_ts_union_type(rust_ty: &str) -> bool {
+  KNOWN_TYPES
+    .get(rust_ty)
+    .map(|&(_, _, is_union_type)| is_union_type)
+    .unwrap_or(false)
+}
+
+fn is_ts_function_type_notation(ty: &Type) -> bool {
+  match ty {
+    Type::Path(syn::TypePath { qself: None, path }) => {
+      if let Some(syn::PathSegment { ident, .. }) = path.segments.last() {
+        let rust_ty = ident.to_string();
+        return KNOWN_TYPES
+          .get(&*rust_ty)
+          .map(|&(_, is_ts_fn, _)| is_ts_fn)
+          .unwrap_or(false);
+      }
+
+      false
+    }
+    _ => false,
+  }
+}
+
 pub fn ty_to_ts_type(ty: &Type, is_return_ty: bool, is_struct_field: bool) -> (String, bool) {
   match ty {
     Type::Reference(r) => ty_to_ts_type(&r.elem, is_return_ty, is_struct_field),
@@ -235,13 +260,19 @@ pub fn ty_to_ts_type(ty: &Type, is_return_ty: bool, is_struct_field: bool) -> (S
 
       if let Some(syn::PathSegment { ident, arguments }) = path.segments.last() {
         let rust_ty = ident.to_string();
+        let is_ts_union_type = is_ts_union_type(&rust_ty);
         let args = if let syn::PathArguments::AngleBracketed(arguments) = arguments {
           arguments
             .args
             .iter()
             .filter_map(|arg| match arg {
               syn::GenericArgument::Type(generic_ty) => {
-                Some(ty_to_ts_type(generic_ty, false, false))
+                Some(ty_to_ts_type(generic_ty, false, false)).map(|(mut ty, is_struct_field)| {
+                  if is_ts_union_type && is_ts_function_type_notation(generic_ty) {
+                    ty = format!("({})", ty);
+                  }
+                  (ty, is_struct_field)
+                })
               }
               _ => None,
             })
@@ -289,7 +320,7 @@ pub fn ty_to_ts_type(ty: &Type, is_return_ty: bool, is_struct_field: bool) -> (S
               Some((rust_ty, false))
             }
           });
-        } else if let Some(&known_ty) = KNOWN_TYPES.get(rust_ty.as_str()) {
+        } else if let Some(&(known_ty, _, _)) = KNOWN_TYPES.get(rust_ty.as_str()) {
           if known_ty.contains("{}") {
             ts_ty = Some((
               fill_ty(known_ty, args.into_iter().map(|(arg, _)| arg).collect()),
diff --git a/examples/napi/__test__/typegen.spec.ts.md b/examples/napi/__test__/typegen.spec.ts.md
index 2c99d8f3..d104c6fb 100644
--- a/examples/napi/__test__/typegen.spec.ts.md
+++ b/examples/napi/__test__/typegen.spec.ts.md
@@ -79,6 +79,7 @@ Generated by [AVA](https://avajs.dev).
       baz: number␊
     }␊
     export function eitherFromObjects(input: A | B | C): string␊
+    export function eitherBoolOrFunction(input: boolean | ((...args: any[]) => any)): void␊
     /** default enum values are continuos i32s start from 0 */␊
     export const enum Kind {␊
       /** Barks */␊
diff --git a/examples/napi/__test__/typegen.spec.ts.snap b/examples/napi/__test__/typegen.spec.ts.snap
index 031a546009b36f651b186e6a25de0d6681f84193..22ff5dba4642f40fade9205f867782c97f6a02c0 100644
GIT binary patch
literal 3645
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%0AApDYnO{W64F0gMuroN*<gXz
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
PZ|?jba(Xu>bTj|}UM=_j

literal 3635
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
F000&06r%tD

diff --git a/examples/napi/index.d.ts b/examples/napi/index.d.ts
index a9c5ca4a..70132707 100644
--- a/examples/napi/index.d.ts
+++ b/examples/napi/index.d.ts
@@ -69,6 +69,7 @@ export interface C {
   baz: number
 }
 export function eitherFromObjects(input: A | B | C): string
+export function eitherBoolOrFunction(input: boolean | ((...args: any[]) => any)): void
 /** default enum values are continuos i32s start from 0 */
 export const enum Kind {
   /** Barks */
diff --git a/examples/napi/src/either.rs b/examples/napi/src/either.rs
index a316a603..cdebbed3 100644
--- a/examples/napi/src/either.rs
+++ b/examples/napi/src/either.rs
@@ -127,3 +127,6 @@ pub fn either_from_objects(input: Either3<A, B, C>) -> String {
     Either3::C(_) => "C".to_owned(),
   }
 }
+
+#[napi]
+pub fn either_bool_or_function(_input: Either<bool, JsFunction>) {}