fixed wrongly mapped variables

Author: Prunoideae

src/main/java/com/prunoideae/probejs/formatter/NameResolver.java

@@ -123,7 +123,7 @@ public static String getNameSafe(String kw) {
     }
 
     public static void init() {
-        putResolvedName(Object.class, "any");
+        putResolvedName(Object.class, "object");
         putResolvedName(String.class, "string");
         putResolvedName(Character.class, "string");
         putResolvedName(Character.TYPE, "string");

src/main/java/com/prunoideae/probejs/formatter/SpecialTypes.java

@@ -1,22 +1,18 @@
 package com.prunoideae.probejs.formatter;
 
 import com.prunoideae.probejs.formatter.formatter.FormatterType;
-import com.prunoideae.probejs.formatter.formatter.IFormatter;
+import com.prunoideae.probejs.info.ClassInfo;
 import com.prunoideae.probejs.info.MethodInfo;
 import com.prunoideae.probejs.info.type.ITypeInfo;
 import com.prunoideae.probejs.info.type.TypeInfoClass;
 import com.prunoideae.probejs.info.type.TypeInfoParameterized;
 import com.prunoideae.probejs.info.type.TypeInfoVariable;
 import dev.latvian.mods.kubejs.item.ingredient.IngredientJS;
-import dev.latvian.mods.kubejs.util.BuilderBase;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.function.*;
+import java.lang.reflect.TypeVariable;
+import java.util.*;
 
 public class SpecialTypes {
 
@@ -30,22 +26,25 @@ private FormatterLambda(MethodInfo info) {
         }
 
         public String format(ITypeInfo typeInfo) {
-            List<ITypeInfo> paramTypes = new ArrayList<>();
+            Map<String, ITypeInfo> variableMap = new HashMap<>();
             if (typeInfo instanceof TypeInfoParameterized parameterized) {
-                paramTypes.addAll(parameterized.getParamTypes());
+                List<ITypeInfo> concreteTypes = new ArrayList<>(parameterized.getParamTypes());
+                for (ITypeInfo variable : info.getFrom().getParameters()) {
+                    variableMap.put(variable.getTypeName(), concreteTypes.isEmpty() ? new TypeInfoClass(Object.class) : concreteTypes.remove(0));
+                }
             }
 
             List<String> formattedParam = new ArrayList<>();
             for (MethodInfo.ParamInfo param : info.getParams()) {
                 ITypeInfo resolvedType = param.getType();
                 if (resolvedType instanceof TypeInfoVariable) {
-                    resolvedType = paramTypes.isEmpty() ? new TypeInfoClass(Object.class) : paramTypes.remove(0);
+                    resolvedType = variableMap.getOrDefault(resolvedType.getTypeName(), new TypeInfoClass(Object.class));
                 }
                 formattedParam.add("%s: %s".formatted(param.getName(), new FormatterType(resolvedType).format(0, 0)));
             }
             ITypeInfo resolvedReturn = info.getReturnType();
             if (resolvedReturn instanceof TypeInfoVariable) {
-                resolvedReturn = paramTypes.isEmpty() ? new TypeInfoClass(Object.class) : paramTypes.remove(0);
+                resolvedReturn = variableMap.getOrDefault(resolvedReturn.getTypeName(), new TypeInfoClass(Object.class));
             }
             return "(%s) => %s".formatted(String.join(", ", formattedParam), new FormatterType(resolvedReturn).format(0, 0));
         }
@@ -55,9 +54,10 @@ public static void processFunctionalInterfaces(Set<Class<?>> globalClasses) {
         for (Class<?> clazz : globalClasses) {
             if (clazz.isInterface() && clazz.getAnnotation(FunctionalInterface.class) != null && !skippedSpecials.contains(clazz)) {
                 //Functional interfaces has one and only one abstract method
-                for (Method method : clazz.getMethods()) {
-                    if (Modifier.isAbstract(method.getModifiers())) {
-                        FormatterLambda formatter = new FormatterLambda(new MethodInfo(method, method.getDeclaringClass()));
+                ClassInfo info = ClassInfo.getOrCache(clazz);
+                for (MethodInfo method : info.getMethodInfo()) {
+                    if (method.isAbstract()) {
+                        FormatterLambda formatter = new FormatterLambda(method);
                         NameResolver.putTypeFormatter(clazz, formatter::format);
                         break;
                     }

src/main/java/com/prunoideae/probejs/info/MethodInfo.java

@@ -18,6 +18,7 @@ public class MethodInfo {
     private final String name;
     private final boolean shouldHide;
     private final int modifiers;
+    private final Class<?> from;
     private ITypeInfo returnType;
     private List<ParamInfo> params;
     private List<ITypeInfo> typeVariables;
@@ -31,6 +32,7 @@ private static String getRemappedOrDefault(Method method, Class<?> from) {
     public MethodInfo(Method method, Class<?> from) {
         this.name = getRemappedOrDefault(method, from);
         this.shouldHide = method.getAnnotation(HideFromJS.class) != null;
+        this.from = from;
         this.modifiers = method.getModifiers();
         this.returnType = InfoTypeResolver.resolveType(method.getGenericReturnType());
         this.params = Arrays.stream(method.getParameters()).map(ParamInfo::new).collect(Collectors.toList());
@@ -49,6 +51,10 @@ public boolean isStatic() {
         return Modifier.isStatic(modifiers);
     }
 
+    public boolean isAbstract() {
+        return Modifier.isAbstract(modifiers);
+    }
+
     public ITypeInfo getReturnType() {
         return returnType;
     }
@@ -61,6 +67,10 @@ public List<ITypeInfo> getTypeVariables() {
         return typeVariables;
     }
 
+    public ClassInfo getFrom() {
+        return ClassInfo.getOrCache(from);
+    }
+
     public void setParams(List<ParamInfo> params) {
         this.params = params;
     }