Improve the generation of generic local variables

emmanue1 · emmanue1 · commit ca1dec9fc577 · 2019-08-15T22:56:46.000+02:00
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/ArrayTypeArguments.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/ArrayTypeArguments.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2019 Emmanuel Dupuy.
+ * Copyright (c) 2008, 2019 Emmanuel Dupuy.
  * This project is distributed under the GPLv3 license.
  * This is a Copyleft license that gives the user the right to use,
  * copy and modify the code freely for non-commercial purposes.
@@ -9,6 +9,7 @@
 
 import org.jd.core.v1.util.DefaultList;
 
+import java.util.Iterator;
 import java.util.List;
 
 public class ArrayTypeArguments extends DefaultList<TypeArgument> implements BaseTypeArgument {
@@ -22,4 +23,28 @@ public ArrayTypeArguments(List<TypeArgument> list) {
     public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
+
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        if (typeArgument.getClass() != ArrayTypeArguments.class) {
+            return false;
+        }
+
+        ArrayTypeArguments ata = (ArrayTypeArguments)typeArgument;
+
+        if (size() != ata.size()) {
+            return false;
+        }
+
+        Iterator<TypeArgument> iterator1 = iterator();
+        Iterator<TypeArgument> iterator2 = ata.iterator();
+
+        while (iterator1.hasNext()) {
+            if (!iterator1.next().isTypeArgumentAssignableFrom(iterator2.next())) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/BaseTypeArgument.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/BaseTypeArgument.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2019 Emmanuel Dupuy.
+ * Copyright (c) 2008, 2019 Emmanuel Dupuy.
  * This project is distributed under the GPLv3 license.
  * This is a Copyleft license that gives the user the right to use,
  * copy and modify the code freely for non-commercial purposes.
@@ -8,4 +8,5 @@
 package org.jd.core.v1.model.javasyntax.type;
 
 public interface BaseTypeArgument extends TypeVisitable {
+    boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument);
 }
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/DiamondTypeArgument.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/DiamondTypeArgument.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2019 Emmanuel Dupuy.
+ * Copyright (c) 2008, 2019 Emmanuel Dupuy.
  * This project is distributed under the GPLv3 license.
  * This is a Copyleft license that gives the user the right to use,
  * copy and modify the code freely for non-commercial purposes.
@@ -16,4 +16,9 @@ protected DiamondTypeArgument() {}
     public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
+
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        return true;
+    }
 }
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/GenericType.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/GenericType.java
@@ -65,13 +65,26 @@ public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
 
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        return equals(typeArgument);
+    }
+
     @Override
     public boolean isGeneric() {
         return true;
     }
 
     @Override
     public String toString() {
-        return "GenericType{" + name + "}";
+        StringBuilder sb = new StringBuilder("GenericType{");
+
+        sb.append(name);
+
+        if (dimension > 0) {
+            sb.append(", dimension=").append(dimension);
+        }
+
+        return sb.append('}').toString();
     }
 }
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/ObjectType.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/ObjectType.java
@@ -191,6 +191,27 @@ public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
 
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        if (typeArgument.getClass() != ObjectType.class) {
+            return false;
+        }
+
+        ObjectType ot = (ObjectType)typeArgument;
+
+        if ((dimension != ot.getDimension()) || !internalName.equals(ot.getInternalName())) {
+            return false;
+        }
+
+        if (ot.getTypeArguments() == null) {
+            return (typeArgument == null);
+        } else if (typeArgument == null) {
+            return false;
+        } else {
+            return typeArguments.isTypeArgumentAssignableFrom(ot.getTypeArguments());
+        }
+    }
+
     @Override
     public boolean isObject() {
         return true;
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/PrimitiveType.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/PrimitiveType.java
@@ -153,6 +153,11 @@ public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
 
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        return equals(typeArgument);
+    }
+
     @Override
     public boolean isPrimitive() {
         return true;
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/WildcardExtendsTypeArgument.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/WildcardExtendsTypeArgument.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2019 Emmanuel Dupuy.
+ * Copyright (c) 2008, 2019 Emmanuel Dupuy.
  * This project is distributed under the GPLv3 license.
  * This is a Copyleft license that gives the user the right to use,
  * copy and modify the code freely for non-commercial purposes.
@@ -23,6 +23,17 @@ public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
 
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        if (typeArgument.getClass() == WildcardExtendsTypeArgument.class) {
+            return type.isTypeArgumentAssignableFrom(((WildcardExtendsTypeArgument)typeArgument).getType());
+        } else if (typeArgument instanceof Type) {
+            return type.isTypeArgumentAssignableFrom(typeArgument);
+        }
+
+        return false;
+    }
+
     @Override
     public String toString() {
         return "WildcardExtendsTypeArgument{? extends " + type + "}";
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/WildcardSuperTypeArgument.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/WildcardSuperTypeArgument.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2019 Emmanuel Dupuy.
+ * Copyright (c) 2008, 2019 Emmanuel Dupuy.
  * This project is distributed under the GPLv3 license.
  * This is a Copyleft license that gives the user the right to use,
  * copy and modify the code freely for non-commercial purposes.
@@ -23,6 +23,17 @@ public void accept(TypeVisitor visitor) {
         visitor.visit(this);
     }
 
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        if (typeArgument.getClass() == WildcardSuperTypeArgument.class) {
+            return type.isTypeArgumentAssignableFrom(((WildcardSuperTypeArgument)typeArgument).getType());
+        } else if (typeArgument instanceof Type) {
+            return type.isTypeArgumentAssignableFrom(typeArgument);
+        }
+
+        return false;
+    }
+
     @Override
     public String toString() {
         return "WildcardSuperTypeArgument{? super " + type + "}";
diff --git a/src/main/java/org/jd/core/v1/model/javasyntax/type/WildcardTypeArgument.java b/src/main/java/org/jd/core/v1/model/javasyntax/type/WildcardTypeArgument.java
@@ -18,4 +18,9 @@ public void accept(TypeVisitor visitor) {
     public String toString() {
         return "Wildcard{?}";
     }
+
+    @Override
+    public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {
+        return true;
+    }
 }
diff --git a/src/main/java/org/jd/core/v1/service/converter/classfiletojavasyntax/model/localvariable/GenericLocalVariable.java b/src/main/java/org/jd/core/v1/service/converter/classfiletojavasyntax/model/localvariable/GenericLocalVariable.java
@@ -40,7 +40,22 @@ public void accept(LocalVariableVisitor visitor) {
 
     @Override
     public String toString() {
-        return "GenericLocalVariable{" + type + ", index=" + index + "}";
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("GenericLocalVariable{");
+        sb.append(type.getName());
+
+        if (type.getDimension() > 0) {
+            sb.append(new String(new char[type.getDimension()]).replaceAll("\0", "[]"));
+        }
+
+        sb.append(' ').append(name).append(", index=").append(index);
+
+        if (next != null) {
+            sb.append(", next=").append(next);
+        }
+
+        return sb.append("}").toString();
     }
 
     @Override public boolean isAssignableFrom(Type otherType) {
diff --git a/src/main/java/org/jd/core/v1/service/converter/classfiletojavasyntax/model/localvariable/ObjectLocalVariable.java b/src/main/java/org/jd/core/v1/service/converter/classfiletojavasyntax/model/localvariable/ObjectLocalVariable.java
@@ -82,8 +82,24 @@ public boolean isAssignableFrom(Type type) {
         if (!type.isPrimitive()) {
             if ((type == TYPE_UNDEFINED_OBJECT) || (this.type == TYPE_UNDEFINED_OBJECT) || (this.type == TYPE_OBJECT) || this.type.equals(type)) {
                 return true;
-            } else if ((this.type.getDimension() == 0) && (type.getDimension() == 0) && this.type.isObject() && type.isObject()) {
-                return objectTypeMaker.isAssignable((ObjectType) this.type, (ObjectType) type);
+            } else if ((this.type.getDimension() == type.getDimension()) && this.type.isObject()) {
+                ObjectType ot1 = (ObjectType) this.type;
+
+                if (type.isObject()) {
+                    ObjectType ot2 = (ObjectType) type;
+
+                    if (ot1.getInternalName().equals(ot2.getInternalName()) && (ot1.getTypeArguments() != null) && (ot2.getTypeArguments() != null)) {
+                        return ot1.getTypeArguments().isTypeArgumentAssignableFrom(ot2.getTypeArguments());
+                    }
+
+                    if (type.getDimension() == 0) {
+                        if ((ot1.getTypeArguments() == null) ? (ot2.getTypeArguments() == null) : ot1.getTypeArguments().equals(ot2.getTypeArguments())) {
+                            return objectTypeMaker.isAssignable(ot1, ot2);
+                        }
+                    }
+                } else if (ot1.getInternalName().equals(TYPE_OBJECT.getInternalName())) {
+                    return true;
+                }
             }
         }
 
diff --git a/src/main/java/org/jd/core/v1/service/converter/classfiletojavasyntax/util/LocalVariableMaker.java b/src/main/java/org/jd/core/v1/service/converter/classfiletojavasyntax/util/LocalVariableMaker.java
@@ -335,6 +335,14 @@ protected AbstractLocalVariable searchLocalVariable(int index, int offset) {
         return lv;
     }
 
+    protected boolean isAssignableFrom(AbstractLocalVariable lv, Type valueType) {
+        if (lv.getType().isObject() && valueType.isObject() && (lv.getType().getDimension() == valueType.getDimension())) {
+            return objectTypeMaker.isAssignable((ObjectType)lv.getType(), (ObjectType)valueType);
+        }
+
+        return false;
+    }
+
     public AbstractLocalVariable getLocalVariableInAssignment(int index, int offset, Type valueType) {
         AbstractLocalVariable lv = searchLocalVariable(index, offset);
 
@@ -343,10 +351,10 @@ public AbstractLocalVariable getLocalVariableInAssignment(int index, int offset,
             createLocalVariableVisitor.init(index, offset);
             valueType.accept(createLocalVariableVisitor);
             lv = createLocalVariableVisitor.getLocalVariable();
-        } else if (lv.isAssignableFrom(valueType)) {
+        } else if (lv.isAssignableFrom(valueType) || isAssignableFrom(lv, valueType)) {
             // Reduce type
             lv.typeOnRight(valueType);
-        } else {
+        } else if (!lv.getType().isGeneric() || (ObjectType.TYPE_OBJECT != valueType)) {
             // Not assignable -> Create a new local variable
             createLocalVariableVisitor.init(index, offset);
             valueType.accept(createLocalVariableVisitor);
@@ -392,14 +400,16 @@ public AbstractLocalVariable getLocalVariableInAssignment(int index, int offset,
             createLocalVariableVisitor.init(index, offset);
             valueLocalVariable.accept(createLocalVariableVisitor);
             lv = createLocalVariableVisitor.getLocalVariable();
-        } else if (!lv.isAssignableFrom(valueLocalVariable)) {
+        } else if (lv.isAssignableFrom(valueLocalVariable) || isAssignableFrom(lv, valueLocalVariable.getType())) {
+            // Reduce type
+            lv.variableOnRight(valueLocalVariable);
+        } else if (!lv.getType().isGeneric() || (ObjectType.TYPE_OBJECT != valueLocalVariable.getType())) {
             // Not assignable -> Create a new local variable
             createLocalVariableVisitor.init(index, offset);
             valueLocalVariable.accept(createLocalVariableVisitor);
             lv = createLocalVariableVisitor.getLocalVariable();
         }
 
-        lv.variableOnRight(valueLocalVariable);
         lv.setToOffset(offset);
         store(lv);
 

Original file line number	Diff line number	Diff line change
`@@ -18,4 +18,9 @@ public void accept(TypeVisitor visitor) {`
`18`	`18`	`public String toString() {`
`19`	`19`	`return "Wildcard{?}";`
`20`	`20`	`}`
	`21`	`+`
	`22`	`+ @Override`
	`23`	`+ public boolean isTypeArgumentAssignableFrom(BaseTypeArgument typeArgument) {`
	`24`	`+ return true;`
	`25`	`+ }`
`21`	`26`	`}`