fix equalitty for several classes

bytecode-generation/src/main/java/me/tomassetti/jvm/JvmConstructorDefinition.java

@@ -6,4 +6,17 @@ public JvmConstructorDefinition(String ownerInternalName, String descriptor) {
         super(ownerInternalName, "<init>", descriptor);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof JvmConstructorDefinition)) return false;
+
+        JvmConstructorDefinition that = (JvmConstructorDefinition) o;
+
+        if (!ownerInternalName.equals(that.ownerInternalName)) return false;
+        if (!name.equals(that.name)) return false;
+        if (!descriptor.equals(that.descriptor)) return false;
+
+        return true;
+    }
 }

bytecode-generation/src/main/java/me/tomassetti/jvm/JvmMethodDefinition.java

@@ -18,4 +18,35 @@ public boolean isStatic() {
     public boolean isDeclaredOnInterface() {
         return declaredOnInterface;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof JvmMethodDefinition)) return false;
+
+        JvmMethodDefinition that = (JvmMethodDefinition) o;
+
+        if (_static != that._static) return false;
+        if (declaredOnInterface != that.declaredOnInterface) return false;
+        if (!ownerInternalName.equals(that.ownerInternalName)) return false;
+        if (!name.equals(that.name)) return false;
+        if (!descriptor.equals(that.descriptor)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (_static ? 1 : 0);
+        result = 31 * result + (declaredOnInterface ? 1 : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "JvmMethodDefinition{" +
+                "_static=" + _static +
+                ", declaredOnInterface=" + declaredOnInterface +
+                '}';
+    }
 }

turin-compiler/src/main/java/me/tomassetti/turin/definitions/InternalConstructorDefinition.java

@@ -57,4 +57,33 @@ public InternalConstructorDefinition apply(Map<String, TypeUsage> typeParams) {
         return new InternalConstructorDefinition(returnType.replaceTypeVariables(typeParams),
                 formalParametersReplaced, jvmConstructorDefinition);
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof InternalConstructorDefinition)) return false;
+
+        InternalConstructorDefinition that = (InternalConstructorDefinition) o;
+
+        if (!jvmConstructorDefinition.equals(that.jvmConstructorDefinition)) return false;
+        if (!returnType.equals(that.returnType)) return false;
+        if (!getFormalParameters().equals(that.getFormalParameters())) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = jvmConstructorDefinition.hashCode();
+        result = 31 * result + returnType.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "InternalConstructorDefinition{" +
+                "jvmConstructorDefinition=" + jvmConstructorDefinition +
+                ", returnType=" + returnType +
+                '}';
+    }
 }

turin-compiler/src/main/java/me/tomassetti/turin/definitions/InternalMethodDefinition.java

@@ -63,4 +63,36 @@ public boolean isConstructor() {
     public boolean isMethod() {
         return true;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof InternalMethodDefinition)) return false;
+
+        InternalMethodDefinition that = (InternalMethodDefinition) o;
+
+        if (!jvmMethodDefinition.equals(that.jvmMethodDefinition)) return false;
+        if (!methodName.equals(that.methodName)) return false;
+        if (!returnType.equals(that.returnType)) return false;
+        if (!getFormalParameters().equals(that.getFormalParameters())) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = methodName.hashCode();
+        result = 31 * result + jvmMethodDefinition.hashCode();
+        result = 31 * result + returnType.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "InternalMethodDefinition{" +
+                "methodName='" + methodName + '\'' +
+                ", jvmMethodDefinition=" + jvmMethodDefinition +
+                ", returnType=" + returnType +
+                '}';
+    }
 }

turin-compiler/src/main/java/me/tomassetti/turin/parser/ast/expressions/InstanceMethodInvokation.java

@@ -11,6 +11,7 @@
 import me.tomassetti.turin.typesystem.TypeUsage;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 public class InstanceMethodInvokation extends Invokable {
@@ -61,9 +62,13 @@ public JvmMethodDefinition findJvmDefinition(SymbolResolver resolver) {
             ap.setParent(InstanceMethodInvokation.this);
             return ap;
         }).collect(Collectors.toList());
-        return subject.calcType().getMethod(methodName, false).get().
-                internalInvokableDefinitionFor(paramTypes).get().
-                asMethod().getJvmMethodDefinition();
+        TypeUsage subjectType = subject.calcType();
+        Optional<InvokableType> method = subjectType.getMethod(methodName, false);
+        Optional<? extends InternalInvokableDefinition> invokableDefinition = method.get().internalInvokableDefinitionFor(paramTypes);
+        if (!invokableDefinition.isPresent()) {
+            throw new IllegalStateException("Unable to retrieve the JVM definition: " + method.get().getClass().getCanonicalName());
+        }
+        return invokableDefinition.get().asMethod().getJvmMethodDefinition();
     }
 
     @Override

turin-compiler/src/main/java/me/tomassetti/turin/typesystem/InvokableReferenceTypeUsage.java

@@ -1,8 +1,11 @@
 package me.tomassetti.turin.typesystem;
 
 import me.tomassetti.jvm.JvmType;
+import me.tomassetti.turin.definitions.InternalConstructorDefinition;
 import me.tomassetti.turin.definitions.InternalInvokableDefinition;
+import me.tomassetti.turin.definitions.InternalMethodDefinition;
 import me.tomassetti.turin.parser.ast.expressions.ActualParam;
+import me.tomassetti.turin.symbols.FormalParameterSymbol;
 import me.tomassetti.turin.symbols.Symbol;
 
 import java.util.List;
@@ -21,8 +24,32 @@ public class InvokableReferenceTypeUsage implements TypeUsage, InvokableType {
 
     @Override
     public <T extends TypeUsage> TypeUsage replaceTypeVariables(Map<String, T> typeParams) {
-        throw new UnsupportedOperationException();
-    }
+        if (typeParams.isEmpty()) {
+            return this;
+        }
+        List<FormalParameterSymbol> replacedParams = internalInvokableDefinition
+                .getFormalParameters()
+                .stream()
+                .map((fp) -> new FormalParameterSymbol(
+                        fp.getType().replaceTypeVariables(typeParams),
+                        fp.getName(),
+                        fp.hasDefaultValue()))
+                .collect(Collectors.toList());
+        if (internalInvokableDefinition.isMethod()) {
+            return new InvokableReferenceTypeUsage(new InternalMethodDefinition(
+                    internalInvokableDefinition.asMethod().getMethodName(),
+                    replacedParams,
+                    internalInvokableDefinition.getReturnType().replaceTypeVariables(typeParams),
+                    internalInvokableDefinition.asMethod().getJvmMethodDefinition()));
+        } else if (internalInvokableDefinition.isConstructor()) {
+            return new InvokableReferenceTypeUsage(new InternalConstructorDefinition(
+                    internalInvokableDefinition.getReturnType().replaceTypeVariables(typeParams),
+                    replacedParams,
+                    internalInvokableDefinition.asConstructor().getJvmConstructorDefinition()));
+        } else {
+            throw new UnsupportedOperationException();
+        }
+     }
 
     public InvokableReferenceTypeUsage(InternalInvokableDefinition internalInvokableDefinition) {
         this.internalInvokableDefinition = internalInvokableDefinition;
@@ -85,6 +112,9 @@ public Optional<InvokableType> getMethod(String method, boolean staticContext) {
         return Optional.empty();
     }
 
+    /**
+     * It cannot be assigned to anything because it is not possible to store a reference to it.
+     */
     @Override
     public boolean canBeAssignedTo(TypeUsage type) {
         return false;
@@ -102,15 +132,32 @@ public Optional<InternalInvokableDefinition> internalInvokableDefinitionFor(List
 
     @Override
     public String describe() {
-        if (internalInvokableDefinition.isMethod()) {
-            return internalInvokableDefinition.asMethod().getMethodName() + "(" +
-                    String.join(", " , internalInvokableDefinition.getFormalParameters().stream().map((fp)->fp.getType().describe()).collect(Collectors.toList())) + ") -> " +
-                    internalInvokableDefinition.getReturnType().describe();
-        } else if (internalInvokableDefinition.isConstructor()) {
-            return internalInvokableDefinition.asConstructor().getReturnType().describe() + "(" +
-                    String.join(", " , internalInvokableDefinition.getFormalParameters().stream().map((fp)->fp.getType().describe()).collect(Collectors.toList()));
-        } else {
-            throw new UnsupportedOperationException();
-        }
+        return  "(" +
+                String.join(", " , internalInvokableDefinition.getFormalParameters().stream().map((fp)->fp.getType().describe()).collect(Collectors.toList())) + ") -> " +
+                internalInvokableDefinition.getReturnType().describe();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof InvokableReferenceTypeUsage)) return false;
+
+        InvokableReferenceTypeUsage that = (InvokableReferenceTypeUsage) o;
+
+        if (!internalInvokableDefinition.equals(that.internalInvokableDefinition)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return internalInvokableDefinition.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return "InvokableReferenceTypeUsage{" +
+                "internalInvokableDefinition=" + internalInvokableDefinition +
+                '}';
     }
 }

turin-compiler/src/test/java/me/tomassetti/turin/typesystem/InvokableReferenceTypeUsageTest.java

@@ -1,6 +1,7 @@
 package me.tomassetti.turin.typesystem;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import me.tomassetti.jvm.JvmConstructorDefinition;
 import me.tomassetti.jvm.JvmMethodDefinition;
 import me.tomassetti.turin.definitions.InternalConstructorDefinition;
@@ -16,6 +17,8 @@
 import org.junit.Test;
 
 import java.util.Collections;
+import java.util.Map;
+
 import static org.junit.Assert.*;
 
 public class InvokableReferenceTypeUsageTest {
@@ -59,7 +62,7 @@ public void setup() {
         InternalInvokableDefinition internalD = new InternalConstructorDefinition(
                 string,
                 ImmutableList.of(),
-                new JvmConstructorDefinition("a/b/MyClass", "()V"));
+                new JvmConstructorDefinition("a/b/MyClass", "()Ljava/lang/string;"));
         invokableD = new InvokableReferenceTypeUsage(internalD);
         InternalInvokableDefinition internalSameAsA = new InternalConstructorDefinition(
                 string,
@@ -318,44 +321,65 @@ public void testSameType() {
         assertEquals(true, invokableD.sameType(invokableSameAsD));
     }
 
-    /*@Test
+    @Test
     public void testCanBeAssignedTo() {
-        assertEquals(true, arrayOfBoolean.canBeAssignedTo(arrayOfBoolean));
-        assertEquals(false, arrayOfBoolean.canBeAssignedTo(arrayOfString));
-        assertEquals(false, arrayOfBoolean.canBeAssignedTo(arrayOfArrayOfString));
-        assertEquals(false, arrayOfBoolean.canBeAssignedTo(PrimitiveTypeUsage.BOOLEAN));
-        assertEquals(false, arrayOfBoolean.canBeAssignedTo(string));
-        assertEquals(true, arrayOfBoolean.canBeAssignedTo(object));
-        assertEquals(false, arrayOfString.canBeAssignedTo(arrayOfBoolean));
-        assertEquals(true, arrayOfString.canBeAssignedTo(arrayOfString));
-        assertEquals(false, arrayOfString.canBeAssignedTo(arrayOfArrayOfString));
-        assertEquals(false, arrayOfString.canBeAssignedTo(PrimitiveTypeUsage.BOOLEAN));
-        assertEquals(false, arrayOfString.canBeAssignedTo(string));
-        assertEquals(true, arrayOfString.canBeAssignedTo(object));
-        assertEquals(false, arrayOfArrayOfString.canBeAssignedTo(arrayOfBoolean));
-        assertEquals(false, arrayOfArrayOfString.canBeAssignedTo(arrayOfString));
-        assertEquals(true, arrayOfArrayOfString.canBeAssignedTo(arrayOfArrayOfString));
-        assertEquals(false, arrayOfArrayOfString.canBeAssignedTo(PrimitiveTypeUsage.BOOLEAN));
-        assertEquals(false, arrayOfArrayOfString.canBeAssignedTo(string));
-        assertEquals(true, arrayOfArrayOfString.canBeAssignedTo(object));
+        assertFalse(invokableA.canBeAssignedTo(invokableA));
+        assertFalse(invokableA.canBeAssignedTo(invokableB));
+        assertFalse(invokableA.canBeAssignedTo(invokableC));
+        assertFalse(invokableA.canBeAssignedTo(invokableD));
+        assertFalse(invokableA.canBeAssignedTo(object));
+        assertFalse(invokableA.canBeAssignedTo(string));
+
+        assertFalse(invokableB.canBeAssignedTo(invokableA));
+        assertFalse(invokableB.canBeAssignedTo(invokableB));
+        assertFalse(invokableB.canBeAssignedTo(invokableC));
+        assertFalse(invokableB.canBeAssignedTo(invokableD));
+        assertFalse(invokableB.canBeAssignedTo(object));
+        assertFalse(invokableB.canBeAssignedTo(string));
+
+        assertFalse(invokableC.canBeAssignedTo(invokableA));
+        assertFalse(invokableC.canBeAssignedTo(invokableB));
+        assertFalse(invokableC.canBeAssignedTo(invokableC));
+        assertFalse(invokableC.canBeAssignedTo(invokableD));
+        assertFalse(invokableC.canBeAssignedTo(object));
+        assertFalse(invokableC.canBeAssignedTo(string));
+
+        assertFalse(invokableD.canBeAssignedTo(invokableA));
+        assertFalse(invokableD.canBeAssignedTo(invokableB));
+        assertFalse(invokableD.canBeAssignedTo(invokableC));
+        assertFalse(invokableD.canBeAssignedTo(invokableD));
+        assertFalse(invokableD.canBeAssignedTo(object));
+        assertFalse(invokableD.canBeAssignedTo(string));
     }
 
     @Test
     public void testReplaceTypeVariables() {
-        assertEquals(arrayOfBoolean, arrayOfBoolean.replaceTypeVariables(Collections.emptyMap()));
-        assertEquals(arrayOfString, arrayOfString.replaceTypeVariables(Collections.emptyMap()));
-        assertEquals(arrayOfArrayOfString, arrayOfArrayOfString.replaceTypeVariables(Collections.emptyMap()));
-        assertEquals(arrayOfBoolean, arrayOfBoolean.replaceTypeVariables(ImmutableMap.of("A", string, "B", object)));
-        assertEquals(arrayOfString, arrayOfString.replaceTypeVariables(ImmutableMap.of("A", string, "B", object)));
-        assertEquals(arrayOfArrayOfString, arrayOfArrayOfString.replaceTypeVariables(ImmutableMap.of("A", string, "B", object)));
+        Map<String, TypeUsage> typeParams = ImmutableMap.of("A", string, "B", object);
+        assertEquals(invokableA, invokableA.replaceTypeVariables(Collections.emptyMap()));
+        assertEquals(invokableA, invokableA.replaceTypeVariables(typeParams));
+        assertEquals(invokableB, invokableB.replaceTypeVariables(Collections.emptyMap()));
+        assertEquals(invokableB, invokableB.replaceTypeVariables(typeParams));
+        assertEquals(invokableC, invokableC.replaceTypeVariables(Collections.emptyMap()));
+        assertNotEquals(invokableC, invokableC.replaceTypeVariables(typeParams));
+        TypeUsage invokableCReplaced = invokableC.replaceTypeVariables(typeParams);
+        InternalInvokableDefinition internalCReplaced = new InternalMethodDefinition(
+                "bar",
+                ImmutableList.of(),
+                string,
+                // where A is a Type Variable
+                new JvmMethodDefinition("a/b/MyClass", "internalC", "()A", false, true));
+        assertEquals(new InvokableReferenceTypeUsage(internalCReplaced), invokableCReplaced);
+        assertEquals(invokableD, invokableD.replaceTypeVariables(Collections.emptyMap()));
+        assertEquals(invokableD, invokableD.replaceTypeVariables(typeParams));
     }
 
     @Test
     public void testDescribe() {
-        assertEquals("array of boolean", arrayOfBoolean.describe());
-        assertEquals("array of java.lang.String", arrayOfString.describe());
-        assertEquals("array of array of java.lang.String", arrayOfArrayOfString.describe());
-    }*/
+        assertEquals("(int, java.lang.Object) -> java.lang.String", invokableA.describe());
+        assertEquals("(boolean) -> void", invokableB.describe());
+        assertEquals("() -> type variable A", invokableC.describe());
+        assertEquals("() -> java.lang.String", invokableD.describe());
+    }
 
     //Optional<? extends InternalInvokableDefinition> internalInvokableDefinitionFor(List<ActualParam> actualParams);