GenericRefType umgestalten. Unnötige Backreferenzen entfernen

src/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -10,12 +10,10 @@ import org.objectweb.asm.signature.SignatureWriter;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
@@ -165,7 +163,7 @@ public class Signature {
 	 * @param genAndBounds 
 	 */
 	private void getBoundsOfTypeVar(GenericTypeVar g, HashMap<String, String> genAndBounds) {
-		sw.visitFormalTypeParameter(g.getParsedName());
+		sw.visitFormalTypeParameter(g.getName());
 		
 		Iterator<? extends RefTypeOrTPHOrWildcardOrGeneric> bItr = g.getBounds().iterator(); 
 		while(bItr.hasNext()) {
@@ -174,7 +172,7 @@ public class Signature {
 //			System.out.println("GetBounds: " + boundDesc);
 			// Ensure that <...> extends java.lang.Object OR ...
 			sw.visitClassBound().visitClassType(boundDesc);
-			genAndBounds.put(g.getParsedName(), boundDesc);
+			genAndBounds.put(g.getName(), boundDesc);
 		}
 		sw.visitClassBound().visitEnd();
 	}

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
@@ -51,11 +50,11 @@ public class FCGenerator {
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
         //Generics mit gleichem Namen müssen den selben TPH bekommen
         for(GenericTypeVar gtv : forType.getGenerics()){
-            if(!gtvs.containsKey(gtv.getParsedName())){
+            if(!gtvs.containsKey(gtv.getName())){
-                gtvs.put(gtv.getParsedName(), TypePlaceholder.fresh(new NullToken()));
+                gtvs.put(gtv.getName(), TypePlaceholder.fresh(new NullToken()));
-                newGTVs.put(gtv.getParsedName(), TypePlaceholder.fresh(new NullToken()));
+                newGTVs.put(gtv.getName(), TypePlaceholder.fresh(new NullToken()));
             }
-            params.add(gtvs.get(gtv.getParsedName()));
+            params.add(gtvs.get(gtv.getName()));
         }
 
         Optional<ClassOrInterface> hasSuperclass = availableClasses.stream().filter(cl -> forType.getSuperClass().getName().equals(cl.getClassName())).findAny();
@@ -79,7 +78,7 @@ public class FCGenerator {
             RefTypeOrTPHOrWildcardOrGeneric setType = itSetParams.next();
             //In diesem Typ die GTVs durch TPHs und Einsetzungen austauschen:
             RefTypeOrTPHOrWildcardOrGeneric setSetType = setType.acceptTV(new TypeExchanger(gtvs));
-            newGTVs.put(itGenParams.next().getParsedName(), setSetType);
+            newGTVs.put(itGenParams.next().getName(), setSetType);
         }
 
         RefTypeOrTPHOrWildcardOrGeneric superType = forType.getSuperClass().acceptTV(new TypeExchanger(newGTVs));

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/GenericContext.java

@@ -3,8 +3,8 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 
 public class GenericContext {
-    public final String parentMethod;
+    private final String parentMethod;
-    public final JavaClassName parentClass;
+    private final JavaClassName parentClass;
 
     public GenericContext(JavaClassName parentClass, String parentMethod) {
         if(parentMethod == null)parentMethod = "";

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java

@@ -3,7 +3,6 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.antlr.Java8Parser;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
@@ -75,7 +74,7 @@ public class TypeGenerator {
         //Problem <A extends B, B> ist erlaubt, würde aber bei den Bounds von A den Generic B nicht als solchen erkennen
         List<RefTypeOrTPHOrWildcardOrGeneric> bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics);
 
-        GenericTypeVar ret = new GenericTypeVar(new GenericTypeName(new GenericContext(parentClass, parentMethod), name), bounds, typeParameter.getStart(), typeParameter.getStop());
+        GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop());
         generics.put(name, new GenericContext(parentClass, parentMethod));
         return ret;
     }
@@ -133,7 +132,7 @@ public class TypeGenerator {
             String name, Java8Parser.TypeArgumentsContext typeArguments, Token offset, JavaClassRegistry reg, GenericsRegistry generics){
         if(!reg.contains(name)){ //Dann könnte es ein Generische Type sein
             if(generics.contains(name)){
-                return new GenericRefType(new GenericTypeName(generics.get(name),name), offset);
+                return new GenericRefType(name, offset);
             }else{
                 throw new TypeinferenceException("Der Typ "+ name + " ist nicht vorhanden",offset);
             }

src/de/dhbwstuttgart/parser/scope/GenericTypeName.java

@@ -1,26 +0,0 @@
-package de.dhbwstuttgart.parser.scope;
-
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-
-public class GenericTypeName extends JavaClassName {
-    private final static String DELIMITER = "%";
-
-    private final JavaClassName parentClass;
-    private final String methodName;
-
-    public GenericTypeName(GenericContext genericContext, String name) {
-        super(name);
-        this.parentClass = genericContext.parentClass;
-        this.methodName = genericContext.parentMethod;
-    }
-
-    public String getUniqueIdentifier() {
-        return parentClass.toString()
-                + DELIMITER + methodName
-                + DELIMITER + super.toString();
-    }
-
-    public JavaClassName getParentClass() {
-        return parentClass;
-    }
-}

src/de/dhbwstuttgart/sat/asp/writer/ASPGenerator.java

@@ -2,12 +2,10 @@ package de.dhbwstuttgart.sat.asp.writer;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.sat.asp.ASPStringConverter;
 import de.dhbwstuttgart.sat.asp.writer.model.*;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
@@ -100,7 +98,7 @@ public class ASPGenerator {
 
         @Override
         public ASPType visit(GenericRefType genericRefType) {
-            return new ASPRefType(ASPStringConverter.toConstant(genericRefType.getName()),
+            return new ASPRefType(ASPStringConverter.toConstant(genericRefType.getParsedName()),
                     new ASPParameterList(new ArrayList<>(), writer));
         }
     }

src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java

@@ -1,7 +1,5 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
 import org.antlr.v4.runtime.Token;
@@ -26,9 +24,9 @@ public class GenericTypeVar extends SyntaxTreeNode
      */
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds=new ArrayList<RefTypeOrTPHOrWildcardOrGeneric>();
 	private Token endOffset;
-    private GenericTypeName name;
+    private String name;
 
-    public GenericTypeVar(GenericTypeName s, List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds, Token offset, Token endOffset)
+    public GenericTypeVar(String s, List<? extends RefTypeOrTPHOrWildcardOrGeneric> bounds, Token offset, Token endOffset)
     {
         super(offset);
         name = s;
@@ -50,18 +48,15 @@ public class GenericTypeVar extends SyntaxTreeNode
         return "BoGTV " + this.name;
     }
 
-    public GenericTypeName getName() {
+    public String getName(){
-        return name;
-    }
-
-    public String getParsedName(){
         return name.toString();
     }
 
+    /*
     public JavaClassName definingClass(){
         return name.getParentClass();
     }
-
+*/
     @Override
     public void accept(ASTVisitor visitor) {
         visitor.visit(this);

src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java

@@ -8,7 +8,6 @@ import java.util.List;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.Field;
@@ -44,13 +43,16 @@ public class ASTFactory {
 		int modifier = jreClass.getModifiers();
 		boolean isInterface = jreClass.isInterface();
 		//see: https://stackoverflow.com/questions/9934774/getting-generic-parameter-from-supertype-class
-		//ParameterizedType parameterSuperClass = (ParameterizedType) jreClass.getGenericSuperclass();
+		ParameterizedType parameterSuperClass = null;
+		Type tempSuperClass = jreClass.getGenericSuperclass();
+		if(tempSuperClass != null && tempSuperClass instanceof ParameterizedType)
+			parameterSuperClass = (ParameterizedType) tempSuperClass;
 		java.lang.Class superjreClass = jreClass.getSuperclass();
 		RefType superClass;
 		if(superjreClass != null){
 			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
 			for(TypeVariable tv : superjreClass.getTypeParameters()){
-				params.add(new GenericRefType(new GenericTypeName(new GenericContext( name, null),tv.getName()), new NullToken()));
+				params.add(new GenericRefType(tv.getName(), new NullToken()));
 			}
 			superClass = new RefType(new JavaClassName(superjreClass.getName()), params, new NullToken());
 		}else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!)
@@ -67,6 +69,22 @@ public class ASTFactory {
 		return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset);
 	}
 
+	private static RefTypeOrTPHOrWildcardOrGeneric convertType(Type type){
+		JavaClassName name = null;
+		List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
+		if(type instanceof ParameterizedType){
+			for(Type paramType : ((ParameterizedType)type).getActualTypeArguments()){
+				params.add(convertType(paramType));
+			}
+		}else if(type instanceof TypeVariable){
+
+		}else if(type instanceof Class){
+			Class paramClass = (Class) type;
+			//params.add(new RefType(paramClass.getName())
+		}else throw new NotImplementedException();
+		return new RefType(name, params, new NullToken());
+	}
+
 	private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) {
 		return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken());
 	}
@@ -155,9 +173,7 @@ public class ASTFactory {
 		}else{
 			if(type instanceof TypeVariable){
 				//GTVDeclarationContext via "(TypeVariable) type).getGenericDeclaration()"
-				return new GenericRefType(
+				return new GenericRefType(type.getTypeName(), new NullToken());
-						new GenericTypeName(new GenericContext(parentClass, parentMethod),type.getTypeName()),
-						new NullToken());
 			}
 			List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
 			if(type instanceof ParameterizedType){
@@ -179,9 +195,7 @@ public class ASTFactory {
 				genericBounds.add((RefType) createType(bound, parentClass, parentMethod));
 			}
 		}
-		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(
+		return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken());
-				new GenericTypeName(new GenericContext(parentClass, parentMethod), jreTVName)
-				, genericBounds, new NullToken(), new NullToken());
 	}
 
 	public static ClassOrInterface createObjectClass() {

src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java

@@ -1,25 +1,19 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 import org.antlr.v4.runtime.Token;
 
 public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
 {
-    private GenericTypeName name;
+    private String name;
 
-    public GenericRefType(GenericTypeName name, Token offset)
+    public GenericRefType(String name, Token offset)
     {
         super(offset);
         this.name = name;
     }
 
-    public GenericTypeName getName(){
-        return name;
-    }
-
     public String getParsedName(){
         return name.toString();
     }

src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.visual;
 
-import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -171,7 +170,7 @@ public class OutputGenerator implements ASTVisitor{
 
     @Override
     public void visit(GenericRefType genericRefType) {
-        out.append(genericRefType.getName().toString());
+        out.append(genericRefType.getParsedName().toString());
     }
 
     @Override

src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java

@@ -126,7 +126,7 @@ class TypeToInsertString implements ResultSetVisitor{
 
     @Override
     public void visit(GenericRefType genericRefType) {
-        insert += genericRefType.getName();
+        insert += genericRefType.getParsedName();
     }
 
     @Override

src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java

@@ -1,8 +1,6 @@
 package de.dhbwstuttgart.typeinference.assumptions;
 
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.SyntaxTreeGenerator.GenericContext;
-import de.dhbwstuttgart.parser.scope.GenericTypeName;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
@@ -29,8 +27,7 @@ public class FunNClass extends ClassOrInterface {
     private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
         List<GenericTypeVar> generics = new ArrayList<>();
         for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
-            generics.add(new GenericTypeVar(new GenericTypeName(new GenericContext(
+            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
-                    new JavaClassName("Fun"+(funNParams.size()-1)), null), NameGenerator.makeNewName()),
                     new ArrayList<>(), new NullToken(), new NullToken()));
         }
         return new GenericDeclarationList(generics, new NullToken());

src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java

@@ -3,9 +3,7 @@ package de.dhbwstuttgart.typeinference.assumptions;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
-import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.TypeScope;
-import de.dhbwstuttgart.syntaxtree.statement.Assign;
 import de.dhbwstuttgart.syntaxtree.type.FunN;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -14,7 +12,6 @@ import de.dhbwstuttgart.typeinference.constraints.GenericsResolver;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 
 public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;

src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java

@@ -4,7 +4,6 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
-import de.dhbwstuttgart.parser.antlr.Java8Parser;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -339,7 +338,7 @@ public class TYPEStmt implements StatementVisitor{
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         for(GenericTypeVar gtv : receiverCl.getGenerics()){
             //Die Generics werden alle zu TPHs umgewandelt.
-            params.add(resolver.resolve(gtv.getParsedName()));
+            params.add(resolver.resolve(gtv.getName()));
         }
 
         RefTypeOrTPHOrWildcardOrGeneric receiverType = new RefType(assumption.getReceiver().getClassName(), params, forMethod.getOffset());

test/asp/UnifyWithoutWildcards.java

@@ -94,5 +94,5 @@ public class UnifyWithoutWildcards {
         //ret.add(ASTFactory.createClass(java.util.List.class));
         return ret;
     }
-    private class Matrix extends Vector<Vector<Integer>>{}
+    private class Matrix<A> extends HashMap<A,Map<Integer, A>>{}
 }