some idea

Author: ZZZank

dev_note.md

@@ -0,0 +1,15 @@
+
+# steps
+
+- class
+- info
+- document
+- formatter
+- compiler
+## class
+aka raw class fetching
+
+## info
+
+## document
+generic applying should be here

src/main/java/com/probejs/formatter/api/WithFormatter.java

@@ -0,0 +1,6 @@
+package com.probejs.formatter.api;
+
+public interface WithFormatter {
+
+    IFormatter toFormatter();
+}

src/main/java/com/probejs/rewrite/ClazzPath.java

@@ -0,0 +1,62 @@
+package com.probejs.rewrite;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.val;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Data
+@AllArgsConstructor
+public class ClazzPath {
+    public static final List<String> NAMESPACE_INTERNAL = Collections.singletonList("Internal");
+    public static final String NAME_UNRESOLVED = "Unresolved";
+    public static final ClazzPath UNRESOLVED = new ClazzPath(Collections.emptyList(), NAME_UNRESOLVED, false);
+
+    private final List<String> namespace;
+    private final String name;
+    private boolean isInternal;
+
+    ClazzPath(String clazzName) {
+        val path = Arrays
+            .stream(clazzName.split("\\."))
+            .map(PathResolver::getNameSafe)
+            .collect(Collectors.toList());
+        this.namespace = path.subList(1, path.size());
+        this.name = path.get(0);
+        this.isInternal = false;
+    }
+
+    public List<String> getNamespace() {
+        return this.isInternal && !this.namespace.isEmpty()
+            ? ClazzPath.NAMESPACE_INTERNAL
+            : this.namespace;
+    }
+
+    public String asStrPath(String delimiter) {
+        return String.join(delimiter, this.asStrNamespace(delimiter), this.name);
+    }
+
+    public String asStrNamespace(String delimiter) {
+        return String.join(delimiter, this.getNamespace());
+    }
+
+    public String dotPath() {
+        return asStrPath(".");
+    }
+
+    public String slashPath() {
+        return asStrPath("/");
+    }
+
+    public String dotNamespace() {
+        return this.asStrNamespace(".");
+    }
+
+    public String slashNamespace() {
+        return this.asStrNamespace("/");
+    }
+}

src/main/java/com/probejs/rewrite/PathResolver.java

@@ -0,0 +1,94 @@
+package com.probejs.rewrite;
+
+import lombok.val;
+
+import java.util.*;
+
+public abstract class PathResolver {
+    public static final HashMap<String, ClazzPath> resolved = new HashMap<>();
+    public static final HashSet<String> lastNames = new HashSet<>();
+    public static final HashSet<Class<?>> primitives = new HashSet<>();
+    /**
+     * language keywords used by typescript
+     */
+    public static final Set<String> langKeywords = new HashSet<>();
+
+    static {
+        //keywords
+        langKeywords.addAll(Arrays.asList("function", "debugger", "in", "with", "java"));
+        //pre-resolve primitive
+        val ANY = new ClazzPath(Collections.emptyList(), "any", false);
+        resolvePrimitive(Object.class, ANY);
+        val STR = new ClazzPath(Collections.emptyList(), "string", false);
+        resolvePrimitive(String.class, STR);
+        resolvePrimitive(Character.class, STR);
+        resolvePrimitive(Character.TYPE, STR);
+        val VOID = new ClazzPath(Collections.emptyList(), "void", false);
+        resolvePrimitive(Void.class, VOID);
+        resolvePrimitive(Void.TYPE, VOID);
+        val NUM = new ClazzPath(Collections.emptyList(), "number", false);
+        resolvePrimitive(Long.class, NUM);
+        resolvePrimitive(Long.TYPE, NUM);
+        resolvePrimitive(Integer.class, NUM);
+        resolvePrimitive(Integer.TYPE, NUM);
+        resolvePrimitive(Short.class, NUM);
+        resolvePrimitive(Short.TYPE, NUM);
+        resolvePrimitive(Byte.class, NUM);
+        resolvePrimitive(Byte.TYPE, NUM);
+        resolvePrimitive(Double.class, NUM);
+        resolvePrimitive(Double.TYPE, NUM);
+        resolvePrimitive(Float.class, NUM);
+        resolvePrimitive(Float.TYPE, NUM);
+        val BOOL = new ClazzPath(Collections.emptyList(), "boolean", false);
+        resolvePrimitive(Boolean.class, BOOL);
+        resolvePrimitive(Boolean.TYPE, BOOL);
+    }
+
+    public static void resolvePrimitive(Class<?> clazz, ClazzPath resolvedPath) {
+        resolveManually(clazz, resolvedPath);
+        primitives.add(clazz);
+    }
+
+    public static ClazzPath resolve(Class<?> clazz) {
+        return resolve(clazz.getName());
+    }
+
+    public static ClazzPath resolve(String clazzName) {
+        ClazzPath path = resolved.get(clazzName);
+        if (path == null) {
+            path = new ClazzPath(clazzName);
+            path.setInternal(!lastNames.contains(path.getName()));
+            resolveManually(clazzName, path);
+        }
+        return path;
+    }
+
+    public static ClazzPath resolveManually(String name, ClazzPath resolvedPath) {
+        resolved.put(name, resolvedPath);
+        lastNames.add(resolvedPath.getName());
+        return resolvedPath;
+    }
+
+    public static ClazzPath resolveManually(Class<?> clazz, ClazzPath resolvedPath) {
+        return resolveManually(clazz.getName(), resolvedPath);
+    }
+
+    public static ClazzPath resolveManually(Class<?> clazz, String resolvedPath) {
+        return resolveManually(clazz.getName(), new ClazzPath(resolvedPath));
+    }
+
+    public static ClazzPath get(String name) {
+        return resolved.getOrDefault(name, ClazzPath.UNRESOLVED);
+    }
+
+    public static boolean isNameSafe(String name) {
+        return langKeywords.contains(name);
+    }
+
+    public static String getNameSafe(String name) {
+        if (!isNameSafe(name)) {
+            name = name + "_";
+        }
+        return name;
+    }
+}