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/bytecode/signature/Signature.java b/src/de/dhbwstuttgart/bytecode/signature/Signature.java index f9bcb369..46202cb1 100644 --- a/src/de/dhbwstuttgart/bytecode/signature/Signature.java +++ b/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 genAndBounds) { - sw.visitFormalTypeParameter(g.getParsedName()); + sw.visitFormalTypeParameter(g.getName()); Iterator 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(); } diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java index ea2b17a6..24abec67 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java +++ b/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 newGTVs = new HashMap<>(); //Generics mit gleichem Namen müssen den selben TPH bekommen for(GenericTypeVar gtv : forType.getGenerics()){ - if(!gtvs.containsKey(gtv.getParsedName())){ - gtvs.put(gtv.getParsedName(), TypePlaceholder.fresh(new NullToken())); - newGTVs.put(gtv.getParsedName(), TypePlaceholder.fresh(new NullToken())); + if(!gtvs.containsKey(gtv.getName())){ + gtvs.put(gtv.getName(), 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 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)); diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/GenericContext.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/GenericContext.java index 6e3ce7d9..0cea06ed 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/GenericContext.java +++ b/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; - public final JavaClassName parentClass; + private final String parentMethod; + private final JavaClassName parentClass; public GenericContext(JavaClassName parentClass, String parentMethod) { if(parentMethod == null)parentMethod = ""; diff --git a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java b/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java index 1dd259d0..b4923039 100644 --- a/src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java +++ b/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 ist erlaubt, würde aber bei den Bounds von A den Generic B nicht als solchen erkennen List 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; } @@ -131,7 +130,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); } diff --git a/src/de/dhbwstuttgart/parser/scope/GenericTypeName.java b/src/de/dhbwstuttgart/parser/scope/GenericTypeName.java deleted file mode 100644 index c5355ebd..00000000 --- a/src/de/dhbwstuttgart/parser/scope/GenericTypeName.java +++ /dev/null @@ -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; - } -} diff --git a/src/de/dhbwstuttgart/sat/asp/writer/ASPGenerator.java b/src/de/dhbwstuttgart/sat/asp/writer/ASPGenerator.java index b1483423..676aa33f 100644 --- a/src/de/dhbwstuttgart/sat/asp/writer/ASPGenerator.java +++ b/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)); } } diff --git a/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java index 02042ca3..6ee03b60 100644 --- a/src/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java +++ b/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 bounds=new ArrayList(); private Token endOffset; - private GenericTypeName name; + private String name; - public GenericTypeVar(GenericTypeName s, List bounds, Token offset, Token endOffset) + public GenericTypeVar(String s, List 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() { - return name; - } - - public String getParsedName(){ + public String getName(){ return name.toString(); } + /* public JavaClassName definingClass(){ return name.getParentClass(); } - +*/ @Override public void accept(ASTVisitor visitor) { visitor.visit(this); diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java index b0683569..c438bc67 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java +++ b/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; @@ -43,12 +42,17 @@ 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 = 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 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!) @@ -65,18 +69,41 @@ 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 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()); } + //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()); @@ -89,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()); @@ -153,9 +185,7 @@ public class ASTFactory { }else{ if(type instanceof TypeVariable){ //GTVDeclarationContext via "(TypeVariable) type).getGenericDeclaration()" - return new GenericRefType( - new GenericTypeName(new GenericContext(parentClass, parentMethod),type.getTypeName()), - new NullToken()); + return new GenericRefType(type.getTypeName(), new NullToken()); } List params = new ArrayList<>(); if(type instanceof ParameterizedType){ @@ -177,9 +207,7 @@ public class ASTFactory { genericBounds.add((RefType) createType(bound, parentClass, parentMethod)); } } - return new de.dhbwstuttgart.syntaxtree.GenericTypeVar( - new GenericTypeName(new GenericContext(parentClass, parentMethod), jreTVName) - , genericBounds, new NullToken(), new NullToken()); + return new de.dhbwstuttgart.syntaxtree.GenericTypeVar(jreTVName, genericBounds, new NullToken(), new NullToken()); } public static ClassOrInterface createObjectClass() { diff --git a/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java b/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java index a5d394aa..a14813e7 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java +++ b/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(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java index f630583e..740c80e5 100644 --- a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java @@ -30,7 +30,7 @@ public class SuperWildcardType extends WildcardType{ * Beispiel: ? super Integer. * Integer wird zurückgegeben. */ - public RefTypeOrTPHOrWildcardOrGeneric get_SuperType() + public RefTypeOrTPHOrWildcardOrGeneric getInnerType() { return this.innerType; } diff --git a/src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java b/src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java index c7a06502..0c623548 100644 --- a/src/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java +++ b/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 diff --git a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java b/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java index 29492c31..8834f859 100644 --- a/src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java +++ b/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 diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java b/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java index a04ce9bb..3518c16a 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java +++ b/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 funNParams) { List generics = new ArrayList<>(); for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){ - generics.add(new GenericTypeVar(new GenericTypeName(new GenericContext( - new JavaClassName("Fun"+(funNParams.size()-1)), null), NameGenerator.makeNewName()), + generics.add(new GenericTypeVar(NameGenerator.makeNewName(), new ArrayList<>(), new NullToken(), new NullToken())); } return new GenericDeclarationList(generics, new NullToken()); diff --git a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java b/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java index 066c3246..4656318c 100644 --- a/src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java +++ b/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; diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java index 8ed2343c..8d87218d 100644 --- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java +++ b/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.*; @@ -206,6 +205,7 @@ public class TYPEStmt implements StatementVisitor{ @Override public void visit(BinaryExpr binary) { + if(binary.operation.equals(BinaryExpr.Operator.DIV) || binary.operation.equals(BinaryExpr.Operator.MUL)|| binary.operation.equals(BinaryExpr.Operator.MOD)|| @@ -217,9 +217,12 @@ public class TYPEStmt implements StatementVisitor{ //Expression muss zu Numeric Convertierbar sein. also von Numeric erben numeric.add(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT)); numeric.add(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT)); - //The type of a multiplicative expression is the promoted type of its operands. - numeric.add(new Pair(binary.rexpr.getType(), binary.getType(), PairOperator.SMALLERDOT)); - numeric.add(new Pair(binary.lexpr.getType(), binary.getType(), PairOperator.SMALLERDOT)); + /* + In Java passiert bei den binären Operatoren eine sogenannte Type Promotion: + https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2 + Das bedeutet, dass Java die Typen je nach belieben castet, so lange sie nur von Number erben + */ + numeric.add(new Pair(binary.getType(), number, PairOperator.SMALLERDOT)); numericAdditionOrStringConcatenation.add(numeric); if(binary.operation.equals(BinaryExpr.Operator.ADD)) { //Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2) @@ -339,7 +342,7 @@ public class TYPEStmt implements StatementVisitor{ List 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()); diff --git a/test/asp/ClingoTest.java b/test/asp/ClingoTest.java index d7656d8a..f47b644c 100644 --- a/test/asp/ClingoTest.java +++ b/test/asp/ClingoTest.java @@ -20,7 +20,6 @@ import java.io.*; import java.util.*; public class ClingoTest { - public static final String rootDirectory = "~/Sync/HiwiJob/ResearchPapers/MasterarbeitStadelmeier/asp/unifyWithoutWildcards"; public static final String tempDirectory = "/tmp/"; private final TypePlaceholder testType = TypePlaceholder.fresh(new NullToken()); @Test diff --git a/test/asp/UnifyWithoutWildcards.java b/test/asp/UnifyWithoutWildcards.java index 9e7c867d..db697312 100644 --- a/test/asp/UnifyWithoutWildcards.java +++ b/test/asp/UnifyWithoutWildcards.java @@ -1,29 +1,98 @@ package asp; import de.dhbwstuttgart.parser.NullToken; +import de.dhbwstuttgart.parser.scope.JavaClassName; +import de.dhbwstuttgart.sat.asp.Clingo; +import de.dhbwstuttgart.sat.asp.parser.ASPParser; +import de.dhbwstuttgart.sat.asp.writer.ASPGenerator; import de.dhbwstuttgart.syntaxtree.ClassOrInterface; import de.dhbwstuttgart.syntaxtree.factory.ASTFactory; -import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; +import de.dhbwstuttgart.syntaxtree.type.*; import de.dhbwstuttgart.typeinference.constraints.ConstraintSet; import de.dhbwstuttgart.typeinference.constraints.Pair; +import de.dhbwstuttgart.typeinference.result.ResultSet; import de.dhbwstuttgart.typeinference.unify.model.PairOperator; +import org.junit.Test; -import java.util.Collection; -import java.util.HashSet; -import java.util.Set; +import java.io.File; +import java.io.IOException; +import java.io.PrintWriter; +import java.sql.Ref; +import java.util.*; public class UnifyWithoutWildcards { - public Collection getFC() { - Set ret = new HashSet<>(); - ret.add(ASTFactory.createObjectClass()); - ret.add(ASTFactory.createClass(java.util.List.class)); + public static final String tempDirectory = "/tmp/"; + + @Test + public void adapt() throws InterruptedException, IOException, ClassNotFoundException { + ConstraintSet testSet = new ConstraintSet<>(); + List list = Arrays.asList(TypePlaceholder.fresh(new NullToken())); + RefType t1 = new RefType(new JavaClassName("Matrix"), new NullToken()); + RefType t2 = new RefType(new JavaClassName("Vector"), list, new NullToken()); + testSet.addUndConstraint(new Pair(t1, t2, PairOperator.SMALLERDOT)); + run(testSet); + } + + public ResultSet run(ConstraintSet toTest) throws IOException, InterruptedException, ClassNotFoundException { + String content = ""; + content = new ASPGenerator(toTest, this.getFC()).getASP(); + + PrintWriter writer = new PrintWriter(tempDirectory + "test.lp", "UTF-8"); + writer.println(content); + writer.close(); + Clingo clingo = new Clingo(Arrays.asList(new File(tempDirectory + "test.lp"))); + String result = clingo.runClingo(); + ResultSet resultSet = ASPParser.parse(result, getInvolvedTPHS(toTest)); + return resultSet; + } + + private static class TPHExtractor implements TypeVisitor>{ + @Override + public List visit(RefType refType) { + ArrayList ret = new ArrayList<>(); + for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){ + ret.addAll(param.acceptTV(this)); + } + return ret; + } + + @Override + public List visit(SuperWildcardType superWildcardType) { + return superWildcardType.getInnerType().acceptTV(this); + } + + @Override + public List visit(TypePlaceholder typePlaceholder) { + return Arrays.asList(typePlaceholder); + } + + @Override + public List visit(ExtendsWildcardType extendsWildcardType) { + return extendsWildcardType.getInnerType().acceptTV(this); + } + + @Override + public List visit(GenericRefType genericRefType) { + return new ArrayList<>(); + } + } + private Collection getInvolvedTPHS(ConstraintSet toTest) { + List ret = new ArrayList<>(); + toTest.map((Pair p)-> { + ret.addAll(p.TA1.acceptTV(new TPHExtractor())); + ret.addAll(p.TA2.acceptTV(new TPHExtractor())); + return p; + }); return ret; } - public ConstraintSet getPairs() { - ConstraintSet ret = new ConstraintSet<>(); - ret.addUndConstraint(new Pair(TypePlaceholder.fresh(new NullToken()), ASTFactory.createObjectType(), PairOperator.SMALLERDOT)); + private Collection getFC() { + Set ret = new HashSet<>(); + ret.add(ASTFactory.createClass(Matrix.class)); + //ret.add(ASTFactory.createObjectClass()); + //ret.add(ASTFactory.createClass(java.util.List.class)); return ret; } + private class Matrix extends HashMap>{} } diff --git a/test/javFiles/AddLong.jav b/test/javFiles/AddLong.jav new file mode 100644 index 00000000..ceb31228 --- /dev/null +++ b/test/javFiles/AddLong.jav @@ -0,0 +1,9 @@ +import java.lang.Integer; +import java.lang.Long; + +public class AddLong{ + add(Integer a, Long b) { + Long c = a+b; + return c; + } +} \ No newline at end of file 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 diff --git a/test/typeinference/JavaTXCompilerTest.java b/test/typeinference/JavaTXCompilerTest.java index 1cfe65a6..ddf172b5 100644 --- a/test/typeinference/JavaTXCompilerTest.java +++ b/test/typeinference/JavaTXCompilerTest.java @@ -72,6 +72,10 @@ public class JavaTXCompilerTest { public void expressions() throws IOException, ClassNotFoundException { execute(new File(rootDirectory+"Expressions.jav")); } + @Test + public void addLong() throws IOException, ClassNotFoundException { + execute(new File(rootDirectory+"AddLong.jav")); + } private static class TestResultSet{