From 7ff3f22db50341243a76670e3d78c9d5efa2f320 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Fri, 23 Mar 2018 17:20:15 +0100 Subject: [PATCH 01/16] Fehler in FCGenerator beheben --- .../SyntaxTreeGenerator/FCGenerator.java | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java index 1714570e3..0dfd64e9b 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java @@ -43,8 +43,16 @@ public class FCGenerator { return getSuperTypes(forType, availableClasses, new HashMap<>()); } - //TODO: implements Interface auch als superklassen beachten - private static List getSuperTypes(ClassOrInterface forType, Collection availableClasses, HashMap gtvs) throws ClassNotFoundException { + /** + * + * @param forType + * @param availableClasses + * @param gtvs + * @return + * @throws ClassNotFoundException + */ + private static List getSuperTypes(ClassOrInterface forType, Collection availableClasses, + HashMap gtvs) throws ClassNotFoundException { List params = new ArrayList<>(); //Die GTVs, die in forType hinzukommen: HashMap newGTVs = new HashMap<>(); @@ -78,7 +86,7 @@ public class FCGenerator { 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 + //Hier vermerken, welche Typen in der Superklasse ausgetauscht werden müssen Iterator itGenParams = superClass.getGenerics().iterator(); Iterator itSetParams = superType.getParaList().iterator(); while(itSetParams.hasNext()){ @@ -88,7 +96,9 @@ public class FCGenerator { newGTVs.put(itGenParams.next().getName(), setSetType); } - RefTypeOrTPHOrWildcardOrGeneric superRefType = superType.acceptTV(new TypeExchanger(newGTVs)); + //Für den superType kann man nun zum Austauschen der Generics wieder die gtvs nehmen: + //Die newGTVs sind nur für den superClass ClassOrInterface welches möglicherweise per reflection geladen wurde abgestimmt + RefTypeOrTPHOrWildcardOrGeneric superRefType = superType.acceptTV(new TypeExchanger(gtvs)); RefTypeOrTPHOrWildcardOrGeneric t1 = new RefType(forType.getClassName(), params, new NullToken()); RefTypeOrTPHOrWildcardOrGeneric t2 = superRefType; From 3e829eee542e95d6fbb21870179d21f5d782540c Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Fri, 23 Mar 2018 17:45:41 +0100 Subject: [PATCH 02/16] Tests anpassen --- test/javFiles/Lambda2.jav | 1 + test/javFiles/Lambda3.jav | 1 + 2 files changed, 2 insertions(+) diff --git a/test/javFiles/Lambda2.jav b/test/javFiles/Lambda2.jav index fbcdaf55b..cf1e910b8 100644 --- a/test/javFiles/Lambda2.jav +++ b/test/javFiles/Lambda2.jav @@ -1,3 +1,4 @@ +import java.lang.String; public class Lambda2 { diff --git a/test/javFiles/Lambda3.jav b/test/javFiles/Lambda3.jav index 9c4e960cd..9e22f3027 100644 --- a/test/javFiles/Lambda3.jav +++ b/test/javFiles/Lambda3.jav @@ -1,3 +1,4 @@ +import java.lang.String; public class Lambda2 { From f40c82af4a61899208aa2009e08894a004911783 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 12 Apr 2018 20:06:37 +0200 Subject: [PATCH 03/16] Matrix Test anpassen --- test/javFiles/Matrix.jav | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/test/javFiles/Matrix.jav b/test/javFiles/Matrix.jav index aa8966c9f..a680370f4 100644 --- a/test/javFiles/Matrix.jav +++ b/test/javFiles/Matrix.jav @@ -3,24 +3,27 @@ import java.lang.Integer; import java.lang.Boolean; class Matrix extends Vector> { + Integer mul1(Integer x, Integer y) { return x;} + Integer add1(Integer x, Integer y) { return x;} mul(m) { var ret = new Matrix(); var i = 0; - //while(i < size()) { + while(i < size()) { var v1 = this.elementAt(i); - //var v2 = new Vector(); - //var j = 0; - //while(j < v1.size()) { - //var erg = 0; - //var k = 0; - //while(k < v1.size()) { - //erg = erg + v1.elementAt(k) - // * m.elementAt(k).elementAt(j); - //k++; } - //v2.addElement(new Integer(erg)); - //j++; } - //ret.addElement(v2); - //i++; } + var v2 = new Vector(); + var j = 0; + while(j < v1.size()) { + var erg = 0; + var k = 0; + while(k < v1.size()) { + //erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j); + erg = add1(erg, mul1(v1.elementAt(k), + m.elementAt(k).elementAt(j))); + k++; } + v2.addElement(new Integer(erg)); + j++; } + ret.addElement(v2); + i++; } return ret; } } From 50a1f979a0f619d5b6099a49172037ecb8c5f31f Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 18 Apr 2018 14:08:12 +0200 Subject: [PATCH 04/16] Fehler beim Parsen beheben --- .../parser/SyntaxTreeGenerator/TypeGenerator.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index 38399bf0d..4bc08960f 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -113,9 +113,8 @@ public class TypeGenerator { if(referenceTypeContext.classOrInterfaceType() != null){ if(referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType()!= null){ Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType(); - //return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics); - if(ctx.typeArguments() != null)throw new NotImplementedException(); - return convertTypeName(referenceTypeContext.getText(), null,referenceTypeContext.getStart(), reg, generics); + return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics); + //return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics); }else{ throw new NotImplementedException(); } From c8728bab10627b61a682ead3cc31f991d35ce444 Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Mon, 7 May 2018 12:51:29 +0200 Subject: [PATCH 05/16] Testfall fix --- test/javFiles/Generics.jav | 1 + 1 file changed, 1 insertion(+) diff --git a/test/javFiles/Generics.jav b/test/javFiles/Generics.jav index c76b40aa5..dd7b4eba5 100644 --- a/test/javFiles/Generics.jav +++ b/test/javFiles/Generics.jav @@ -1,3 +1,4 @@ +import java.lang.String; class Generics { // A mt1(A a, B b){ From 35d5fb2f03e2a7a4316bfce6e68123c45f87c71b Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Mon, 7 May 2018 15:12:07 +0200 Subject: [PATCH 06/16] Fehler in ASTFactory mit Generischen FEldern beheben --- .../dhbwstuttgart/syntaxtree/factory/ASTFactory.java | 4 ++-- test/astfactory/ASTFactoryTest.java | 12 ++++++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index 52921c5d6..efd20831a 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -37,7 +37,7 @@ public class ASTFactory { methoden.add(createMethod(method, jreClass)); } List felder = new ArrayList<>(); - for(java.lang.reflect.Field field : jreClass.getFields()){ + for(java.lang.reflect.Field field : jreClass.getDeclaredFields()){ felder.add(createField(field, name)); } int modifier = jreClass.getModifiers(); @@ -89,7 +89,7 @@ public class ASTFactory { } 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()); + return new Field(field.getName(), createType(field.getGenericType(), jreClass, null), field.getModifiers(), new NullToken()); } //private static RefType createType(Class classType) { diff --git a/test/astfactory/ASTFactoryTest.java b/test/astfactory/ASTFactoryTest.java index c3b62b0b6..6285cf0a6 100644 --- a/test/astfactory/ASTFactoryTest.java +++ b/test/astfactory/ASTFactoryTest.java @@ -1,6 +1,9 @@ package astfactory; //import javafx.collections.ObservableList; +import de.dhbwstuttgart.syntaxtree.ClassOrInterface; +import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; +import de.dhbwstuttgart.syntaxtree.type.GenericRefType; import org.junit.Test; import java.lang.reflect.ParameterizedType; @@ -19,4 +22,13 @@ public class ASTFactoryTest extends HashMap{ System.out.println(Arrays.toString(arguments)); System.out.println(((TypeVariable)arguments[1]).getGenericDeclaration()); } + + public static class GenericFieldTest{ + public G testField; + } + @Test + public void genericFieldTest(){ + ClassOrInterface test = ASTFactory.createClass(GenericFieldTest.class); + assertTrue(test.getFieldDecl().get(0).getType() instanceof GenericRefType); + } } \ No newline at end of file From 832623a738a191ddcab57fe4a71d2d99715eb264 Mon Sep 17 00:00:00 2001 From: Andreas Stadelmeier Date: Wed, 16 May 2018 15:37:46 +0200 Subject: [PATCH 07/16] ClassOrInterface muss im Modifier INTERFACE haben, wenn isInterface gesetzt ist --- src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java index 72097fc03..00788b63a 100644 --- a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java +++ b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree; +import com.sun.org.apache.xpath.internal.operations.Mod; import de.dhbwstuttgart.core.IItemWithOffset; import de.dhbwstuttgart.exceptions.DebugException; import de.dhbwstuttgart.parser.scope.JavaClassName; @@ -12,6 +13,7 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation; import org.antlr.v4.runtime.Token; +import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Collection; import java.util.List; @@ -33,6 +35,7 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{ public ClassOrInterface(int modifiers, JavaClassName name, List fielddecl, List methods, List constructors, GenericDeclarationList genericClassParameters, RefType superClass, Boolean isInterface, List implementedInterfaces, Token offset){ super(offset); + if(isInterface && !Modifier.isInterface(modifiers))modifiers += Modifier.INTERFACE; this.modifiers = modifiers; this.name = name; this.fields = fielddecl; From ad422824858a84d65acfbc7864086e3b53f8e456 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Mon, 28 May 2018 15:55:14 +0200 Subject: [PATCH 08/16] Test --- test/parser/GeneralParserTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/parser/GeneralParserTest.java b/test/parser/GeneralParserTest.java index b218347f2..4e7d9868d 100644 --- a/test/parser/GeneralParserTest.java +++ b/test/parser/GeneralParserTest.java @@ -42,7 +42,7 @@ public class GeneralParserTest{ filenames.add("StructuralTypes.jav"); */ // filenames.add("ExtendsTest.jav"); - filenames.add("OpratorTest.jav"); + filenames.add("PackageNameTest.jav"); try{ new JavaTXCompiler(filenames.stream().map(s -> new File(rootDirectory + s)).collect(Collectors.toList())); }catch(Exception exc){ From 7e3fca2da98938923a62c0856c64297951310c3b Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Mon, 28 May 2018 16:18:33 +0200 Subject: [PATCH 09/16] =?UTF-8?q?Hotfix=20f=C3=BCr=20Typparsen=20Problem?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../parser/SyntaxTreeGenerator/TypeGenerator.java | 14 ++++++++------ test/parser/PackageNameTest.jav | 9 +++++++++ 2 files changed, 17 insertions(+), 6 deletions(-) create mode 100644 test/parser/PackageNameTest.jav diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index 4bc08960f..00a0f778e 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -22,18 +22,20 @@ import java.util.List; public class TypeGenerator { public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) { - String name; - if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){ - name = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().Identifier().getText(); - } Java8Parser.TypeArgumentsContext arguments; if(unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType() != null){ - name = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().Identifier().getText(); arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); }else{// if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){ - name = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().getText(); arguments = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments(); } + /** + * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten + * Beispiel: Typ.InnererTyp + */ + String name = unannClassOrInterfaceTypeContext.getText(); + if(name.contains("<")){ + name = name.split("<")[0]; //Der Typ ist alles vor den ersten Argumenten + } return convertTypeName(name, arguments, unannClassOrInterfaceTypeContext.getStart(), reg, generics); } diff --git a/test/parser/PackageNameTest.jav b/test/parser/PackageNameTest.jav new file mode 100644 index 000000000..53c889b77 --- /dev/null +++ b/test/parser/PackageNameTest.jav @@ -0,0 +1,9 @@ +import java.lang.Integer; +import java.lang.Comparable; + +class PackageNameTest{ +java.lang.Integer test(a){return a;} + +Comparable test2(a){return a;} + +} \ No newline at end of file From 26f24db0a31e856a3eb6ef10bacab7142a8ded34 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Mon, 28 May 2018 17:08:08 +0200 Subject: [PATCH 10/16] Kleiner Fix am ASTWalker --- src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java | 8 ++++---- src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java | 6 ++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java b/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java index 4168b5870..bf9fe2637 100644 --- a/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java +++ b/src/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java @@ -66,10 +66,10 @@ public abstract class AbstractASTWalker implements ASTVisitor{ @Override public void visit(ParameterList formalParameters) { - Iterator genericIterator = formalParameters.getFormalparalist().iterator(); - if(genericIterator.hasNext()){ - while(genericIterator.hasNext()){ - genericIterator.next().accept(this); + Iterator it = formalParameters.getFormalparalist().iterator(); + if(it.hasNext()){ + while(it.hasNext()){ + it.next().accept(this); } } } diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java index ad591ebe5..9e5ba545a 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java +++ b/src/de/dhbwstuttgart/typedeployment/TypeInsertPlacer.java @@ -59,13 +59,11 @@ class TypeInsertPlacerClass extends AbstractASTWalker{ } @Override - public void visit(ParameterList params) { - for(FormalParameter param : params){ + public void visit(FormalParameter param) { if(param.getType() instanceof TypePlaceholder) inserts.add(TypeInsertFactory.createInsertPoints( param.getType(), param.getType().getOffset(), cl, method, results)); - } - super.visit(params); + super.visit(param); } @Override From ee1fa17aba5e47ea279b4f102a63ccfe91c2636c Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 30 May 2018 15:29:59 +0200 Subject: [PATCH 11/16] Implement convert(ClassOrInterfaceType) --- .../parser/SyntaxTreeGenerator/TypeGenerator.java | 11 +++++------ src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java | 1 - 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index 00a0f778e..d36fd172f 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -92,7 +92,7 @@ public class TypeGenerator { return ret; } if(typeBoundContext.classOrInterfaceType() != null){ - ret.add(convert(typeBoundContext.classOrInterfaceType())); + ret.add(convert(typeBoundContext.classOrInterfaceType(), reg, generics)); if(typeBoundContext.additionalBound() != null) for(Java8Parser.AdditionalBoundContext addCtx : typeBoundContext.additionalBound()){ ret.add(convert(addCtx.interfaceType())); @@ -103,8 +103,9 @@ public class TypeGenerator { } } - private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext) { - throw new NotImplementedException(); + private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ClassOrInterfaceTypeContext classOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) { + Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = classOrInterfaceTypeContext.classType_lfno_classOrInterfaceType(); + return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),classOrInterfaceTypeContext.getStart(), reg, generics); } private static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.InterfaceTypeContext interfaceTypeContext) { @@ -114,9 +115,7 @@ public class TypeGenerator { public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.ReferenceTypeContext referenceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) { if(referenceTypeContext.classOrInterfaceType() != null){ if(referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType()!= null){ - Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType(); - return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics); - //return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics); + return convert(referenceTypeContext.classOrInterfaceType(), reg, generics);//return convertTypeName(referenceTypeContext.getText(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics); }else{ throw new NotImplementedException(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java index 00788b63a..b9a633464 100644 --- a/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java +++ b/src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java @@ -1,6 +1,5 @@ package de.dhbwstuttgart.syntaxtree; -import com.sun.org.apache.xpath.internal.operations.Mod; import de.dhbwstuttgart.core.IItemWithOffset; import de.dhbwstuttgart.exceptions.DebugException; import de.dhbwstuttgart.parser.scope.JavaClassName; From 98eb1827b82424fb1be2a146912cafaae9380e8c Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 30 May 2018 15:57:51 +0200 Subject: [PATCH 12/16] Fix Generics parsing --- .../parser/SyntaxTreeGenerator/TypeGenerator.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index d36fd172f..db5770305 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -61,6 +61,10 @@ public class TypeGenerator { public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext, JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) { + for(Java8Parser.TypeParameterContext tp : typeParametersContext.typeParameterList().typeParameter()){ + generics.put(tp.Identifier().getText(), new GenericContext(parentClass, parentMethod)); + } + Token endOffset = typeParametersContext.getStop(); List typeVars = new ArrayList<>(); for(Java8Parser.TypeParameterContext typeParameter : typeParametersContext.typeParameterList().typeParameter()){ @@ -77,7 +81,6 @@ public class TypeGenerator { List bounds = TypeGenerator.convert(typeParameter.typeBound(),reg, generics); GenericTypeVar ret = new GenericTypeVar(name, bounds, typeParameter.getStart(), typeParameter.getStop()); - generics.put(name, new GenericContext(parentClass, parentMethod)); return ret; } From 1ca7fba835ad8b8a50fdfe0c9b5f681cc446e011 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 30 May 2018 16:10:20 +0200 Subject: [PATCH 13/16] Generics fix --- .../parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java | 3 +++ .../parser/SyntaxTreeGenerator/TypeGenerator.java | 4 ---- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java index b7f14f198..33ece33eb 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java @@ -427,6 +427,9 @@ public class SyntaxTreeGenerator{ GenericsRegistry ret = new GenericsRegistry(this.globalGenerics); ret.putAll(generics); if(ctx == null || ctx.typeParameterList() == null)return ret; + for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){ + ret.put(tp.Identifier().getText(), new GenericContext(parentClass, parentMethod)); + } for(Java8Parser.TypeParameterContext tp : ctx.typeParameterList().typeParameter()){ TypeGenerator.convert(tp, parentClass, parentMethod, reg, ret); } diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index db5770305..371a5d796 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java @@ -61,10 +61,6 @@ public class TypeGenerator { public static GenericDeclarationList convert(Java8Parser.TypeParametersContext typeParametersContext, JavaClassName parentClass, String parentMethod, JavaClassRegistry reg, GenericsRegistry generics) { - for(Java8Parser.TypeParameterContext tp : typeParametersContext.typeParameterList().typeParameter()){ - generics.put(tp.Identifier().getText(), new GenericContext(parentClass, parentMethod)); - } - Token endOffset = typeParametersContext.getStop(); List typeVars = new ArrayList<>(); for(Java8Parser.TypeParameterContext typeParameter : typeParametersContext.typeParameterList().typeParameter()){ From acf8c108e8f7188cbf642bdb04c0ca8433926455 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Thu, 26 Jul 2018 14:57:13 +0200 Subject: [PATCH 14/16] Diamantoperator --- .../parser/SyntaxTreeGenerator/StatementGenerator.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java index 5310d13be..6f371a1dd 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java +++ b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java @@ -745,6 +745,7 @@ public class StatementGenerator { if(e.classInstanceCreationExpression_lf_primary() != null){ throw new NotImplementedException(); }else if(e.fieldAccess_lf_primary() != null){ + throw new NotImplementedException(); }else if(e.arrayAccess_lf_primary() != null){ throw new NotImplementedException(); @@ -799,8 +800,6 @@ public class StatementGenerator { if(newExpression.typeArgumentsOrDiamond()!= null){ if(newExpression.typeArgumentsOrDiamond().typeArguments()!=null){ genericArgs = newExpression.typeArgumentsOrDiamond().typeArguments(); - }else { - throw new NotImplementedException(); } } if(newExpression.typeArguments()!= null)throw new NotImplementedException(); From af894ebfe4fd9c9bd80326d76e36167c9a41d171 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Mon, 6 Aug 2018 14:01:31 +0200 Subject: [PATCH 15/16] Fehler mit Wildcards in ASTFactory beheben --- .../syntaxtree/factory/ASTFactory.java | 16 ++++++++++++++-- .../syntaxtree/type/ExtendsWildcardType.java | 4 ++++ .../syntaxtree/type/SuperWildcardType.java | 5 +++++ 3 files changed, 23 insertions(+), 2 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index efd20831a..f84e21726 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -17,6 +17,7 @@ import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.syntaxtree.*; import de.dhbwstuttgart.syntaxtree.statement.Block; import de.dhbwstuttgart.syntaxtree.statement.Statement; +import de.dhbwstuttgart.syntaxtree.type.WildcardType; import org.antlr.v4.runtime.Token; /** @@ -201,8 +202,19 @@ public class ASTFactory { //Diese entfernen: name = name.split("<")[0]; } - RefType ret = new RefType(new JavaClassName(name), params, new NullToken()); - return ret; + if(type instanceof java.lang.reflect.WildcardType){ + java.lang.reflect.WildcardType wildcardType = (java.lang.reflect.WildcardType) type; + if(wildcardType.getLowerBounds().length > 0){ + return new SuperWildcardType(convertType(wildcardType.getLowerBounds()[0]), new NullToken()); + }else if(wildcardType.getUpperBounds().length > 0){ + return new ExtendsWildcardType(convertType(wildcardType.getUpperBounds()[0]), new NullToken()); + }else{//Es handelt sich um den '?'-Typ: + return new ExtendsWildcardType(createObjectType(), new NullToken()); + } + }else{ + RefType ret = new RefType(new JavaClassName(name), params, new NullToken()); + return ret; + } } } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java index d5abd93b8..5f282e467 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java @@ -34,6 +34,10 @@ public class ExtendsWildcardType extends WildcardType{ return false; } + @Override + public String toString() { + return "? extends "+innerType.toString(); + } @Override public void accept(ASTVisitor visitor) { diff --git a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java index 740c80e5a..625fb01bd 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java @@ -35,6 +35,11 @@ public class SuperWildcardType extends WildcardType{ return this.innerType; } + @Override + public String toString() { + return "? super "+innerType.toString(); + } + @Override public boolean isExtends() { return false; From f18083ba06896e8559816d713a40f80a1b759f9b Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Mon, 6 Aug 2018 16:39:35 +0200 Subject: [PATCH 16/16] Merge --- .../syntaxtree/factory/ASTFactory.java | 60 +++++-------------- .../assumptions/MethodAssumption.java | 4 +- .../typeinference/typeAlgo/TYPE.java | 3 +- 3 files changed, 16 insertions(+), 51 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index f84e21726..d92d0b9a9 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java @@ -51,15 +51,15 @@ public class ASTFactory { java.lang.Class superjreClass = jreClass.getSuperclass(); RefType superClass; if(parameterSuperClass != null){ - superClass = (RefType) convertType(parameterSuperClass); + superClass = (RefType) createType(parameterSuperClass); }else if(superjreClass != null){ - superClass = (RefType) convertType(superjreClass); + superClass = (RefType) createType(superjreClass); }else{//Jede Klasse und jedes Interface erbt von Object: (auch Object selbst!) - superClass = (RefType) createType(java.lang.Object.class, name, ""); + superClass = (RefType) createType(java.lang.Object.class); } List implementedInterfaces = new ArrayList<>(); for(Type jreInterface : jreClass.getGenericInterfaces()){ - implementedInterfaces.add((RefType) createType(jreInterface, name, "")); + implementedInterfaces.add((RefType) createType(jreInterface)); } GenericDeclarationList genericDeclarationList = createGenerics(jreClass.getTypeParameters(), jreClass, null); @@ -68,29 +68,8 @@ public class ASTFactory { return new ClassOrInterface(modifier, name, felder, methoden, konstruktoren, genericDeclarationList, superClass,isInterface, implementedInterfaces, offset); } - private static RefTypeOrTPHOrWildcardOrGeneric convertType(Type type){ - if(type instanceof ParameterizedType){ - List params = new ArrayList<>(); - for(Type paramType : ((ParameterizedType)type).getActualTypeArguments()){ - params.add(convertType(paramType)); - } - JavaClassName name = new JavaClassName(((ParameterizedType) type).getRawType().getTypeName()); - return new RefType(name, params, new NullToken()); - }else if(type instanceof TypeVariable){ - return new GenericRefType(((TypeVariable) type).getName(), new NullToken()); - }else if(type instanceof Class){ - List params = new ArrayList<>(); - Class paramClass = (Class) type; - for(TypeVariable tv : paramClass.getTypeParameters()){ - params.add(new GenericRefType(tv.getName(), new NullToken())); - } - JavaClassName name = new JavaClassName(paramClass.getName()); - return new RefType(name, params, new NullToken()); - }else throw new NotImplementedException(); - } - private static Field createField(java.lang.reflect.Field field, JavaClassName jreClass) { - return new Field(field.getName(), createType(field.getGenericType(), jreClass, null), field.getModifiers(), new NullToken()); + return new Field(field.getName(), createType(field.getType()), field.getModifiers(), new NullToken()); } //private static RefType createType(Class classType) { @@ -99,13 +78,13 @@ public class ASTFactory { private static de.dhbwstuttgart.syntaxtree.Constructor createConstructor(Constructor constructor, Class inClass) { String name = constructor.getName(); - RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass, new JavaClassName(inClass.getName()), name); + RefTypeOrTPHOrWildcardOrGeneric returnType = createType(inClass); Parameter[] jreParams = constructor.getParameters(); Type[] jreGenericParams = constructor.getGenericParameterTypes(); List params = new ArrayList<>(); int i = 0; for(Type jreParam : jreGenericParams){ - RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name); + RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam); params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken())); i++; } @@ -131,13 +110,13 @@ public class ASTFactory { }else{ jreRetType = jreMethod.getReturnType(); } - returnType = createType(jreRetType,new JavaClassName(inClass.getName()), name); + returnType = createType(jreRetType); Parameter[] jreParams = jreMethod.getParameters(); Type[] jreGenericParams = jreMethod.getGenericParameterTypes(); List params = new ArrayList<>(); int i = 0; for(Type jreParam : jreGenericParams){ - RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam,new JavaClassName(inClass.getName()), name); + RefTypeOrTPHOrWildcardOrGeneric paramType = createType(jreParam); params.add(new FormalParameter(jreParams[i].getName(),paramType, new NullToken())); i++; } @@ -158,18 +137,7 @@ public class ASTFactory { return new GenericDeclarationList(gtvs,new NullToken()); } - /* - public RefType createType(java.lang.Class jreClass){ - List params = new ArrayList<>(); - for(TypeVariable jreTV : jreClass.getTypeParameters()){ - RefType gtv = createType(jreTV); - params.add(gtv); - } - return new RefType(names.getName(jreClass.getName()), params, new NullToken()); - } - */ - - private static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type, JavaClassName parentClass, String parentMethod){ + private static RefTypeOrTPHOrWildcardOrGeneric createType(java.lang.reflect.Type type){ if(type.getTypeName().equals("void")){ return new Void(new NullToken()); }else if(type.getTypeName().equals("int")){ @@ -194,7 +162,7 @@ public class ASTFactory { List params = new ArrayList<>(); if(type instanceof ParameterizedType){ for(Type t : ((ParameterizedType)type).getActualTypeArguments()){ - params.add(createType(t, parentClass, parentMethod)); + params.add(createType(t)); } } String name = type.getTypeName(); @@ -205,9 +173,9 @@ public class ASTFactory { if(type instanceof java.lang.reflect.WildcardType){ java.lang.reflect.WildcardType wildcardType = (java.lang.reflect.WildcardType) type; if(wildcardType.getLowerBounds().length > 0){ - return new SuperWildcardType(convertType(wildcardType.getLowerBounds()[0]), new NullToken()); + return new SuperWildcardType(createType(wildcardType.getLowerBounds()[0]), new NullToken()); }else if(wildcardType.getUpperBounds().length > 0){ - return new ExtendsWildcardType(convertType(wildcardType.getUpperBounds()[0]), new NullToken()); + return new ExtendsWildcardType(createType(wildcardType.getUpperBounds()[0]), new NullToken()); }else{//Es handelt sich um den '?'-Typ: return new ExtendsWildcardType(createObjectType(), new NullToken()); } @@ -224,7 +192,7 @@ public class ASTFactory { java.lang.reflect.Type[] bounds = jreTypeVar.getBounds(); if(bounds.length > 0){ for(java.lang.reflect.Type bound : bounds){ - genericBounds.add((RefType) createType(bound, parentClass, parentMethod)); + genericBounds.add((RefType) createType(bound)); } } return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken()); diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java index e17281e5f..ffb396705 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java +++ b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java @@ -45,9 +45,7 @@ public class MethodAssumption extends Assumption{ public List getArgTypes(GenericsResolver resolver) { List ret = new ArrayList<>(); for(RefTypeOrTPHOrWildcardOrGeneric param : params){ - if(param instanceof GenericRefType){ //Generics in den Assumptions müssen umgewandelt werden. - param = resolver.resolve((GenericRefType) param); - } + param = resolver.resolve(param); ret.add(param); } return ret; diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java index 4a41176c5..6a4410505 100644 --- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java +++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java @@ -60,8 +60,7 @@ public class TYPE { return new TypeInferenceInformation(classes); } - - */ + */ private ConstraintSet getConstraintsMethod(Method m, TypeInferenceInformation info, ClassOrInterface currentClass) { if(m.block == null)return new ConstraintSet(); //Abstrakte Methoden generieren keine Constraints TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);