It suddenly occurred to me, type should be layered

, to handle TS types that are in  the format as Java types

Author: ZZZank

src/main/java/com/probejs/rewrite/doc/DocClazz.java

@@ -24,6 +24,7 @@ public class DocClazz implements CommentHolder {
     private final DocComment comment;
     private final ClazzPath path;
     private final List<DocType> assignables;
+    private final ClassInfo info;
 
     private DocClazz(Class<?> clazz) {
         //doc properties
@@ -33,6 +34,7 @@ private DocClazz(Class<?> clazz) {
         this.assignables = new ArrayList<>();
         this.comment = new DocComment();
         //properties from ClassInfo
+        this.info = cInfo;
         this.fields = cInfo.getFields().stream().map(DocField::new).collect(Collectors.toList());
         this.methods = cInfo.getMethods().stream().map(DocMethod::new).collect(Collectors.toList());
     }

src/main/java/com/probejs/rewrite/doc/type/DocTypeResolver.java

@@ -1,25 +1,26 @@
 package com.probejs.rewrite.doc.type;
 
-import com.probejs.info.type.IType;
-import com.probejs.info.type.TypeArray;
-import com.probejs.info.type.TypeClass;
+import com.probejs.rewrite.doc.type.java.JavaType;
+import com.probejs.rewrite.doc.type.java.TypeArray;
 import com.probejs.rewrite.doc.type.java.TypeClazz;
 
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
 
 public abstract class DocTypeResolver {
 
-    private static final Map<Class<? extends IType>, Function<IType, DocType>> REGISTRIES;
+    private static final Map<Class<? extends Type>, Function<Type, JavaType>> JAVA;
 
     static {
-        REGISTRIES = new HashMap<>();
-        REGISTRIES.put(TypeClass.class, TypeClazz::new);
-        REGISTRIES.put(TypeArray.class, com.probejs.rewrite.doc.type.java.TypeArray::new);
+        JAVA = new HashMap<>();
+        JAVA.put(Class.class, TypeClazz::new);
+        JAVA.put(GenericArrayType.class, TypeArray::new);
     }
 
-    public static DocType of(IType type) {
-        return REGISTRIES.get(type.getClass()).apply(type);
+    public static JavaType ofJava(Type type) {
+        return JAVA.get(type.getClass()).apply(type);
     }
 }

src/main/java/com/probejs/rewrite/doc/type/java/TypeArray.java

@@ -1,16 +1,65 @@
 package com.probejs.rewrite.doc.type.java;
 
-import com.probejs.info.type.IType;
-import com.probejs.rewrite.doc.type.DocType;
 import com.probejs.rewrite.doc.type.DocTypeResolver;
 import lombok.Getter;
 
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.util.Collection;
+
 @Getter
-public class TypeArray implements DocType {
+public class TypeArray implements JavaType {
+
+    private final JavaType base;
+    private final boolean isGenericArray;
+
+    /**
+     * @return {@code type instanceof GenericArrayType}
+     */
+    public static boolean isGenericArray(Type type) {
+        return type instanceof GenericArrayType;
+    }
 
-    private final DocType base;
+    /**
+     * @return true if it can be cast into {@code Class<?>} and {@code ((Class<?>) type).isArray()}
+     * is true, otherwise false
+     */
+    public static boolean isClassArray(Type type) {
+        if (type instanceof Class<?> clazz) {
+            return clazz.isArray();
+        }
+        return false;
+    }
+
+    public static boolean test(Type type) {
+        return isGenericArray(type) || isClassArray(type);
+    }
+
+    public TypeArray(Type type) {
+        if (isGenericArray(type)) {
+            this.base = DocTypeResolver.ofJava(((GenericArrayType) type).getGenericComponentType());
+            isGenericArray = true;
+        } else if (isClassArray(type)) {
+            assert type instanceof Class<?>;
+            this.base = DocTypeResolver.ofJava(((Class<?>) type).getComponentType());
+            isGenericArray = false;
+        } else {
+            throw new IllegalArgumentException("Argument 'type' is not array");
+        }
+    }
+
+    @Override
+    public Type raw() {
+        return base.raw();
+    }
+
+    @Override
+    public JavaType base() {
+        return base;
+    }
 
-    public TypeArray(IType type) {
-        this.base = DocTypeResolver.of(type.getBase());
+    @Override
+    public Collection<Class<?>> relatedClasses() {
+        return base.relatedClasses();
     }
 }

src/main/java/com/probejs/rewrite/doc/type/java/TypeClazz.java

@@ -8,8 +8,12 @@
 import com.probejs.rewrite.doc.type.DocType;
 import lombok.Getter;
 
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.List;
+
 @Getter
-public class TypeClazz implements DocType {
+public class TypeClazz implements JavaType {
 
     private final ClazzPath path;
     private final DocClazz doc;
@@ -25,7 +29,24 @@ public class TypeClazz implements DocType {
         this(clazz.getRaw());
     }
 
-    public TypeClazz(IType iType) {
-        this(((TypeClass) iType).getRaw());
+    public TypeClazz(Type type) {
+
+        this(ClassInfo.ofCache((Class<?>) type));
+    }
+
+    @Override
+    public Type raw() {
+        return doc.getInfo().getRaw();
+    }
+
+    @Override
+    public JavaType base() {
+        return this;
+    }
+
+    @Override
+    public Collection<Class<?>> relatedClasses() {
+        //TODO: could be related to ClassWalker
+        return List.of();
     }
 }

src/main/java/com/probejs/rewrite/doc/type/java/TypeParameterized.java

@@ -0,0 +1,51 @@
+package com.probejs.rewrite.doc.type.java;
+
+import com.probejs.rewrite.doc.type.DocTypeResolver;
+import lombok.val;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * "List<String>"
+ * @author ZZZank
+ */
+public class TypeParameterized implements JavaType {
+
+    private final JavaType base;
+    private final List<JavaType> params;
+
+    public TypeParameterized(Type parameterized) {
+        assert parameterized instanceof ParameterizedType;
+        val type = (ParameterizedType) parameterized;
+        this.base = DocTypeResolver.ofJava(type.getRawType());
+        this.params = Arrays.stream(type.getActualTypeArguments())
+            .map(DocTypeResolver::ofJava)
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public Type raw() {
+        return null;
+    }
+
+    @Override
+    public JavaType base() {
+        return base;
+    }
+
+    @Override
+    public Collection<Class<?>> relatedClasses() {
+        val related = new ArrayList<Class<?>>(1+params.size()+1);
+        related.addAll(base.relatedClasses());
+        for (val param : params) {
+            related.addAll(param.relatedClasses());
+        }
+        return related;
+    }
+}