From bb5945898a0bd490000f8a96089ade4edf61569b Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Tue, 13 Mar 2018 01:57:21 +0100 Subject: [PATCH 01/15] Bug in ASTFactory beseitigen --- pom.xml | 6 ++++ .../syntaxtree/factory/ASTFactory.java | 36 ++++++++++++------- test/javFiles/Vector.jav | 6 +--- 3 files changed, 31 insertions(+), 17 deletions(-) diff --git a/pom.xml b/pom.xml index ea7be6b3..1b97e501 100644 --- a/pom.xml +++ b/pom.xml @@ -42,6 +42,12 @@ asm-all [4.0.0,) + diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index fa930f58..c438bc67 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -89,14 +89,21 @@ public class ASTFactory { return new Field(field.getName(), createType(field.getType(), jreClass, null), field.getModifiers(), new NullToken()); } + //private static RefType createType(Class classType) { + // return createClass(classType).getType(); + //} + private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) { String name = constructor.getName(); RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name); Parameter[] jreParams = constructor.getParameters(); + Type[] jreGenericParams = constructor.getGenericParameterTypes(); List params = new ArrayList<>(); - for(Parameter jreParam : jreParams){ - RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name); - params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken())); + int i = 0; + for(Type jreParam : jreGenericParams){ + RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name); + params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken())); + i++; } ParameterList parameterList = new ParameterList(params, new NullToken()); Block block = new Block(new ArrayList(), new NullToken()); @@ -109,21 +116,26 @@ public class ASTFactory { } return new de.dhbwstuttgart.syntaxtree.Constructor(modifier, name,returnType, parameterList, block, gtvDeclarations, offset, new ArrayList<>()); - } - - //private static RefType createType(Class classType) { - // return createClass(classType).getType(); - //} + } public static Method createMethod(java.lang.reflect.Method jreMethod, java.lang.Class inClass){ String name = jreMethod.getName(); RefTypeOrTPHOrWildcardOrGeneric returnType; - returnType = createType(jreMethod.getReturnType(),new JavaClassName(inClass.getName()), name); + Type jreRetType; + if(jreMethod.getGenericReturnType()!=null){ + jreRetType = jreMethod.getGenericReturnType(); + }else{ + jreRetType = jreMethod.getReturnType(); + } + returnType = createType(jreRetType,new JavaClassName(inClass.getName()), name); Parameter[] jreParams = jreMethod.getParameters(); + Type[] jreGenericParams = jreMethod.getGenericParameterTypes(); List params = new ArrayList<>(); - for(Parameter jreParam : jreParams){ - RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam.getType(),new JavaClassName(inClass.getName()), name); - params.add(new FormalParameter(jreParam.getName(),paramType, new NullToken())); + int i = 0; + for(Type jreParam : jreGenericParams){ + RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name); + params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken())); + i++; } ParameterList parameterList = new ParameterList(params, new NullToken()); Block block = new Block(new ArrayList(), new NullToken()); diff --git a/test/javFiles/Vector.jav b/test/javFiles/Vector.jav index ef3533a6..40072fe4 100644 --- a/test/javFiles/Vector.jav +++ b/test/javFiles/Vector.jav @@ -3,10 +3,6 @@ import java.util.Vector; class MyVector{ id(x){ - return id2(x); -} - -id2(x){ -return id(x); + return (x.elementAt(0)); } } \ No newline at end of file From 7a9c0a1e69df380e14075f54c6688e7e3390bafc Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 11:09:29 +0100 Subject: [PATCH 02/15] LambdaRunnableTest fix --- test/javFiles/LambdaRunnable.jav | 3 +++ test/visualisation/ToString.java | 5 +++++ 2 files changed, 8 insertions(+) create mode 100644 test/visualisation/ToString.java diff --git a/test/javFiles/LambdaRunnable.jav b/test/javFiles/LambdaRunnable.jav index 982680c3..37924ea2 100644 --- a/test/javFiles/LambdaRunnable.jav +++ b/test/javFiles/LambdaRunnable.jav @@ -1,3 +1,6 @@ +import java.lang.Runnable; +import java.lang.String; +import java.lang.System; public class LamRunnable{ diff --git a/test/visualisation/ToString.java b/test/visualisation/ToString.java new file mode 100644 index 00000000..00b8ddea --- /dev/null +++ b/test/visualisation/ToString.java @@ -0,0 +1,5 @@ +package visualisation; + +public class ToString { + +} From e1f579664a367978b10566465c3999afc87323c8 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 11:12:06 +0100 Subject: [PATCH 03/15] Fix Generics in MethodCall --- src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java index 8d87218d..0cadc085 100644 --- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java +++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java @@ -349,7 +349,7 @@ public class TYPEStmt implements StatementVisitor{ */ methodConstraint.add(new Pair(forMethod.receiver.getType(), assumption.getReceiverType(resolver), PairOperator.SMALLERDOT)); - methodConstraint.add(new Pair(assumption.getReturnType(), forMethod.getType(), + methodConstraint.add(new Pair(assumption.getReturnType(resolver), forMethod.getType(), PairOperator.EQUALSDOT)); methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info, resolver)); return methodConstraint; @@ -442,7 +442,7 @@ public class TYPEStmt implements StatementVisitor{ protected Constraint generateConstructorConstraint(NewClass forConstructor, MethodAssumption assumption, TypeInferenceBlockInformation info, GenericsResolver resolver){ Constraint methodConstraint = new Constraint(); - methodConstraint.add(new Pair(assumption.getReturnType(), forConstructor.getType(), + methodConstraint.add(new Pair(assumption.getReturnType(resolver), forConstructor.getType(), PairOperator.SMALLERDOT)); methodConstraint.addAll(generateParameterConstraints(forConstructor, assumption, info, resolver)); return methodConstraint; From 77be216ee51a78bd83bee581ec00247e0742dd9d Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 11:15:59 +0100 Subject: [PATCH 04/15] Fix --- .../typeinference/assumptions/FieldAssumption.java | 5 +++-- .../typeinference/assumptions/MethodAssumption.java | 3 ++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java index 62867a26..e039dcbe 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.typeinference.assumptions; +import de.dhbwstuttgart.exceptions.NotImplementedException; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.TypeScope; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; @@ -25,7 +26,7 @@ public class FieldAssumption extends Assumption{ } public RefTypeOrTPHOrWildcardOrGeneric getReceiverType(GenericsResolver resolver) { - - return null; + //TODO + throw new NotImplementedException(); } } diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java index 4656318c..e17281e5 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java @@ -37,7 +37,8 @@ public class MethodAssumption extends Assumption{ return receiver; } - public RefTypeOrTPHOrWildcardOrGeneric getReturnType() { + public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) { + if(retType instanceof GenericRefType)return resolver.resolve(retType); return retType; } From a71e56ea9793f9ffb05d99b9b8a7c159e6053a2d Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 11:15:59 +0100 Subject: [PATCH 05/15] Fix --- .../typeinference/assumptions/FieldAssumption.java | 5 +++-- .../typeinference/assumptions/MethodAssumption.java | 3 ++- src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java | 2 +- test/typeinference/JavaTXCompilerTest.java | 4 ++++ 4 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java index 62867a26..e039dcbe 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/FieldAssumption.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.typeinference.assumptions; +import de.dhbwstuttgart.exceptions.NotImplementedException; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.TypeScope; import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric; @@ -25,7 +26,7 @@ public class FieldAssumption extends Assumption{ } public RefTypeOrTPHOrWildcardOrGeneric getReceiverType(GenericsResolver resolver) { - - return null; + //TODO + throw new NotImplementedException(); } } diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java index 4656318c..e17281e5 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java @@ -37,7 +37,8 @@ public class MethodAssumption extends Assumption{ return receiver; } - public RefTypeOrTPHOrWildcardOrGeneric getReturnType() { + public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) { + if(retType instanceof GenericRefType)return resolver.resolve(retType); return retType; } diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java index 0cadc085..19f212bf 100644 --- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java +++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java @@ -393,7 +393,7 @@ public class TYPEStmt implements StatementVisitor{ for(Method m : cl.getMethods()){ if(m.getName().equals(name) && m.getParameterList().getFormalparalist().size() == numArgs){ - RefTypeOrTPHOrWildcardOrGeneric retType = info.checkGTV(m.getReturnType()); + RefTypeOrTPHOrWildcardOrGeneric retType = m.getReturnType();//info.checkGTV(m.getReturnType()); ret.add(new MethodAssumption(cl, retType, convertParams(m.getParameterList(),info), createTypeScope(cl, m))); diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index 87551476..3ba22bc6 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -49,6 +49,10 @@ public class JavaTXCompilerTest { execute(new File(rootDirectory+"Generics.jav")); } @Test + public void genericsMethodCall() throws IOException, ClassNotFoundException { + execute(new File(rootDirectory+"MethodCallGenerics.jav")); + } + @Test public void faculty() throws IOException, ClassNotFoundException { execute(new File(rootDirectory+"Faculty.jav")); } From 79810be94fd2f111f91e5971632dd080ffacc01b Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Wed, 21 Mar 2018 14:21:50 +0100 Subject: [PATCH 06/15] =?UTF-8?q?FC=20Generator=20ber=C3=BCcksichtig=20int?= =?UTF-8?q?erfaces?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../SyntaxTreeGenerator/FCGenerator.java | 85 ++++++++++--------- .../SyntaxTreeGenerator.java | 14 +-- .../syntaxtree/ClassOrInterface.java | 9 +- 3 files changed, 60 insertions(+), 48 deletions(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java index 24abec67..ceb3b817 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java @@ -57,48 +57,55 @@ public class FCGenerator { params.add(gtvs.get(gtv.getName())); } - Optional hasSuperclass = availableClasses.stream().filter(cl -> forType.getSuperClass().getName().equals(cl.getClassName())).findAny(); - ClassOrInterface superClass; - if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception - { - superClass = ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(forType.getSuperClass().getName().toString())); - }else{ - superClass = hasSuperclass.get(); - } - /* - Die Parameter der superklasse müssen jetzt nach den Angaben in der Subklasse - modifiziert werden - Beispie: Matrix extends Vector> - Den ersten Parameter mit Vector austauschen und dort alle Generics zu den Typplaceholdern in gtvs austauschen - */ - //Hier vermerken, welche Typen im der Superklasse ausgetauscht werden müssen - Iterator itGenParams = superClass.getGenerics().iterator(); - Iterator itSetParams = forType.getSuperClass().getParaList().iterator(); - while(itGenParams.hasNext()){ - 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().getName(), setSetType); - } - RefTypeOrTPHOrWildcardOrGeneric superType = forType.getSuperClass().acceptTV(new TypeExchanger(newGTVs)); - - RefTypeOrTPHOrWildcardOrGeneric t1 = new RefType(forType.getClassName(), params, new NullToken()); - RefTypeOrTPHOrWildcardOrGeneric t2 = superType; - - Pair ret = new Pair(t1, t2, PairOperator.SMALLER); - - List superTypes; - //Rekursiver Aufruf. Abbruchbedingung ist Object als Superklasse: - if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){ - superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER)); - }else{ - superTypes = getSuperTypes(superClass, availableClasses, newGTVs); - } + List superClasses = new ArrayList<>(); + superClasses.add(forType.getSuperClass()); + superClasses.addAll(forType.getSuperInterfaces()); List retList = new ArrayList<>(); - retList.add(ret); - retList.addAll(superTypes); + for(RefType superType : superClasses){ + Optional hasSuperclass = availableClasses.stream().filter(cl -> superType.getName().equals(cl.getClassName())).findAny(); + ClassOrInterface superClass; + if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception + { + superClass = ASTFactory.createClass(ClassLoader.getSystemClassLoader().loadClass(superType.getName().toString())); + }else{ + superClass = hasSuperclass.get(); + } + /* + Die Parameter der superklasse müssen jetzt nach den Angaben in der Subklasse + modifiziert werden + Beispie: Matrix extends Vector> + Den ersten Parameter mit Vector austauschen und dort alle Generics zu den Typplaceholdern in gtvs austauschen + */ + //Hier vermerken, welche Typen im der Superklasse ausgetauscht werden müssen + Iterator itGenParams = superClass.getGenerics().iterator(); + Iterator itSetParams = superType.getParaList().iterator(); + while(itGenParams.hasNext()){ + 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().getName(), setSetType); + } + + RefTypeOrTPHOrWildcardOrGeneric superRefType = superType.acceptTV(new TypeExchanger(newGTVs)); + + RefTypeOrTPHOrWildcardOrGeneric t1 = new RefType(forType.getClassName(), params, new NullToken()); + RefTypeOrTPHOrWildcardOrGeneric t2 = superRefType; + + Pair ret = new Pair(t1, t2, PairOperator.SMALLER); + + List superTypes; + //Rekursiver Aufruf. Abbruchbedingung ist Object als Superklasse: + if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){ + superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER)); + }else{ + superTypes = getSuperTypes(superClass, availableClasses, newGTVs); + } + + retList.add(ret); + retList.addAll(superTypes); + } return retList; } diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java index ed96d2e6..72606713 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java @@ -203,20 +203,20 @@ public class SyntaxTreeGenerator{ } Boolean isInterface = false; - List implementedInterfaces = convert(ctx.superinterfaces(), generics); + List implementedInterfaces = convert(ctx.superinterfaces(), generics); return new ClassOrInterface(modifiers, name, fielddecl, methods, konstruktoren, genericClassParameters, superClass, isInterface, implementedInterfaces, offset); } - private List convert(Java8Parser.SuperinterfacesContext ctx, GenericsRegistry generics) { + private List convert(Java8Parser.SuperinterfacesContext ctx, GenericsRegistry generics) { if(ctx == null)return new ArrayList<>(); return convert(ctx.interfaceTypeList(), generics); } - private List convert(Java8Parser.InterfaceTypeListContext ctx, GenericsRegistry generics) { - List ret = new ArrayList<>(); + private List convert(Java8Parser.InterfaceTypeListContext ctx, GenericsRegistry generics) { + List ret = new ArrayList<>(); for(Java8Parser.InterfaceTypeContext interfaceType : ctx.interfaceType()){ - ret.add(TypeGenerator.convert(interfaceType.classType(), reg, generics)); + ret.add((RefType) TypeGenerator.convert(interfaceType.classType(), reg, generics)); } return ret; } @@ -400,7 +400,7 @@ public class SyntaxTreeGenerator{ List fields = convertFields(ctx.interfaceBody()); List methods = convertMethods(ctx.interfaceBody(), name, superClass, generics); - List extendedInterfaces = convert(ctx.extendsInterfaces(), generics); + List extendedInterfaces = convert(ctx.extendsInterfaces(), generics); return new ClassOrInterface(modifiers, name, fields, methods, new ArrayList<>(), genericParams, superClass, true, extendedInterfaces, ctx.getStart()); @@ -423,7 +423,7 @@ public class SyntaxTreeGenerator{ return ret; } - private List convert(Java8Parser.ExtendsInterfacesContext extendsInterfacesContext, GenericsRegistry generics) { + private List convert(Java8Parser.ExtendsInterfacesContext extendsInterfacesContext, GenericsRegistry generics) { if(extendsInterfacesContext == null)return new ArrayList<>(); return convert(extendsInterfacesContext.interfaceTypeList(), generics); } diff --git a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java index 5d5fc3e2..72097fc0 100644 --- a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java +++ b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java @@ -13,6 +13,7 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation; import org.antlr.v4.runtime.Token; import java.util.ArrayList; +import java.util.Collection; import java.util.List; /** @@ -26,11 +27,11 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{ private GenericDeclarationList genericClassParameters; private RefType superClass; protected boolean isInterface; - private List implementedInterfaces; + private List implementedInterfaces; private List constructors; public ClassOrInterface(int modifiers, JavaClassName name, List fielddecl, List methods, List constructors, GenericDeclarationList genericClassParameters, - RefType superClass, Boolean isInterface, List implementedInterfaces, Token offset){ + RefType superClass, Boolean isInterface, List implementedInterfaces, Token offset){ super(offset); this.modifiers = modifiers; this.name = name; @@ -101,4 +102,8 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{ public void accept(ASTVisitor visitor) { visitor.visit(this); } + + public Collection getSuperInterfaces() { + return implementedInterfaces; + } } From ae7a63fbca6509f0665794fa6c884575364f04cc Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 14:22:30 +0100 Subject: [PATCH 07/15] Tests fix --- .../parser/SyntaxTreeGenerator/FCGenerator.java | 2 +- test/javFiles/MethodCallGenerics.jav | 14 ++++++++++++++ test/typeinference/JavaTXCompilerTest.java | 3 ++- 3 files changed, 17 insertions(+), 2 deletions(-) create mode 100644 test/javFiles/MethodCallGenerics.jav diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java index 24abec67..43743378 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java @@ -56,7 +56,7 @@ public class FCGenerator { } params.add(gtvs.get(gtv.getName())); } - + Optional hasSuperclass = availableClasses.stream().filter(cl -> forType.getSuperClass().getName().equals(cl.getClassName())).findAny(); ClassOrInterface superClass; if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception diff --git a/test/javFiles/MethodCallGenerics.jav b/test/javFiles/MethodCallGenerics.jav new file mode 100644 index 00000000..0d02509b --- /dev/null +++ b/test/javFiles/MethodCallGenerics.jav @@ -0,0 +1,14 @@ +import java.lang.String; + +class Generics { + // A mt1(A a, B b){ + B mt1(B a, B b){ + return mt1(a, a); + } +} + +class Test { + methode(String s){ + return new Generics().mt1(s,s); + } +} diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index 3ba22bc6..7c4c3582 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -50,7 +50,8 @@ public class JavaTXCompilerTest { } @Test public void genericsMethodCall() throws IOException, ClassNotFoundException { - execute(new File(rootDirectory+"MethodCallGenerics.jav")); + TestResultSet result = execute(new File(rootDirectory+"MethodCallGenerics.jav")); + //TODO: Hier sollte der Rückgabetyp der Methode String sein } @Test public void faculty() throws IOException, ClassNotFoundException { From 6b1a4eddfcf70eb29f9e0f1a2919cf0bcc59b667 Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Wed, 21 Mar 2018 14:40:47 +0100 Subject: [PATCH 08/15] =?UTF-8?q?Java=209=20zu=20Java=208=20=C3=A4ndern.?= =?UTF-8?q?=20Sollte=20ausreichen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 1b97e501..6dcac215 100644 --- a/pom.xml +++ b/pom.xml @@ -83,8 +83,8 @@ org.apache.maven.plugins maven-compiler-plugin - 9 - 9 + 8 + 8 From 161c1a1b53031cbbee47221504c6bc8461576c34 Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Wed, 21 Mar 2018 15:15:31 +0100 Subject: [PATCH 09/15] =?UTF-8?q?Test=20anf=C3=BCgen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/finiteClosure/SuperInterfacesTest.java | 31 +++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 test/finiteClosure/SuperInterfacesTest.java diff --git a/test/finiteClosure/SuperInterfacesTest.java b/test/finiteClosure/SuperInterfacesTest.java new file mode 100644 index 00000000..f00bf068 --- /dev/null +++ b/test/finiteClosure/SuperInterfacesTest.java @@ -0,0 +1,31 @@ +package finiteClosure; + +import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class SuperInterfacesTest { + @Test + public void test() throws ClassNotFoundException { + Collection classes = new ArrayList<>(); + classes.add(ASTFactory.createClass(TestClass.class)); + System.out.println(FCGenerator.toFC(classes)); + } +} + +class TestClass implements Test2, Test3{ + +} + +interface Test2 { + +} + +interface Test3{ + +} \ No newline at end of file From 45ccfb58e309627bfd963f10a1d9ca6beb08842b Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 17:10:40 +0100 Subject: [PATCH 10/15] Test commit --- .../dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java index 43743378..24abec67 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java @@ -56,7 +56,7 @@ public class FCGenerator { } params.add(gtvs.get(gtv.getName())); } - + Optional hasSuperclass = availableClasses.stream().filter(cl -> forType.getSuperClass().getName().equals(cl.getClassName())).findAny(); ClassOrInterface superClass; if(!hasSuperclass.isPresent()) //Wenn es die Klasse in den available Klasses nicht gibt wird sie im Classpath gesucht. Ansonsten Exception From dd18c7c40e63edc0250a7e86ca59bba4bc4e5e27 Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Wed, 21 Mar 2018 15:15:31 +0100 Subject: [PATCH 11/15] =?UTF-8?q?Test=20anf=C3=BCgen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/finiteClosure/SuperInterfacesTest.java | 31 +++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 test/finiteClosure/SuperInterfacesTest.java diff --git a/test/finiteClosure/SuperInterfacesTest.java b/test/finiteClosure/SuperInterfacesTest.java new file mode 100644 index 00000000..f00bf068 --- /dev/null +++ b/test/finiteClosure/SuperInterfacesTest.java @@ -0,0 +1,31 @@ +package finiteClosure; + +import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class SuperInterfacesTest { + @Test + public void test() throws ClassNotFoundException { + Collection classes = new ArrayList<>(); + classes.add(ASTFactory.createClass(TestClass.class)); + System.out.println(FCGenerator.toFC(classes)); + } +} + +class TestClass implements Test2, Test3{ + +} + +interface Test2 { + +} + +interface Test3{ + +} \ No newline at end of file From 9a735e86dd2e8c59870ecf567f81460ee1741dd9 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 17:26:43 +0100 Subject: [PATCH 12/15] =?UTF-8?q?GenericFC=20Test=20anf=C3=BCgen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/finiteClosure/SuperInterfacesTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/test/finiteClosure/SuperInterfacesTest.java b/test/finiteClosure/SuperInterfacesTest.java index f00bf068..0e1368c3 100644 --- a/test/finiteClosure/SuperInterfacesTest.java +++ b/test/finiteClosure/SuperInterfacesTest.java @@ -16,16 +16,31 @@ public class SuperInterfacesTest { classes.add(ASTFactory.createClass(TestClass.class)); System.out.println(FCGenerator.toFC(classes)); } + + @Test + public void testGeneric() throws ClassNotFoundException { + Collection classes = new ArrayList<>(); + classes.add(ASTFactory.createClass(TestClassGeneric.class)); + System.out.println(FCGenerator.toFC(classes)); + } } class TestClass implements Test2, Test3{ } +class TestClassGeneric implements Test4{ + +} + interface Test2 { } interface Test3{ +} + +interface Test4{ + } \ No newline at end of file From 06bb978cf6f1929adcbb95a5787fd2a066f5a4e1 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 21 Mar 2018 18:08:33 +0100 Subject: [PATCH 13/15] Testfall erweitern --- .../dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java | 2 +- test/finiteClosure/SuperInterfacesTest.java | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java index ceb3b817..1714570e 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java @@ -81,7 +81,7 @@ public class FCGenerator { //Hier vermerken, welche Typen im der Superklasse ausgetauscht werden müssen Iterator itGenParams = superClass.getGenerics().iterator(); Iterator itSetParams = superType.getParaList().iterator(); - while(itGenParams.hasNext()){ + while(itSetParams.hasNext()){ RefTypeOrTPHOrWildcardOrGeneric setType = itSetParams.next(); //In diesem Typ die GTVs durch TPHs und Einsetzungen austauschen: RefTypeOrTPHOrWildcardOrGeneric setSetType = setType.acceptTV(new TypeExchanger(gtvs)); diff --git a/test/finiteClosure/SuperInterfacesTest.java b/test/finiteClosure/SuperInterfacesTest.java index 0e1368c3..d96e5ecc 100644 --- a/test/finiteClosure/SuperInterfacesTest.java +++ b/test/finiteClosure/SuperInterfacesTest.java @@ -21,6 +21,7 @@ public class SuperInterfacesTest { public void testGeneric() throws ClassNotFoundException { Collection classes = new ArrayList<>(); classes.add(ASTFactory.createClass(TestClassGeneric.class)); + //TODO: Die ASTFactory generiert hier den Supertyp falsch. Es fehlt die Parameterliste System.out.println(FCGenerator.toFC(classes)); } } From 72f27fab7a8ca4bb430a17c2ffcadbca669da948 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 22 Mar 2018 11:17:51 +0100 Subject: [PATCH 14/15] Fehler in ASTFactory Generierung von Superinterfaces beheben --- src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java | 9 +++++++-- test/finiteClosure/SuperInterfacesTest.java | 1 - 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index c438bc67..67e1b14c 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -59,7 +59,7 @@ public class ASTFactory { superClass = (RefType) createType(java.lang.Object.class, name, ""); } List implementedInterfaces = new ArrayList<>(); - for(java.lang.Class jreInterface : jreClass.getInterfaces()){ + for(Type jreInterface : jreClass.getGenericInterfaces()){ implementedInterfaces.add((RefType) createType(jreInterface, name, "")); } GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null); @@ -193,7 +193,12 @@ public class ASTFactory { params.add(createType(t, parentClass, parentMethod)); } } - RefType ret = new RefType(new JavaClassName(type.getTypeName()), params, new NullToken()); + String name = type.getTypeName(); + if(name.contains("<")){ //Komischer fix. Type von Generischen Typen kann die Generics im Namen enthalten Type + //Diese entfernen: + name = name.split("<")[0]; + } + RefType ret = new RefType(new JavaClassName(name), params, new NullToken()); return ret; } } diff --git a/test/finiteClosure/SuperInterfacesTest.java b/test/finiteClosure/SuperInterfacesTest.java index d96e5ecc..0e1368c3 100644 --- a/test/finiteClosure/SuperInterfacesTest.java +++ b/test/finiteClosure/SuperInterfacesTest.java @@ -21,7 +21,6 @@ public class SuperInterfacesTest { public void testGeneric() throws ClassNotFoundException { Collection classes = new ArrayList<>(); classes.add(ASTFactory.createClass(TestClassGeneric.class)); - //TODO: Die ASTFactory generiert hier den Supertyp falsch. Es fehlt die Parameterliste System.out.println(FCGenerator.toFC(classes)); } } From bcee5e5209a667625338c0ea79f4f5be35ebe241 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 22 Mar 2018 11:41:59 +0100 Subject: [PATCH 15/15] Fehler im Parsen von Package beheben --- .../SyntaxTreeGenerator/SyntaxTreeGenerator.java | 14 ++++++++++++-- test/javFiles/Package.jav | 5 +++++ test/typeinference/JavaTXCompilerTest.java | 4 ++++ 3 files changed, 21 insertions(+), 2 deletions(-) create mode 100644 test/javFiles/Package.jav diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java index 72606713..b7f14f19 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java @@ -73,6 +73,7 @@ public class SyntaxTreeGenerator{ } public SourceFile convert(Java8Parser.CompilationUnitContext ctx, PackageCrawler packageCrawler) throws ClassNotFoundException{ + if(ctx.packageDeclaration()!=null)this.pkgName = convert(ctx.packageDeclaration()); List classes = new ArrayList<>(); Map imports = GatherNames.getImports(ctx, packageCrawler); this.imports = imports.keySet().stream().map(name -> reg.getName(name)).collect(Collectors.toSet()); @@ -89,6 +90,15 @@ public class SyntaxTreeGenerator{ return new SourceFile(this.pkgName, classes, this.imports); } + private String convert(Java8Parser.PackageDeclarationContext packageDeclarationContext) { + String ret = ""; + for(TerminalNode identifier : packageDeclarationContext.Identifier()){ + ret += identifier.getText()+"."; + } + ret = ret.substring(0, ret.length()-1); + return ret; + } + public Method convert(Java8Parser.MethodDeclarationContext methodDeclarationContext, JavaClassName parentClass, RefType superClass, GenericsRegistry generics) { Java8Parser.MethodHeaderContext header = methodDeclarationContext.methodHeader(); int modifiers = SyntaxTreeGenerator.convert(methodDeclarationContext.methodModifier()); @@ -165,8 +175,8 @@ public class SyntaxTreeGenerator{ } } String className = this.pkgName + (this.pkgName.length()>0?".":"") + ctx.Identifier().getText(); - JavaClassName name = reg.getName(className); - if(! name.toString().equals(className)){ + JavaClassName name = reg.getName(className); //Holt den Package Namen mit dazu + if(! name.toString().equals(className)){ //Kommt die Klasse schon in einem anderen Package vor? throw new TypeinferenceException("Name " + className + " bereits vorhanden in " + reg.getName(className).toString() ,ctx.getStart()); } diff --git a/test/javFiles/Package.jav b/test/javFiles/Package.jav new file mode 100644 index 00000000..bbc1e51d --- /dev/null +++ b/test/javFiles/Package.jav @@ -0,0 +1,5 @@ +package strucType.input; + +class Neu +{ +} \ No newline at end of file diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index 7c4c3582..ba004cb5 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -66,6 +66,10 @@ public class JavaTXCompilerTest { execute(new File(rootDirectory+"Matrix.jav")); } @Test + public void packageTests() throws IOException, ClassNotFoundException { + execute(new File(rootDirectory+"Package.jav")); + } + @Test public void vector() throws IOException, ClassNotFoundException { execute(new File(rootDirectory+"Vector.jav")); }