Method type reference corrections (#142)

* Add more specific returns for translatables

* Only index method descriptors for implemented methods and methods in generated lambda classes

3 files changed, 107 insertions, 2 deletions

diff --git a/src/main/java/cuchaz/enigma/translation/representation/Lambda.java b/src/main/java/cuchaz/enigma/translation/representation/Lambda.java
new file mode 100644
index 0000000..63eb563
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/translation/representation/Lambda.java
@@ -0,0 +1,105 @@
+package cuchaz.enigma.translation.representation;

+

+import cuchaz.enigma.translation.Translatable;

+import cuchaz.enigma.translation.Translator;

+import cuchaz.enigma.translation.mapping.EntryMap;

+import cuchaz.enigma.translation.mapping.EntryMapping;

+import cuchaz.enigma.translation.mapping.EntryResolver;

+import cuchaz.enigma.translation.mapping.ResolutionStrategy;

+import cuchaz.enigma.translation.representation.entry.ClassEntry;

+import cuchaz.enigma.translation.representation.entry.MethodEntry;

+import cuchaz.enigma.translation.representation.entry.ParentedEntry;

+

+import java.util.Objects;

+

+public class Lambda implements Translatable {

+        private final String invokedName;

+        private final MethodDescriptor invokedType;

+        private final MethodDescriptor samMethodType;

+        private final ParentedEntry<?> implMethod;

+        private final MethodDescriptor instantiatedMethodType;

+

+        public Lambda(String invokedName, MethodDescriptor invokedType, MethodDescriptor samMethodType, ParentedEntry<?> implMethod, MethodDescriptor instantiatedMethodType) {

+                this.invokedName = invokedName;

+                this.invokedType = invokedType;

+                this.samMethodType = samMethodType;

+                this.implMethod = implMethod;

+                this.instantiatedMethodType = instantiatedMethodType;

+        }

+

+        @Override

+        public Lambda translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {

+                MethodEntry samMethod = new MethodEntry(getInterface(), invokedName, samMethodType);

+                EntryMapping samMethodMapping = resolveMapping(resolver, mappings, samMethod);

+

+                return new Lambda(

+                        samMethodMapping != null ? samMethodMapping.getTargetName() : invokedName,

+                        invokedType.translate(translator, resolver, mappings),

+                        samMethodType.translate(translator, resolver, mappings),

+                        implMethod.translate(translator, resolver, mappings),

+                        instantiatedMethodType.translate(translator, resolver, mappings)

+                );

+        }

+

+        private EntryMapping resolveMapping(EntryResolver resolver, EntryMap<EntryMapping> mappings, MethodEntry methodEntry) {

+                for (MethodEntry entry : resolver.resolveEntry(methodEntry, ResolutionStrategy.RESOLVE_ROOT)) {

+                        EntryMapping mapping = mappings.get(entry);

+                        if (mapping != null) {

+                                return mapping;

+                        }

+                }

+                return null;

+        }

+

+        public ClassEntry getInterface() {

+                return invokedType.getReturnDesc().getTypeEntry();

+        }

+

+        public String getInvokedName() {

+                return invokedName;

+        }

+

+        public MethodDescriptor getInvokedType() {

+                return invokedType;

+        }

+

+        public MethodDescriptor getSamMethodType() {

+                return samMethodType;

+        }

+

+        public ParentedEntry<?> getImplMethod() {

+                return implMethod;

+        }

+

+        public MethodDescriptor getInstantiatedMethodType() {

+                return instantiatedMethodType;

+        }

+

+        @Override

+        public boolean equals(Object o) {

+                if (this == o) return true;

+                if (o == null || getClass() != o.getClass()) return false;

+                Lambda lambda = (Lambda) o;

+                return Objects.equals(invokedName, lambda.invokedName) &&

+                        Objects.equals(invokedType, lambda.invokedType) &&

+                        Objects.equals(samMethodType, lambda.samMethodType) &&

+                        Objects.equals(implMethod, lambda.implMethod) &&

+                        Objects.equals(instantiatedMethodType, lambda.instantiatedMethodType);

+        }

+

+        @Override

+        public int hashCode() {

+                return Objects.hash(invokedName, invokedType, samMethodType, implMethod, instantiatedMethodType);

+        }

+

+        @Override

+        public String toString() {

+                return "Lambda{" +

+                        "invokedName='" + invokedName + '\'' +

+                        ", invokedType=" + invokedType +

+                        ", samMethodType=" + samMethodType +

+                        ", implMethod=" + implMethod +

+                        ", instantiatedMethodType=" + instantiatedMethodType +

+                        '}';

+        }

+}

diff --git a/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java b/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java
index c59751f..37a7014 100644
--- a/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java
+++ b/src/main/java/cuchaz/enigma/translation/representation/MethodDescriptor.java
@@ -118,7 +118,7 @@ public class MethodDescriptor implements Translatable {
         }
 
         @Override
-        public Translatable translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+        public MethodDescriptor translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
                 List<TypeDescriptor> translatedArguments = new ArrayList<>(argumentDescs.size());
                 for (TypeDescriptor argument : argumentDescs) {
                         translatedArguments.add(translator.translate(argument));
diff --git a/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java b/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java
index 834da8d..b753d3a 100644
--- a/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java
+++ b/src/main/java/cuchaz/enigma/translation/representation/entry/ParentedEntry.java
@@ -52,7 +52,7 @@ public abstract class ParentedEntry<P extends Entry<?>> implements Entry<P> {
         }
 
         @Override
-        public Translatable translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
+        public ParentedEntry<P> translate(Translator translator, EntryResolver resolver, EntryMap<EntryMapping> mappings) {
                 P parent = getParent();
                 EntryMapping mapping = resolveMapping(resolver, mappings);
                 if (parent == null) {