From 463aee1dfc1222e8f6f0312aa46fb9b9dcfa13a1 Mon Sep 17 00:00:00 2001
From: Erlend Åmdal
Date: Sat, 18 May 2019 11:13:24 +0200
Subject: Method type reference corrections (#142)

* Add more specific returns for translatables

* Only index method descriptors for implemented methods and methods in generated lambda classes
---
 .../enigma/translation/representation/Lambda.java  | 105 +++++++++++++++++++++
 .../representation/MethodDescriptor.java           |   2 +-
 .../representation/entry/ParentedEntry.java        |   2 +-
 3 files changed, 107 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/cuchaz/enigma/translation/representation/Lambda.java

(limited to 'src/main/java/cuchaz/enigma/translation/representation')

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) {
-- 
cgit v1.2.3