From f5a36f7270487681c402eeb8e12c1a4a4dce5e5c Mon Sep 17 00:00:00 2001
From: Knut Wannheden <knut@moderne.io>
Date: Sun, 29 Sep 2024 16:47:10 +0200
Subject: [PATCH] Support union types

---
 openrewrite/src/java/tree/types.ts        | 14 ++++++++++
 openrewrite/src/javascript/typeMapping.ts | 33 ++++++++++++++---------
 2 files changed, 35 insertions(+), 12 deletions(-)

diff --git a/openrewrite/src/java/tree/types.ts b/openrewrite/src/java/tree/types.ts
index a8a6c3f..3dd70d2 100644
--- a/openrewrite/src/java/tree/types.ts
+++ b/openrewrite/src/java/tree/types.ts
@@ -11,6 +11,20 @@ export namespace JavaType {
     export class Class extends FullyQualified {
     }
 
+    @LstType("org.openrewrite.java.tree.JavaType$MultiCatch")
+    export class Union implements JavaType {
+        private _types: JavaType[] | null = null;
+
+        get types(): JavaType[] {
+            return this._types!;
+        }
+
+        unsafeSet(types: JavaType[]): this {
+            this._types = types;
+            return this;
+        }
+    }
+
     @LstType("org.openrewrite.java.tree.JavaType$ShallowClass")
     export class ShallowClass extends FullyQualified {
     }
diff --git a/openrewrite/src/javascript/typeMapping.ts b/openrewrite/src/javascript/typeMapping.ts
index 31f84c8..c320585 100644
--- a/openrewrite/src/javascript/typeMapping.ts
+++ b/openrewrite/src/javascript/typeMapping.ts
@@ -18,18 +18,18 @@ export class JavaScriptTypeMapping {
             type = this.checker.getTypeFromTypeNode(node);
         }
 
-        if (type) {
-            const signature = this.checker.typeToString(type);
-            const existing = this.typeCache.get(signature);
-            if (existing) {
-                return existing;
-            }
-            const result = this.createType(node, type, signature);
-            this.typeCache.set(signature, result);
-            return result;
-        }
+        return type ? this.getType(type) : null;
+    }
 
-        return null;
+    private getType(type: ts.Type) {
+        const signature = this.checker.typeToString(type);
+        const existing = this.typeCache.get(signature);
+        if (existing) {
+            return existing;
+        }
+        const result = this.createType(type, signature);
+        this.typeCache.set(signature, result);
+        return result;
     }
 
     primitiveType(node: ts.Node): JavaType.Primitive {
@@ -51,7 +51,7 @@ export class JavaScriptTypeMapping {
         return null;
     }
 
-    private createType(node: ts.Node, type: ts.Type, signature: string): JavaType {
+    private createType(type: ts.Type, signature: string): JavaType {
         if (type.isLiteral()) {
             if (type.isNumberLiteral()) {
                 return JavaType.Primitive.of(JavaType.PrimitiveKind.Double);
@@ -76,6 +76,15 @@ export class JavaScriptTypeMapping {
             return JavaType.Primitive.of(JavaType.PrimitiveKind.String);
         }
 
+        if (type.isUnion()) {
+            let result = new JavaType.Union();
+            this.typeCache.set(signature, result);
+
+            const types = type.types.map(t => this.getType(t));
+            result.unsafeSet(types);
+            return result;
+        }
+
         // if (ts.isRegularExpressionLiteral(node)) {
         //     return JavaType.Primitive.of(JavaType.PrimitiveKind.String);
         // }