rewrite SimulateOldTyping again for clearer structure

Author: ZZZank

src/main/java/zzzank/probejs/docs/SimulateOldTyping.java

@@ -1,20 +1,19 @@
 package zzzank.probejs.docs;
 
 import lombok.val;
+import org.jetbrains.annotations.NotNull;
 import zzzank.probejs.ProbeConfig;
-import zzzank.probejs.lang.java.ClassRegistry;
+import zzzank.probejs.lang.java.clazz.ClassPath;
 import zzzank.probejs.lang.typescript.Declaration;
 import zzzank.probejs.lang.typescript.ScriptDump;
-import zzzank.probejs.lang.typescript.code.Code;
 import zzzank.probejs.lang.typescript.code.member.TypeDecl;
 import zzzank.probejs.lang.typescript.code.ts.Wrapped;
 import zzzank.probejs.lang.typescript.code.type.BaseType;
 import zzzank.probejs.lang.typescript.code.type.Types;
-import zzzank.probejs.lang.typescript.refer.ImportInfo;
-import zzzank.probejs.lang.typescript.refer.ImportInfos;
 import zzzank.probejs.plugin.ProbeJSPlugin;
 import zzzank.probejs.utils.CollectUtils;
 
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -24,61 +23,62 @@ public class SimulateOldTyping implements ProbeJSPlugin {
 
     @Override
     public void addGlobals(ScriptDump scriptDump) {
-        if (ProbeConfig.simulateOldTyping.get()) {
-            scriptDump.addGlobal("simulated_internal", new DocImpl(scriptDump));
+        if (!ProbeConfig.simulateOldTyping.get()) {
+            return;
         }
-    }
 
-    public static class DocImpl extends Code {
-        private final ScriptDump scriptDump;
+        val transpiler = scriptDump.transpiler;
+        val namespace = new Wrapped.Namespace("Internal");
 
-        public DocImpl(ScriptDump scriptDump) {
-            this.scriptDump = scriptDump;
-        }
+        for (val clazz : scriptDump.recordedClasses) {
+            val path = clazz.classPath;
+            if (!path.getName().startsWith("$") || transpiler.isRejected(clazz)) {
+                continue;
+            }
 
-        @Override
-        public ImportInfos getImportInfos() {
-            val transpiler = scriptDump.transpiler;
-            return ImportInfos.of(
-                scriptDump.recordedClasses.stream()
-                    .filter(c -> !transpiler.isRejected(c))
-                    .map(c -> c.classPath)
-                    .map(ImportInfo::ofDefault));
+            if (clazz.variableTypes.isEmpty()) {
+                namespace.addCode(new NameInferredTypeDecl(path).setTypeFormat(BaseType.FormatType.RETURN));
+                namespace.addCode(new NameInferredTypeDecl(path));
+            } else {
+                val variables = CollectUtils.mapToList(
+                    clazz.variableTypes,
+                    transpiler.typeConverter::convertType
+                );
+                namespace.addCode(new NameInferredTypeDecl(variables, path).setTypeFormat(BaseType.FormatType.RETURN));
+                namespace.addCode(new NameInferredTypeDecl(variables, path));
+            }
         }
 
-        @Override
-        public List<String> format(Declaration declaration) {
-            val transpiler = scriptDump.transpiler;
-            val namespace = new Wrapped.Namespace("Internal");
+        scriptDump.addGlobal("simulated_internal", namespace);
+    }
 
-            for (val reference : declaration.references.values()) {
-                val name = reference.deduped;
-                if (!name.startsWith("$")) {
-                    continue;
-                }
+    public static class NameInferredTypeDecl extends TypeDecl {
+        private final ClassPath path;
 
-                val path = reference.info.path;
-                val clazz = path.toClazz(ClassRegistry.REGISTRY);
-                if (clazz == null || transpiler.isRejected(clazz)) {
-                    continue;
-                }
+        public NameInferredTypeDecl(@NotNull ClassPath path) {
+            super("", Types.type(path));
+            this.path = path;
+        }
+
+        public NameInferredTypeDecl(@NotNull List<? extends BaseType> symbolVariables, @NotNull ClassPath path) {
+            super("", symbolVariables, Types.type(path).withParams(symbolVariables));
+            this.path = path;
+        }
 
-                val typeName = name.substring(1);
-                if (clazz.variableTypes.isEmpty()) {
-                    val type = Types.type(path);
-                    namespace.addCode(new TypeDecl(typeName, type).setTypeFormat(BaseType.FormatType.RETURN));
-                    namespace.addCode(new TypeDecl(typeName + "_", type));
-                } else {
-                    val variables = CollectUtils.mapToList(
-                        clazz.variableTypes,
-                        transpiler.typeConverter::convertType
-                    );
-                    val type = Types.type(path).withParams(variables);
-                    namespace.addCode(new TypeDecl(typeName, variables, type).setTypeFormat(BaseType.FormatType.RETURN));
-                    namespace.addCode(new TypeDecl(typeName + "_", variables, type));
-                }
+        @Override
+        public List<String> formatRaw(Declaration declaration) {
+            val reference = declaration.references.get(path);
+            var name = reference.deduped;
+            if (!name.startsWith("$")) {
+                return Collections.emptyList();
+            }
+            name = name.substring(1);
+            if (this.typeFormat == BaseType.FormatType.INPUT) {
+                name = name + '_';
             }
-            return namespace.format(declaration);
+            this.name = name;
+
+            return super.formatRaw(declaration);
         }
     }
 }