diff --git a/pom.xml b/pom.xml index 3c31a7e8..b90b76e2 100644 --- a/pom.xml +++ b/pom.xml @@ -55,6 +55,14 @@ http://maven.apache.org/maven-v4_0_0.xsd"> ${project.artifactId}-${project.version} target/test-classes + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0-M3 + + true + + org.antlr antlr4-maven-plugin @@ -138,10 +146,6 @@ http://maven.apache.org/maven-v4_0_0.xsd"> - @@ -169,5 +173,3 @@ http://maven.apache.org/maven-v4_0_0.xsd"> - - diff --git a/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGen.java b/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGen.java index 0dea801d..fec01c10 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGen.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGen.java @@ -147,23 +147,7 @@ public class BytecodeGen implements ASTVisitor { if(!tphExtractor.allTPHS.get(t)) tphsClass.add(t); } - - ArrayList consClass = new ArrayList<>(); - for(TPHConstraint cons : tphExtractor.allCons) { - TypePlaceholder right = null; - for(TypePlaceholder tph : tphsClass) { - if(cons.getLeft().equals(tph.getName())) { - - consClass.add(cons); - right = getTPH(cons.getRight()); - } - } - if(right != null) { - tphsClass.add(right); - removeFromMethod(right.getName()); - right = null; - } - } + String sig = null; /* if class has generics then creates signature * Signature looks like: @@ -172,6 +156,23 @@ public class BytecodeGen implements ASTVisitor { if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<") || !tphsClass.isEmpty()) { + HashMap> constraints = Simplify.simplifyConstraintsClass(tphExtractor,tphsClass); + ArrayList consClass = new ArrayList<>(); + for(TPHConstraint cons : constraints.keySet()) { + TypePlaceholder right = null; + for(TypePlaceholder tph : tphsClass) { + if(cons.getLeft().equals(tph.getName())) { + + consClass.add(cons); + right = getTPH(cons.getRight()); + } + } + if(right != null) { + tphsClass.add(right); + removeFromMethod(right.getName()); + right = null; + } + } Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs,tphsClass, consClass); sig = signature.toString(); System.out.println("Signature: => " + sig); diff --git a/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java b/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java index ff2c49a3..b1ea614f 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java @@ -140,7 +140,8 @@ public class BytecodeGenMethod implements StatementVisitor { } public BytecodeGenMethod(LambdaExpression lambdaExpression, ArrayList usedVars, ResultSet resultSet, MethodVisitor mv, - int indexOfFirstParamLam, boolean isInterface, HashMap classFiles, String path, int lamCounter, SourceFile sf) { + int indexOfFirstParamLam, boolean isInterface, HashMap classFiles, String path, int lamCounter, SourceFile sf,HashMap genericsAndBoundsMethod, + HashMap genericsAndBounds) { this.resultSet = resultSet; this.mv = mv; @@ -149,6 +150,9 @@ public class BytecodeGenMethod implements StatementVisitor { this.path = path; this.lamCounter = lamCounter; this.sf = sf; + this.genericsAndBoundsMethod = genericsAndBoundsMethod; + this.genericsAndBounds = genericsAndBounds; + Iterator itr = lambdaExpression.params.iterator(); int i = indexOfFirstParamLam; @@ -644,7 +648,8 @@ public class BytecodeGenMethod implements StatementVisitor { ArrayList usedVars = kindOfLambda.getUsedVars(); new BytecodeGenMethod(lambdaExpression, usedVars,this.resultSet, mvLambdaBody, indexOfFirstParamLam, isInterface, - classFiles,this.path, lamCounter, sf); + classFiles,this.path, lamCounter, sf, genericsAndBoundsMethod, + genericsAndBounds); mvLambdaBody.visitMaxs(0, 0); mvLambdaBody.visitEnd(); @@ -744,6 +749,13 @@ public class BytecodeGenMethod implements StatementVisitor { statement = new IfStatement(ifStmt.expr, ifStmt.then_block, ifStmt.else_block); isBinaryExp = statement.isExprBinary(); ifStmt.expr.accept(this); + if(!(ifStmt.expr instanceof BinaryExpr)) { + doUnboxing(getResolvedType(ifStmt.expr.getType())); + Label branchLabel = new Label(); + Label endLabel = new Label(); + mv.visitJumpInsn(Opcodes.IFEQ, branchLabel); + statement.genBCForRelOp(mv, branchLabel, endLabel, this); + } statement = null; } @@ -758,86 +770,90 @@ public class BytecodeGenMethod implements StatementVisitor { System.out.println("In MethodCall = " + methodCall.name); String receiverName = getResolvedType(methodCall.receiver.getType()); System.out.println("Methods of " + receiverName + " "); - ClassLoader cLoader = ClassLoader.getSystemClassLoader(); - // This will be used if the class is not standard class (not in API) - ClassLoader cLoader2; java.lang.reflect.Method methodRefl = null; String clazz = receiverName.replace("/", "."); - String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()); - String[] typesOfParams = getTypes(methodCall.arglist.getArguments()); - try { - if(receiverName.contains("<")) { - clazz = clazz.substring(0, receiverName.indexOf("<")); - } +// if(!receiverName.equals(className)) { + ClassLoader cLoader = ClassLoader.getSystemClassLoader(); + // This will be used if the class is not standard class (not in API) + ClassLoader cLoader2; - java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods(); - System.out.println("Methods of " + receiverName + " "); - methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methods); - - } catch (Exception e) { -// try { -// cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)}); -// java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods(); -// System.out.println("Methods of " + receiverName + " "); -// for(int i = 0; i Refl != null"); receiverRefl = methodRefl.getAnnotatedReceiverType().getType().toString(); for(Parameter p:methodRefl.getParameters()) { System.out.println(p.getName() + " und is Primitive = " + p.getType().isPrimitive()); @@ -865,7 +882,7 @@ public class BytecodeGenMethod implements StatementVisitor { } } - System.out.println("Methodcall Desc : " + mDesc); + System.out.println("Methodcall ("+ methodCall.name +") Desc : " + mDesc); // methodCall.arglist.accept(this); @@ -1197,6 +1214,7 @@ public class BytecodeGenMethod implements StatementVisitor { break; case "java/lang/Boolean": + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false); break; case "java/lang/Byte": mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false); diff --git a/src/main/java/de/dhbwstuttgart/bytecode/TPHExtractor.java b/src/main/java/de/dhbwstuttgart/bytecode/TPHExtractor.java index d9a95311..c100eb4a 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/TPHExtractor.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/TPHExtractor.java @@ -5,13 +5,19 @@ package de.dhbwstuttgart.bytecode; import java.util.ArrayList; import java.util.HashMap; +import java.util.Iterator; import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint; import de.dhbwstuttgart.bytecode.constraint.TPHConstraint; import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation; import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH; import de.dhbwstuttgart.syntaxtree.AbstractASTWalker; +import de.dhbwstuttgart.syntaxtree.Constructor; +import de.dhbwstuttgart.syntaxtree.FormalParameter; import de.dhbwstuttgart.syntaxtree.Method; +import de.dhbwstuttgart.syntaxtree.ParameterList; +import de.dhbwstuttgart.syntaxtree.statement.LocalVar; +import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.result.GenericInsertPair; import de.dhbwstuttgart.typeinference.result.ResultSet; @@ -20,36 +26,42 @@ import de.dhbwstuttgart.typeinference.result.ResultSet; * @author Fayez Abu Alia * */ -public class TPHExtractor extends AbstractASTWalker{ +public class TPHExtractor extends AbstractASTWalker { // Alle TPHs der Felder werden iKopf der Klasse definiert // alle TPHs der Klasse: (TPH, is in Method?) - final HashMap allTPHS = new HashMap<>(); + final HashMap allTPHS = new HashMap<>(); MethodAndTPH methodAndTph; + Boolean inMethod = false; + boolean inLocalOrParam = false; + public final ArrayList ListOfMethodsAndTph = new ArrayList<>(); final ArrayList allPairs = new ArrayList<>(); public final ArrayList allCons = new ArrayList<>(); private ResultSet resultSet; - + public TPHExtractor() { - + } - + public void setResultSet(ResultSet resultSet) { this.resultSet = resultSet; } - + @Override public void visit(TypePlaceholder tph) { - if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) { + if (resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) { TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType; - if(inMethod) + if (inMethod) { methodAndTph.getTphs().add(resolvedTPH.getName()); - - allTPHS.put(resolvedTPH,inMethod); - resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{ - if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) { - if(inMethod) + if (inLocalOrParam) + methodAndTph.getLocalTphs().add(resolvedTPH.getName()); + } + + allTPHS.put(resolvedTPH, inMethod); + resultSet.resolveType(tph).additionalGenerics.forEach(ag -> { + if (ag.contains(resolvedTPH) && ag.TA1.equals(resolvedTPH) && !contains(allPairs, ag)) { + if (inMethod) methodAndTph.getPairs().add(ag); allPairs.add(ag); TPHConstraint con = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS); @@ -58,14 +70,16 @@ public class TPHExtractor extends AbstractASTWalker{ }); } } + private boolean contains(ArrayList pairs, GenericInsertPair genPair) { - for(int i=0; i allConstaints; + + public ConstraintsFinder(List allConstaints) { + super(); + this.allConstaints = allConstaints; + } + + public List> findConstraints() { + List> result = new ArrayList<>(); + + List visitedCons = new ArrayList<>(); + for(TPHConstraint c : allConstaints) { + if(c.getRel() == Relation.EXTENDS) { + // get constraints with the same left side + List cons = getConstraints(c,visitedCons); + if(cons.size()>1) + result.add(cons); + } + } + + return result; + } + + private List getConstraints(TPHConstraint c, List visitedCons) { + List res = new ArrayList<>(); + for(TPHConstraint cons : allConstaints) { + if(!isVisited(cons,visitedCons) && cons.getLeft().equals(c.getLeft())) { + res.add(cons); + visitedCons.add(cons); + } + } + return res; + } + + private boolean isVisited(TPHConstraint cons, List visitedCons) { + for(TPHConstraint c : visitedCons) { + if(c.getLeft().equals(cons.getLeft()) && c.getRight().equals(cons.getRight())) + return true; + } + return false; + } +} diff --git a/src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java b/src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java index 7175f108..e21f974c 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java @@ -10,6 +10,8 @@ public class MethodAndTPH { private String name; private final ArrayList tphs = new ArrayList<>(); private final ArrayList pairs = new ArrayList<>(); + // tphs of local variables and parameters + private final ArrayList localTphs = new ArrayList<>(); public MethodAndTPH(String name) { this.name = name; @@ -26,4 +28,9 @@ public class MethodAndTPH { public String getName() { return name; } + + public ArrayList getLocalTphs() { + return localTphs; + } + } diff --git a/src/main/java/de/dhbwstuttgart/bytecode/utilities/NameReplacer.java b/src/main/java/de/dhbwstuttgart/bytecode/utilities/NameReplacer.java new file mode 100644 index 00000000..bc3c1b98 --- /dev/null +++ b/src/main/java/de/dhbwstuttgart/bytecode/utilities/NameReplacer.java @@ -0,0 +1,49 @@ +package de.dhbwstuttgart.bytecode.utilities; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import de.dhbwstuttgart.bytecode.constraint.TPHConstraint; +import de.dhbwstuttgart.syntaxtree.factory.NameGenerator; + +public class NameReplacer { + private List constraints; + private List allConstraints; + private List tphs; + private List localTphs; + + public NameReplacer(List constraints, List allConstraints,List tphs, ArrayList localTphs) { + super(); + this.constraints = constraints; + this.allConstraints = allConstraints; + this.tphs = tphs; + this.localTphs = localTphs; + } + + public Map> replaceNames() { + String newName = NameGenerator.makeNewName(); + ArrayList names = new ArrayList<>(); + for(TPHConstraint cons : constraints) { + names.add(cons.getRight()); + cons.setRight(newName); + } + + for(TPHConstraint cons : allConstraints) { + if(names.contains(cons.getLeft())) + cons.setLeft(newName); + if(names.contains(cons.getRight())) + cons.setRight(newName); + } + + tphs.removeAll(names); + tphs.add(newName); + localTphs.removeAll(names); + localTphs.add(newName); + + HashMap> res = new HashMap<>(); + res.put(newName, names); + return res; + } +} diff --git a/src/main/java/de/dhbwstuttgart/bytecode/utilities/Simplify.java b/src/main/java/de/dhbwstuttgart/bytecode/utilities/Simplify.java index d19d38dc..89b55efb 100644 --- a/src/main/java/de/dhbwstuttgart/bytecode/utilities/Simplify.java +++ b/src/main/java/de/dhbwstuttgart/bytecode/utilities/Simplify.java @@ -4,6 +4,8 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; +import java.util.List; +import java.util.Map; import org.objectweb.asm.Type; @@ -15,125 +17,145 @@ import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; public class Simplify { - - public static HashMap> simplifyConstraints(String name, TPHExtractor tphExtractor, ArrayList tphsClass) { + + public static HashMap> simplifyConstraints(String name, TPHExtractor tphExtractor, + ArrayList tphsClass) { // 1. check if there are any simple cycles like L set L=R and: - // * remove both constraints - // * substitute L with R in all constraint - // b)no => go to next step - // 2. check the result of step 1 if there are any equal-constraints like L=R, M=R .. - // a) yes => put all such TPhs in a map and define "key-Cons" - // -- key-Cons = TPH < Object -- - // put this Constraint and the - // b) no + // a) yes => set L=R and: + // * remove both constraints + // * substitute L with R in all constraint + // b)no => go to next step + // 2. check the result of step 1 if there are any equal-constraints like L=R, + // M=R .. + // a) yes => put all such TPhs in a map and define "key-Cons" + // -- key-Cons = TPH < Object -- + // put this Constraint and the + // b) no // 3. is - + // all constraints that will be simplified - ArrayList allCons = tphExtractor.allCons; +// ArrayList allCons = tphExtractor.allCons; + ArrayList allCons = new ArrayList<>(); + + for(TPHConstraint c : tphExtractor.allCons) { + TPHConstraint nc = new TPHConstraint(c.getLeft(), c.getRight(), c.getRel()); + allCons.add(nc); + } ArrayList consToRemove = new ArrayList<>(); - + + // get all tph of the method + ArrayList methodTphs = new ArrayList<>(); + ArrayList localTphs = new ArrayList<>(); + for (MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) { + if (m.getName().equals(name)) { + methodTphs = m.getTphs(); + localTphs = m.getLocalTphs(); + break; + } + } + // step 1: - for(TPHConstraint c : allCons) { - + for (TPHConstraint c : allCons) { + String left = c.getLeft(); String right = c.getRight(); - if(c.getRel() == Relation.EXTENDS) { - TPHConstraint revCon = getReverseConstraint(allCons,left,right); - if(revCon != null) { + if (c.getRel() == Relation.EXTENDS) { + TPHConstraint revCon = getReverseConstraint(allCons, left, right); + if (revCon != null) { revCon.setRel(Relation.EQUAL); - // the reverse constraint is removed because - // otherwise there is the same constraint twice - // (e.g. A A=B and B=A) + // the reverse constraint is removed because + // otherwise there is the same constraint twice + // (e.g. A A=B and B=A) consToRemove.add(revCon); c.setRel(Relation.EQUAL); - substituteTPH(allCons,left, right); + substituteTPH(allCons, left, right); } } } - + System.out.println(); System.out.println("NEW ALL CONST: " + allCons.size()); - allCons.forEach(c->System.out.println(c.toString())); + allCons.forEach(c -> System.out.println(c.toString())); System.out.println("----------------"); allCons.removeAll(consToRemove); consToRemove = new ArrayList<>(); - + int size = allCons.size(); - + System.out.println("AFTER DELETE ALL CONST: " + allCons.size()); - allCons.forEach(c->System.out.println(c.toString())); + allCons.forEach(c -> System.out.println(c.toString())); System.out.println("----------------"); HashMap> result = new HashMap<>(); - + // check if there is any long cycle (e.g. A allTypes = new LinkedList<>(); // we will put all constraints which are in the cycle, in this ArrayList. // Later these contraints will be converted to equal-constraints ArrayList constraints = new ArrayList<>(size); int visited = 0; - + // contains all constraints - HashMap ss1 = new HashMap<>(); - - for(TPHConstraint constr : allCons) { + HashMap ss1 = new HashMap<>(); + + for (TPHConstraint constr : allCons) { ss1.put(constr.getLeft(), constr.getRight()); } - - for(TPHConstraint c : allCons) { - - if(visited >= size) + + for (TPHConstraint c : allCons) { + + if (visited >= size) break; // Only extends-constraints will be checked - if(c.getRel() == Relation.EXTENDS) { + if (c.getRel() == Relation.EXTENDS) { ++visited; - + String left = c.getLeft(); String right = c.getRight(); // put the types in linked list allTypes.add(left); allTypes.add(right); - + constraints.add(c); - + boolean isCycle = false; - + // iterate through the map to check if there is a cycle - while(ss1.containsKey(right)) { + while (ss1.containsKey(right)) { ++visited; String oldRight = right; right = ss1.get(right); - + TPHConstraint toAdd = getConstraint(oldRight, right, allCons); - - if(toAdd != null) + + if (toAdd != null) constraints.add(toAdd); - - if(left.equals(right)) { + + if (left.equals(right)) { isCycle = true; break; } - + allTypes.add(right); } - - if(isCycle) { + + if (isCycle) { // convert all constraints to equal constraints setAllEqual(constraints); // these constraints will be removed from allCons consToRemove.addAll(constraints); // all equal types will be substitute with one type - substituteAllTPH(allCons,constraints,left); - + substituteAllTPH(allCons, constraints, left); + HashSet eq = new HashSet<>(); // put all equal types in a set - for(String t:allTypes) { + for (String t : allTypes) { eq.add(t); } // generate a new constraint (left < Object) - TPHConstraint constraint = new ExtendsConstraint(left, Type.getInternalName(Object.class), Relation.EXTENDS); + TPHConstraint constraint = new ExtendsConstraint(left, Type.getInternalName(Object.class), + Relation.EXTENDS); // put the generated constraint and its equal set into result set result.put(constraint, eq); constraints.clear(); @@ -141,15 +163,260 @@ public class Simplify { allTypes.clear(); } } + + for (TPHConstraint ec : allCons) { + + if(ec.getRel() == Relation.EQUAL) { + if(!localTphs.contains(ec.getRight())) { + localTphs.add(ec.getRight()); + } + if(!methodTphs.contains(ec.getRight())) { + methodTphs.add(ec.getRight()); + } + + } + } // build an equal set that contains all types - // which are equal and for each equal constraint put left side and right side + // which are equal and for each equal constraint put left side and right side // in this set Then generate a constraint type < Object and put it // with the equal set into the result. - for(TPHConstraint c : allCons) { - if(c.getRel()==Relation.EQUAL) { - if(!isTPHInResEqual(result, c.getLeft())) { +// for(TPHConstraint c : allCons) { +// if(c.getRel()==Relation.EQUAL) { +// if(!isTPHInResEqual(result, c.getLeft())) { +// HashSet equalTPHs = getEqualsTPHs(result, c); +// TPHConstraint constraint = getKeyConstraint(result,c); +// equalTPHs.add(c.getLeft()); +// equalTPHs.add(c.getRight()); +// result.put(constraint, equalTPHs); +// } +// consToRemove.add(c); +// size--; +// } +// } + + System.out.println("Step 2 Result: "); + result.forEach((c, hs) -> { + System.out.print(c.toString() + " -> "); + hs.forEach(s -> { + System.out.print(s + ", "); + }); + System.out.println(); + }); + System.out.println("----------------"); + + if (!allCons.isEmpty() && allCons.size() < 2) { + TPHConstraint cons = allCons.get(0); + if (!result.containsKey(cons)) { + result.put(cons, null); + if (!cons.getRight().equals(Type.getInternalName(Object.class))) + result.put(new ExtendsConstraint(cons.getRight(), Type.getInternalName(Object.class), + Relation.EXTENDS), null); + } + + return result; + } + + size += result.keySet().size(); + // all constraints which have Object on the right side will + // be ignored, because they are simplified and can not be changed. + for (TPHConstraint c : allCons) { + if (c.getRight().equals(Type.getInternalName(Object.class))) + size--; + } + + // finder looks for constraints that have the same left hand side + // and put them in a list + ConstraintsFinder finder = new ConstraintsFinder(allCons); + List> foundCons = finder.findConstraints(); + + ArrayList eqCons = new ArrayList<>(); + + for (List list : foundCons) { + // generate a new name and replace the right hand side for each constraint + // in list with the new name + NameReplacer replacer = new NameReplacer(list, allCons, methodTphs, localTphs); + // new name -> [all old names] + Map> replRes = replacer.replaceNames(); + // create an equal constraint for each value in repres + String key = replRes.keySet().iterator().next(); + for (String val : replRes.values().iterator().next()) { + EqualConstraint ec = new EqualConstraint(val, key, Relation.EQUAL); + eqCons.add(ec); + } + for (TPHConstraint c : allCons) { + if (c.getRel() == Relation.EQUAL && key.equals(c.getRight())) { + eqCons.add(c); + } + } + updateEqualCons(replRes, eqCons); + + TPHConstraint c = list.get(0); + allCons.removeAll(list); + allCons.add(c); + } + + // check if there are multiple constraint with the same left side. + // if yes => check if the super type in the method, if not + // then ignore it. +// HashMap subAndSuper = new HashMap<>(); +// ArrayList eqCons = new ArrayList<>(); +// for(TPHConstraint c : allCons) { +// if(subAndSuper.containsKey(c.getLeft())) { +// LinkedList all = new LinkedList<>(); +// all.add(c.getLeft()); +// String sup =c.getRight(); +// all.add(sup); +// HashMap ss = new HashMap<>(); +// for(TPHConstraint constr : allCons) { +// ss.put(constr.getLeft(), constr.getRight()); +// } +// while(ss.containsKey(sup)) { +// sup = ss.get(sup); +// all.add(sup); +// } +// if(!containTPH(methodTphs, all.getLast())) +// continue; +// } +// if(subAndSuper.containsKey(c.getLeft())) { +// System.out.println(c.getLeft()); +// String r = c.getRight(); +// String r2 = subAndSuper.get(c.getLeft()); +// EqualConstraint eq = new EqualConstraint(r2, r, Relation.EQUAL); +// eqCons.add(eq); +// substituteInMap(subAndSuper,eqCons,allCons,r,r2); +// } +// subAndSuper.put(c.getLeft(), c.getRight()); +// } +// +// System.out.println("SAME LEFT SIDE: "); +// subAndSuper.forEach((c,hs)->{ +// if(c!=null) { +// System.out.print(c+ " -> " + hs); +// +// } +// +// +// System.out.println(); +// }); +// System.out.println("----------------"); + HashMap subAndSuper = new HashMap<>(); + + for (TPHConstraint c : allCons) { + if (c.getRel() == Relation.EXTENDS) + subAndSuper.put(c.getLeft(), c.getRight()); + } + + for (TPHConstraint ec : allCons) { + if(ec.getRel() == Relation.EQUAL) { + methodTphs.remove(ec.getLeft()); + localTphs.remove(ec.getLeft()); + if(!localTphs.contains(ec.getRight())) { + localTphs.add(ec.getRight()); + } + if(!methodTphs.contains(ec.getRight())) { + methodTphs.add(ec.getRight()); + } + } + + } + + int numOfVisitedPairs = 0; + for (String sub : subAndSuper.keySet()) { + if (isTPHInConstraint(result, sub)) + continue; + + if (!containTPH(methodTphs, sub)) + continue; + + if (numOfVisitedPairs >= size) + break; + LinkedList tphInRel = new LinkedList<>(); + tphInRel.add(sub); + String superT = subAndSuper.get(sub); + tphInRel.add(superT); + + numOfVisitedPairs++; + while (!localTphs.contains(superT) && subAndSuper.containsKey(superT)) { + superT = subAndSuper.get(superT); + if (tphInRel.contains(superT)) { + break; + } + tphInRel.add(superT); + numOfVisitedPairs++; + } + + // Subtype + String subTphRes = tphInRel.getFirst(); + // Die größte Supertype + String superTphRes = tphInRel.getLast(); + + // if there is any constraint X < subTph, then + // add X at the beginning of the list. + while (!localTphs.contains(subTphRes) && subAndSuper.containsValue(subTphRes)) { + for (String tph : subAndSuper.keySet()) { + if (containTPH(methodTphs, tph) && subAndSuper.get(tph).equals(subTphRes)) { + subTphRes = tph; + break; + } + } + if (subTphRes.equals(tphInRel.getFirst())) { + break; + } + + if (isTPHInConstraint(result, subTphRes)) + break; + + tphInRel.addFirst(subTphRes); + numOfVisitedPairs++; + } + + subTphRes = tphInRel.getFirst(); + // if the last type in the list not a type in method-types + // then find the last type in front of this type, which is + // a type in method-types + int i = 2; + while (!containTPH(methodTphs, superTphRes) && (tphInRel.size() - i) > 0) { + superTphRes = tphInRel.get(tphInRel.size() - i); + i++; + } + + if (!containTPH(methodTphs, superTphRes)) { + HashSet equals = getEqualsTphsFromEqualCons(eqCons, superTphRes); + if (classTPHSContainsTPH(tphsClass, superTphRes)) { + result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals); + } else { + result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), + equals); + } + + } else { + HashSet equals = getEqualsTphsFromEqualCons(eqCons, subTphRes); + result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals); + if (!isTPHInConstraint(result, superTphRes) && !isTphInEqualSet(result, superTphRes)) { + HashSet equals2 = getEqualsTphsFromEqualCons(eqCons, superTphRes); + result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), + equals2); + } + } + } + +// for(String tph : methodTphs) { + for (String tph : localTphs) { + if (!isTPHInConstraint(result, tph) && !isTphInEqualSet(result, tph)) { + HashSet equals = getEqualsTphsFromEqualCons(eqCons, tph); + result.put(new ExtendsConstraint(tph, Type.getInternalName(Object.class), Relation.EXTENDS), equals); + } + } + + // build an equal set that contains all types + // which are equal and for each equal constraint put left side and right side + // in this set Then generate a constraint type < Object and put it + // with the equal set into the result. + for (TPHConstraint c : allCons) { + if (c.getRel() == Relation.EQUAL) { + if (!isTPHInResEqual(result, c.getLeft())) { HashSet equalTPHs = getEqualsTPHs(result, c); - TPHConstraint constraint = getKeyConstraint(result,c); + TPHConstraint constraint = getKeyConstraint(result, c); equalTPHs.add(c.getLeft()); equalTPHs.add(c.getRight()); result.put(constraint, equalTPHs); @@ -158,206 +425,290 @@ public class Simplify { size--; } } - - System.out.println("Step 2 Result: "); - result.forEach((c,hs)->{ - System.out.print(c.toString() + " -> "); - hs.forEach(s->{ - System.out.print(s + ", "); - }); - System.out.println(); - }); - System.out.println("----------------"); + // remove all equal-constraints allCons.removeAll(consToRemove); - // add all generated constraints to allCons + // add all generated constraints to allCons allCons.addAll(result.keySet()); - - if(!allCons.isEmpty() && allCons.size()<2) { - TPHConstraint cons = allCons.get(0); - if(!result.containsKey(cons)) { - result.put(cons, null); - result.put(new ExtendsConstraint(cons.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS), null); - } - - return result; - } - - size += result.keySet().size(); - // all constraints which have Object on the right side will - // be ignored, because they are simplified and can not be changed. - for(TPHConstraint c : allCons) { - if(c.getRight().equals(Type.getInternalName(Object.class))) - size--; - } - // get all tph of the method - ArrayList methodTphs = new ArrayList<>(); - for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) { - if(m.getName().equals(name)) { - methodTphs = m.getTphs(); - break; - } - } - // check if there are multiple constraint with the same left side. - // if yes => check if the super type in the method, if not - // then ignore it. - HashMap subAndSuper = new HashMap<>(); - ArrayList eqCons = new ArrayList<>(); - for(TPHConstraint c : allCons) { - if(subAndSuper.containsKey(c.getLeft())) { - LinkedList all = new LinkedList<>(); - all.add(c.getLeft()); - String sup =c.getRight(); - all.add(sup); - HashMap ss = new HashMap<>(); - for(TPHConstraint constr : allCons) { - ss.put(constr.getLeft(), constr.getRight()); - } - while(ss.containsKey(sup)) { - sup = ss.get(sup); - all.add(sup); - } - if(!containTPH(methodTphs, all.getLast())) - continue; - } - if(subAndSuper.containsKey(c.getLeft())) { - System.out.println(c.getLeft()); - String r = c.getRight(); - String r2 = subAndSuper.get(c.getLeft()); - EqualConstraint eq = new EqualConstraint(r2, r, Relation.EQUAL); - eqCons.add(eq); - substituteInMap(subAndSuper,eqCons,allCons,r,r2); - } - subAndSuper.put(c.getLeft(), c.getRight()); - } - - System.out.println("SAME LEFT SIDE: "); - subAndSuper.forEach((c,hs)->{ - if(c!=null) { - System.out.print(c+ " -> " + hs); - - } - - - System.out.println(); - }); - System.out.println("----------------"); - int numOfVisitedPairs = 0; - for(String sub : subAndSuper.keySet()) { - if(isTPHInConstraint(result,sub)) - continue; - - if(!containTPH(methodTphs,sub)) - continue; - - if(numOfVisitedPairs>=size) - break; - LinkedList tphInRel = new LinkedList<>(); - tphInRel.add(sub); - String superT = subAndSuper.get(sub); - tphInRel.add(superT); - - numOfVisitedPairs++; - while(subAndSuper.containsKey(superT)) { - superT = subAndSuper.get(superT); - if(tphInRel.contains(superT)) { - break; - } - tphInRel.add(superT); - numOfVisitedPairs++; - } - - // Subtype - String subTphRes = tphInRel.getFirst(); - // Die größte Supertype - String superTphRes = tphInRel.getLast(); - - // if there is any constraint X < subTph, then - // add X at the beginning of the list. - while(subAndSuper.containsValue(subTphRes)) { - for(String tph : subAndSuper.keySet()) { - if(containTPH(methodTphs,tph) && subAndSuper.get(tph).equals(subTphRes)) { - subTphRes = tph; - break; - } - } - if(subTphRes.equals(tphInRel.getFirst())) { - break; - } - - if(isTPHInConstraint(result, subTphRes)) - break; - - tphInRel.addFirst(subTphRes); - numOfVisitedPairs++; - } - - subTphRes = tphInRel.getFirst(); - // if the last type in the list not a type in method-types - // then find the last type in front of this type, which is - // a type in method-types - int i = 2; - while(!containTPH(methodTphs,superTphRes) && (tphInRel.size()-i) >0) { - superTphRes = tphInRel.get(tphInRel.size()-i); - i++; - } - - if(!containTPH(methodTphs, superTphRes)) { - HashSet equals = getEqualsTphsFromEqualCons(eqCons,superTphRes); - if(classTPHSContainsTPH(tphsClass,superTphRes)) { - result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals); - } else { - result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), equals); - } - - } else { - HashSet equals = getEqualsTphsFromEqualCons(eqCons,subTphRes); - result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals); - if(!isTPHInConstraint(result, superTphRes) && !isTphInEqualSet(result,superTphRes)) { - HashSet equals2 = getEqualsTphsFromEqualCons(eqCons,superTphRes); - result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), equals2); - } - } - } - - for(String tph : methodTphs) { - if(!isTPHInConstraint(result, tph) && !isTphInEqualSet(result,tph)) { - HashSet equals = getEqualsTphsFromEqualCons(eqCons,tph); - result.put(new ExtendsConstraint(tph, Type.getInternalName(Object.class), Relation.EXTENDS), equals); - } - } - + System.out.println("EndResult: "); - result.forEach((c,hs)->{ - if(c!=null) { + result.forEach((c, hs) -> { + if (c != null) { System.out.print(c.toString() + " -> "); - if(hs == null) { + if (hs == null) { System.out.print(" [] "); - }else { - hs.forEach(s->{ + } else { + hs.forEach(s -> { System.out.print(s + ", "); }); } } - - + System.out.println(); }); System.out.println("----------------"); return result; } - + + private static void updateEqualCons(Map> replRes, ArrayList eqCons) { + List oldNames = replRes.values().iterator().next(); + String newName = replRes.keySet().iterator().next(); + for (TPHConstraint c : eqCons) { +// if(oldNames.contains(c.getLeft())) +// c.setLeft(newName); + if (oldNames.contains(c.getRight())) + c.setRight(newName); + } + + } + + public static HashMap> simplifyConstraintsClass(TPHExtractor tphExtractor, + ArrayList tphsClass) { + // all constraints that will be simplified + ArrayList allCons = tphExtractor.allCons; + ArrayList consToRemove = new ArrayList<>(); + + // step 1: + for (TPHConstraint c : allCons) { + + String left = c.getLeft(); + String right = c.getRight(); + if (c.getRel() == Relation.EXTENDS) { + TPHConstraint revCon = getReverseConstraint(allCons, left, right); + if (revCon != null) { + revCon.setRel(Relation.EQUAL); + // the reverse constraint is removed because + // otherwise there is the same constraint twice + // (e.g. A A=B and B=A) + consToRemove.add(revCon); + c.setRel(Relation.EQUAL); + substituteTPH(allCons, left, right); + } + } + } + + allCons.removeAll(consToRemove); + consToRemove = new ArrayList<>(); + + int size = allCons.size(); + + HashMap> result = new HashMap<>(); + + // check if there is any long cycle (e.g. A allTypes = new LinkedList<>(); + // we will put all constraints which are in the cycle, in this ArrayList. + // Later these contraints will be converted to equal-constraints + ArrayList constraints = new ArrayList<>(size); + int visited = 0; + + // contains all constraints + HashMap ss1 = new HashMap<>(); + + for (TPHConstraint constr : allCons) { + ss1.put(constr.getLeft(), constr.getRight()); + } + + for (TPHConstraint c : allCons) { + + if (visited >= size) + break; + // Only extends-constraints will be checked + if (c.getRel() == Relation.EXTENDS) { + ++visited; + + String left = c.getLeft(); + String right = c.getRight(); + // put the types in linked list + allTypes.add(left); + allTypes.add(right); + + constraints.add(c); + + boolean isCycle = false; + + // iterate through the map to check if there is a cycle + while (ss1.containsKey(right)) { + ++visited; + String oldRight = right; + right = ss1.get(right); + + TPHConstraint toAdd = getConstraint(oldRight, right, allCons); + + if (toAdd != null) + constraints.add(toAdd); + + if (left.equals(right)) { + isCycle = true; + break; + } + + allTypes.add(right); + } + + if (isCycle) { + // convert all constraints to equal constraints + setAllEqual(constraints); + // these constraints will be removed from allCons + consToRemove.addAll(constraints); + // all equal types will be substitute with one type + substituteAllTPH(allCons, constraints, left); + + HashSet eq = new HashSet<>(); + // put all equal types in a set + for (String t : allTypes) { + eq.add(t); + } + // generate a new constraint (left < Object) + TPHConstraint constraint = new ExtendsConstraint(left, Type.getInternalName(Object.class), + Relation.EXTENDS); + // put the generated constraint and its equal set into result set + result.put(constraint, eq); + constraints.clear(); + } + allTypes.clear(); + } + } + // build an equal set that contains all types + // which are equal and for each equal constraint put left side and right side + // in this set Then generate a constraint type < Object and put it + // with the equal set into the result. + for (TPHConstraint c : allCons) { + if (c.getRel() == Relation.EQUAL) { + if (!isTPHInResEqual(result, c.getLeft())) { + HashSet equalTPHs = getEqualsTPHs(result, c); + TPHConstraint constraint = getKeyConstraint(result, c); + equalTPHs.add(c.getLeft()); + equalTPHs.add(c.getRight()); + result.put(constraint, equalTPHs); + } + consToRemove.add(c); + size--; + } + } + + // remove all equal-constraints + allCons.removeAll(consToRemove); + // add all generated constraints to allCons + allCons.addAll(result.keySet()); + + if (!allCons.isEmpty() && allCons.size() < 2) { + TPHConstraint cons = allCons.get(0); + if (!result.containsKey(cons)) { + result.put(cons, null); + result.put(new ExtendsConstraint(cons.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS), + null); + } + + return result; + } + + size += result.keySet().size(); + // all constraints which have Object on the right side will + // be ignored, because they are simplified and can not be changed. + for (TPHConstraint c : allCons) { + if (c.getRight().equals(Type.getInternalName(Object.class))) + size--; + } + + // check if there are multiple constraint with the same left side. + // if yes => check if the super type in the method, if not + // then ignore it. + HashMap subAndSuper = new HashMap<>(); + ArrayList eqCons = new ArrayList<>(); + for (TPHConstraint c : allCons) { + + subAndSuper.put(c.getLeft(), c.getRight()); + } + + int numOfVisitedPairs = 0; + for (String sub : subAndSuper.keySet()) { + if (isTPHInConstraint(result, sub)) + continue; + + if (!classTPHSContainsTPH(tphsClass, sub)) + continue; + + if (numOfVisitedPairs >= size) + break; + LinkedList tphInRel = new LinkedList<>(); + tphInRel.add(sub); + String superT = subAndSuper.get(sub); + tphInRel.add(superT); + + numOfVisitedPairs++; + while (subAndSuper.containsKey(superT)) { + superT = subAndSuper.get(superT); + if (tphInRel.contains(superT)) { + break; + } + tphInRel.add(superT); + numOfVisitedPairs++; + } + + // Subtype + String subTphRes = tphInRel.getFirst(); + // Die größte Supertype + String superTphRes = tphInRel.getLast(); + + // if there is any constraint X < subTph, then + // add X at the beginning of the list. + while (subAndSuper.containsValue(subTphRes)) { + for (String tph : subAndSuper.keySet()) { + if (classTPHSContainsTPH(tphsClass, tph) && subAndSuper.get(tph).equals(subTphRes)) { + subTphRes = tph; + break; + } + } + if (subTphRes.equals(tphInRel.getFirst())) { + break; + } + + if (isTPHInConstraint(result, subTphRes)) + break; + + tphInRel.addFirst(subTphRes); + numOfVisitedPairs++; + } + + subTphRes = tphInRel.getFirst(); + + HashSet equals = getEqualsTphsFromEqualCons(eqCons, superTphRes); + result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), equals); + + } + + System.out.println("EndResult: "); + result.forEach((c, hs) -> { + if (c != null) { + System.out.print(c.toString() + " -> "); + if (hs == null) { + System.out.print(" [] "); + } else { + hs.forEach(s -> { + System.out.print(s + ", "); + }); + } + } + + System.out.println(); + }); + System.out.println("----------------"); + return result; + } + private static boolean classTPHSContainsTPH(ArrayList tphsClass, String superTphRes) { - for(TypePlaceholder tph : tphsClass) { - if(tph.getName().equals(superTphRes)) + for (TypePlaceholder tph : tphsClass) { + if (tph.getName().equals(superTphRes)) return true; } return false; } private static boolean isTphInEqualSet(HashMap> result, String tph) { - for(HashSet hs: result.values()) { - if(hs.contains(tph)) + for (HashSet hs : result.values()) { + if (hs.contains(tph)) return true; } return false; @@ -365,44 +716,44 @@ public class Simplify { private static HashSet getEqualsTphsFromEqualCons(ArrayList eqCons, String tph) { HashSet ee = new HashSet<>(); - for(TPHConstraint c : eqCons) { - if(c.getLeft().equals(tph)) + for (TPHConstraint c : eqCons) { + if (c.getLeft().equals(tph)) ee.add(c.getRight()); - if(c.getRight().equals(tph)) + if (c.getRight().equals(tph)) ee.add(c.getLeft()); } return ee; } - private static void substituteInMap(HashMap subAndSuper, ArrayList allCons,ArrayList eqCons, String toSubs, - String tph) { + private static void substituteInMap(HashMap subAndSuper, ArrayList allCons, + ArrayList eqCons, String toSubs, String tph) { substituteTPH(allCons, toSubs, tph); - if(subAndSuper.containsKey(toSubs) && subAndSuper.containsKey(tph)) { + if (subAndSuper.containsKey(toSubs) && subAndSuper.containsKey(tph)) { toSubs = subAndSuper.remove(toSubs); EqualConstraint eq = new EqualConstraint(subAndSuper.get(tph), toSubs, Relation.EQUAL); eqCons.add(eq); - substituteInMap(subAndSuper, allCons,eqCons,toSubs, subAndSuper.get(tph)); - } else if(subAndSuper.containsKey(toSubs) && !subAndSuper.containsKey(tph)) { + substituteInMap(subAndSuper, allCons, eqCons, toSubs, subAndSuper.get(tph)); + } else if (subAndSuper.containsKey(toSubs) && !subAndSuper.containsKey(tph)) { String val = subAndSuper.remove(toSubs); subAndSuper.put(tph, val); } else { - for(String k : subAndSuper.keySet()) { + for (String k : subAndSuper.keySet()) { subAndSuper.replace(k, toSubs, tph); } } } private static TPHConstraint getConstraint(String oldRight, String right, ArrayList allCons) { - for(TPHConstraint c : allCons) { - if(c.getLeft().equals(oldRight) && c.getRight().equals(right)) + for (TPHConstraint c : allCons) { + if (c.getLeft().equals(oldRight) && c.getRight().equals(right)) return c; } return null; } private static boolean isTPHInResEqual(HashMap> result, String left) { - for(HashSet eq : result.values()) { - if(eq.contains(left)) { + for (HashSet eq : result.values()) { + if (eq.contains(left)) { return true; } } @@ -411,75 +762,77 @@ public class Simplify { private static void substituteAllTPH(ArrayList allCons, ArrayList constraints, String first) { - for(TPHConstraint c : allCons) { - for(TPHConstraint c2 : constraints) { - if(c.getRel() == Relation.EXTENDS) { - if(c2.getLeft().equals(c.getLeft()) || c2.getRight().equals(c.getLeft())) + for (TPHConstraint c : allCons) { + for (TPHConstraint c2 : constraints) { + if (c.getRel() == Relation.EXTENDS) { + if (c2.getLeft().equals(c.getLeft()) || c2.getRight().equals(c.getLeft())) c.setLeft(first); - if(c2.getLeft().equals(c.getRight()) || c2.getRight().equals(c.getRight())) + if (c2.getLeft().equals(c.getRight()) || c2.getRight().equals(c.getRight())) c.setRight(first); } - + } } } private static void setAllEqual(ArrayList constraints) { - for(TPHConstraint c:constraints) { + for (TPHConstraint c : constraints) { c.setRel(Relation.EQUAL); } } - public static HashMap> simplifyContraints(HashMap> allConstraints) { + public static HashMap> simplifyContraints( + HashMap> allConstraints) { // 1. check if there are any cycles like L set L=R and: - // * remove both constraints - // * substitute L with R in all constraint - // b)no => go to next step - // 2. check the result of step 1 if there are any equal-constraints like L=R, M=R .. - // a) yes => put all such TPhs in a map and define "key-Cons" - // -- key-Cons = TPH < Object -- - // put this Constraint and the - // b) no + // a) yes => set L=R and: + // * remove both constraints + // * substitute L with R in all constraint + // b)no => go to next step + // 2. check the result of step 1 if there are any equal-constraints like L=R, + // M=R .. + // a) yes => put all such TPhs in a map and define "key-Cons" + // -- key-Cons = TPH < Object -- + // put this Constraint and the + // b) no // 3. is ArrayList allCons = new ArrayList<>(); - for(TPHConstraint tphCons : allConstraints.keySet()) { + for (TPHConstraint tphCons : allConstraints.keySet()) { allCons.add(tphCons); } ArrayList consToRemove = new ArrayList<>(); // step 1: - for(TPHConstraint c : allCons) { - + for (TPHConstraint c : allCons) { + String left = c.getLeft(); String right = c.getRight(); - if(c.getRel() == Relation.EXTENDS) { - TPHConstraint revCon = getReverseConstraint(allCons,left,right); - if(revCon != null) { + if (c.getRel() == Relation.EXTENDS) { + TPHConstraint revCon = getReverseConstraint(allCons, left, right); + if (revCon != null) { revCon.setRel(Relation.EQUAL); consToRemove.add(revCon); c.setRel(Relation.EQUAL); - substituteTPH(allCons,left, right); + substituteTPH(allCons, left, right); } } } System.out.println(); System.out.println("NEW ALL CONST: " + allCons.size()); - allCons.forEach(c->System.out.println(c.toString())); + allCons.forEach(c -> System.out.println(c.toString())); System.out.println("----------------"); allCons.removeAll(consToRemove); consToRemove = new ArrayList<>(); - + // int size = allCons.size(); - + System.out.println("AFTER DELETE ALL CONST: " + allCons.size()); - allCons.forEach(c->System.out.println(c.toString())); + allCons.forEach(c -> System.out.println(c.toString())); System.out.println("----------------"); HashMap> result = new HashMap<>(); - - for(TPHConstraint c : allCons) { - if(c.getRel()==Relation.EQUAL) { + + for (TPHConstraint c : allCons) { + if (c.getRel() == Relation.EQUAL) { HashSet equalTPHs = getEqualsTPHs(result, c); - TPHConstraint constraint = getKeyConstraint(result,c); + TPHConstraint constraint = getKeyConstraint(result, c); equalTPHs.add(c.getLeft()); equalTPHs.add(c.getRight()); result.put(constraint, equalTPHs); @@ -488,9 +841,9 @@ public class Simplify { } } System.out.println("Step 2 Result: "); - result.forEach((c,hs)->{ + result.forEach((c, hs) -> { System.out.print(c.toString() + " -> "); - hs.forEach(s->{ + hs.forEach(s -> { System.out.print(s + ", "); }); System.out.println(); @@ -498,33 +851,33 @@ public class Simplify { System.out.println("----------------"); allCons.removeAll(consToRemove); allCons.addAll(result.keySet()); - - if(!allCons.isEmpty() && allCons.size()<2) { - if(!result.containsKey(allCons.get(0))) + if (!allCons.isEmpty() && allCons.size() < 2) { + + if (!result.containsKey(allCons.get(0))) result.put(allCons.get(0), null); - + return result; } - + // size += result.keySet().size(); - + // for(TPHConstraint c : allCons) { // if(c.getRight().equals(Type.getInternalName(Object.class))) // size--; // } - + HashMap subAndSuper = new HashMap<>(); - - for(TPHConstraint c : allCons) { + + for (TPHConstraint c : allCons) { subAndSuper.put(c.getLeft(), c.getRight()); } - + // int numOfVisitedPairs = 0; - for(String sub : subAndSuper.keySet()) { - if(isTPHInConstraint(result,sub)) + for (String sub : subAndSuper.keySet()) { + if (isTPHInConstraint(result, sub)) continue; - + // if(numOfVisitedPairs>=size) // break; @@ -532,118 +885,137 @@ public class Simplify { tphInRel.add(sub); String superT = subAndSuper.get(sub); tphInRel.add(superT); - + // numOfVisitedPairs++; - while(subAndSuper.containsKey(superT)) { + while (subAndSuper.containsKey(superT)) { superT = subAndSuper.get(superT); - if(tphInRel.contains(superT)) { + if (tphInRel.contains(superT)) { break; } tphInRel.add(superT); // numOfVisitedPairs++; } - + // Subtype String subTphRes = tphInRel.getFirst(); // Die größte Supertype String superTphRes = tphInRel.getLast(); - - while(subAndSuper.containsValue(subTphRes)) { - for(String tph : subAndSuper.keySet()) { - if(subAndSuper.get(tph).equals(subTphRes)) { + + while (subAndSuper.containsValue(subTphRes)) { + for (String tph : subAndSuper.keySet()) { + if (subAndSuper.get(tph).equals(subTphRes)) { subTphRes = tph; break; } } - if(subTphRes.equals(tphInRel.getFirst())) { + if (subTphRes.equals(tphInRel.getFirst())) { break; } tphInRel.addFirst(subTphRes); // numOfVisitedPairs++; } - + subTphRes = tphInRel.getFirst(); - + int i = 2; - while(superTphRes.equals(Type.getInternalName(Object.class)) && (tphInRel.size()-i) >0) { - superTphRes = tphInRel.get(tphInRel.size()-i); + while (superTphRes.equals(Type.getInternalName(Object.class)) && (tphInRel.size() - i) > 0) { + superTphRes = tphInRel.get(tphInRel.size() - i); i++; } - if(superTphRes.equals(Type.getInternalName(Object.class))) { - result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), null); + if (superTphRes.equals(Type.getInternalName(Object.class))) { + result.put(new ExtendsConstraint(subTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), + null); } else { result.put(new ExtendsConstraint(subTphRes, superTphRes, Relation.EXTENDS), null); - result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), null); + result.put(new ExtendsConstraint(superTphRes, Type.getInternalName(Object.class), Relation.EXTENDS), + null); } - + } System.out.println("EndResult: "); - result.forEach((c,hs)->{ - if(c!=null) { + result.forEach((c, hs) -> { + if (c != null) { System.out.print(c.toString() + " -> "); - if(hs == null) { + if (hs == null) { System.out.print(" [] "); - }else { - hs.forEach(s->{ + } else { + hs.forEach(s -> { System.out.print(s + ", "); }); } } - - + System.out.println(); }); System.out.println("----------------"); return result; } - - private static void substituteTPH(ArrayList allCons,String left ,String right) { - allCons.forEach(c->{ - if(c.getRel() == Relation.EXTENDS) { - if(c.getLeft().equals(left)) + + private static void substituteTPH(ArrayList allCons, String left, String right) { + allCons.forEach(c -> { + if (c.getRel() == Relation.EXTENDS) { + if (c.getLeft().equals(left)) c.setLeft(right); - if(c.getRight().equals(left)) + if (c.getRight().equals(left)) c.setRight(right); } }); } private static TPHConstraint getReverseConstraint(ArrayList allCons, String left, String right) { - for(TPHConstraint c : allCons) { - if(c.getLeft().equals(right) && c.getRight().equals(left)){ + for (TPHConstraint c : allCons) { + if (c.getLeft().equals(right) && c.getRight().equals(left)) { return c; } } return null; } - + private static boolean isTPHInConstraint(HashMap> result, String sub) { - for(TPHConstraint c : result.keySet()) { - if(c.getLeft().equals(sub)) + for (TPHConstraint c : result.keySet()) { + if (c.getLeft().equals(sub)) return true; } return false; } private static boolean containTPH(ArrayList methodTphs, String sub) { - for(String tph : methodTphs) { - if(tph.equals(sub)) + for (String tph : methodTphs) { + if (tph.equals(sub)) return true; } return false; } - private static TPHConstraint getKeyConstraint(HashMap> result, TPHConstraint toFind) { - for(TPHConstraint c : result.keySet()) { - if(c.containTPH(toFind.getLeft()) || c.containTPH(toFind.getRight())) + private static TPHConstraint getKeyConstraint(HashMap> result, TPHConstraint toFind, + ArrayList allCons) { + + for (TPHConstraint c : result.keySet()) { + if (c.containTPH(toFind.getLeft())) return c; } + for (TPHConstraint c : allCons) { + if (toFind.getRight().equals(c.getLeft())) + return c; + } + return new ExtendsConstraint(toFind.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS); } - private static HashSet getEqualsTPHs(HashMap> result, TPHConstraint toFind) { - for(TPHConstraint c : result.keySet()) { - if(c.containTPH(toFind.getLeft()) || c.containTPH(toFind.getRight())) + private static TPHConstraint getKeyConstraint(HashMap> result, + TPHConstraint toFind) { + + for (TPHConstraint c : result.keySet()) { + if (c.containTPH(toFind.getLeft()) || c.containTPH(toFind.getRight())) + return c; + } + + return new ExtendsConstraint(toFind.getRight(), Type.getInternalName(Object.class), Relation.EXTENDS); + } + + private static HashSet getEqualsTPHs(HashMap> result, TPHConstraint toFind) { + for (TPHConstraint c : result.keySet()) { + if (c.containTPH(toFind.getLeft()) || c.containTPH(toFind.getRight())) return result.get(c); } return new HashSet<>(); diff --git a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java index 0be50fb5..bbe8c257 100644 --- a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java +++ b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java @@ -34,6 +34,7 @@ import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType; import de.dhbwstuttgart.typeinference.unify.model.UnifyPair; import de.dhbwstuttgart.typeinference.unify.model.UnifyType; import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask; +import de.dhbwstuttgart.typeinference.unify.UnifyResultListener; import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl; import de.dhbwstuttgart.typeinference.unify.UnifyResultModel; @@ -41,6 +42,10 @@ import java.io.File; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOException; +<<<<<<< HEAD +======= +import java.io.OutputStreamWriter; +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 import java.io.Writer; import java.util.*; import java.util.function.Function; @@ -48,6 +53,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import org.antlr.v4.parse.ANTLRParser.throwsSpec_return; +import org.apache.commons.io.output.NullOutputStream; public class JavaTXCompiler { @@ -275,7 +281,7 @@ public class JavaTXCompiler { } */ - public UnifyResultModel typeInferenceAsync() throws ClassNotFoundException { + public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException { List allClasses = new ArrayList<>();//environment.getAllAvailableClasses(); //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC for(SourceFile sf : this.sourceFiles.values()) { @@ -285,10 +291,18 @@ public class JavaTXCompiler { final ConstraintSet cons = getConstraints(); Set> results = new HashSet<>(); +<<<<<<< HEAD UnifyResultModel urm = null; try { Writer logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName())); +======= + UnifyResultModel urm = new UnifyResultModel(); + urm.addUnifyResultListener(resultListener); + try { + logFile = logFile == null ? new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName())) : logFile; + +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile); System.out.println(finiteClosure); urm = new UnifyResultModel(cons, finiteClosure); @@ -423,7 +437,12 @@ public class JavaTXCompiler { final ConstraintSet cons = getConstraints(); Set> results = new HashSet<>(); try { +<<<<<<< HEAD Writer logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName())); +======= + Writer logFile = new OutputStreamWriter(new NullOutputStream()); + //new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName())); +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile); System.out.println(finiteClosure); diff --git a/src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java b/src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java index bf9fe263..6fd83f3b 100644 --- a/src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java +++ b/src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java @@ -80,6 +80,9 @@ public abstract class AbstractASTWalker implements ASTVisitor{ for(Field f : classOrInterface.getFieldDecl()){ f.accept(this); } + for(Constructor c : classOrInterface.getConstructors()){ + c.accept(this); + } for(Method m : classOrInterface.getMethods()){ m.accept(this); } diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify.java index 2cea2184..df47e43f 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify.java @@ -14,6 +14,7 @@ import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure; import de.dhbwstuttgart.typeinference.unify.model.UnifyPair; public class TypeUnify { +<<<<<<< HEAD /** * unify parallel ohne result modell @@ -27,12 +28,17 @@ public class TypeUnify { */ public Set> unify(Set undConstrains, List>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) { TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret); +======= + public Set> unify(Set undConstrains, List>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet cons) { + TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, new UnifyResultModel(), cons); +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 ForkJoinPool pool = new ForkJoinPool(); pool.invoke(unifyTask); Set> res = unifyTask.join(); return res; } +<<<<<<< HEAD /** * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind * @param undConstrains @@ -46,11 +52,16 @@ public class TypeUnify { */ public UnifyResultModel unifyAsync(Set undConstrains, List>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) { TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret); +======= + public UnifyResultModel unifyAsync(Set undConstrains, List>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet cons, UnifyResultModel ret) { + TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, cons); +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 ForkJoinPool pool = new ForkJoinPool(); pool.invoke(unifyTask); return ret; } +<<<<<<< HEAD /** * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind * @param undConstrains @@ -64,6 +75,10 @@ public class TypeUnify { */ public UnifyResultModel unifyParallel(Set undConstrains, List>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) { TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret); +======= + public UnifyResultModel unifyParallel(Set undConstrains, List>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet cons, UnifyResultModel ret) { + TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, cons); +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 ForkJoinPool pool = new ForkJoinPool(); pool.invoke(unifyTask); Set> res = unifyTask.join(); diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java index 31247aef..e18be625 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java @@ -1,7 +1,10 @@ package de.dhbwstuttgart.typeinference.unify; import java.io.FileWriter; +<<<<<<< HEAD import java.io.IOException; +======= +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 import java.io.Writer; import java.util.HashSet; import java.util.List; @@ -17,8 +20,13 @@ public class TypeUnify2Task extends TypeUnifyTask { Set> setToFlatten; +<<<<<<< HEAD public TypeUnify2Task(Set> setToFlatten, Set eq, List>> oderConstraints, Set nextSetElement, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) { super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm); +======= + public TypeUnify2Task(Set> setToFlatten, Set eq, List>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet cons) { + super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons); +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 this.setToFlatten = setToFlatten; this.nextSetElement = nextSetElement; } diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java index b26ee13b..fc8e9b2d 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java @@ -133,7 +133,11 @@ public class TypeUnifyTask extends RecursiveTask>> { } */ +<<<<<<< HEAD public TypeUnifyTask(Set eq, List>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) { +======= + public TypeUnifyTask(Set eq, List>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet cons2) { +>>>>>>> 7cb2eed36edfe2d9f3ec4ce5c0ca40702dcff7f2 synchronized (this) { this.eq = eq; //this.oderConstraints = oderConstraints.stream().map(x -> x.stream().map(y -> new HashSet<>(y)).collect(Collectors.toSet(HashSet::new))).collect(Collectors.toList(ArrayList::new)); diff --git a/src/test/java/bytecode/FieldTphConsMethTest.java b/src/test/java/bytecode/FieldTphConsMethTest.java index ecf992d0..382c31e4 100644 --- a/src/test/java/bytecode/FieldTphConsMethTest.java +++ b/src/test/java/bytecode/FieldTphConsMethTest.java @@ -32,11 +32,11 @@ public class FieldTphConsMethTest { pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/"; loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)}); classToTest = loader.loadClass("FieldTphConsMeth"); - instanceOfClass = classToTest.getDeclaredConstructor().newInstance(); } @Test public void test() throws Exception { + instanceOfClass = classToTest.getConstructor(Object.class).newInstance("C"); Field a = classToTest.getDeclaredField("a"); a.setAccessible(true); @@ -44,6 +44,7 @@ public class FieldTphConsMethTest { Object result = m.invoke(instanceOfClass, 42); assertEquals(42,result); + assertEquals("C", a.get(instanceOfClass)); } } diff --git a/src/test/java/bytecode/FieldTphMMethTest.java b/src/test/java/bytecode/FieldTphMMethTest.java new file mode 100644 index 00000000..f21adefe --- /dev/null +++ b/src/test/java/bytecode/FieldTphMMethTest.java @@ -0,0 +1,66 @@ +package bytecode; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; + +import org.junit.BeforeClass; +import org.junit.Test; + +import de.dhbwstuttgart.core.JavaTXCompiler; + +public class FieldTphMMethTest { + + private static String path; + private static File fileToTest; + private static JavaTXCompiler compiler; + private static ClassLoader loader; + private static Class classToTest; + private static String pathToClassFile; + private static Object instanceOfClass; + private static Object instanceOfClass2; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/FieldTphMMeth.jav"; + fileToTest = new File(path); + compiler = new JavaTXCompiler(fileToTest); + compiler.generateBytecode(System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/"); + pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/"; + loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)}); + classToTest = loader.loadClass("FieldTphMMeth"); + instanceOfClass = classToTest.getConstructor(Object.class,Object.class,Boolean.class).newInstance("C",42,true); + instanceOfClass2 = classToTest.getConstructor(Object.class,Object.class,Boolean.class).newInstance("C",42,false); + } + + @Test + public void testM() throws Exception { + + Method m = classToTest.getDeclaredMethod("m", Object.class,Object.class,Boolean.class); + Object result = m.invoke(instanceOfClass, "C",42,false); + + assertEquals(42,result); + } + + @Test + public void testWithTrue() throws Exception { + Field a = classToTest.getDeclaredField("a"); + a.setAccessible(true); + + assertEquals("C", a.get(instanceOfClass)); + + } + + @Test + public void testWithFalse() throws Exception { + Field a = classToTest.getDeclaredField("a"); + a.setAccessible(true); + + assertEquals(42, a.get(instanceOfClass2)); + } + +} diff --git a/src/test/java/bytecode/FieldTph.java b/src/test/java/bytecode/InfTest.java similarity index 68% rename from src/test/java/bytecode/FieldTph.java rename to src/test/java/bytecode/InfTest.java index 65c7f291..75608bfe 100644 --- a/src/test/java/bytecode/FieldTph.java +++ b/src/test/java/bytecode/InfTest.java @@ -3,7 +3,7 @@ package bytecode; import static org.junit.Assert.*; import java.io.File; -import java.lang.reflect.Field; +import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; @@ -12,8 +12,8 @@ import org.junit.Test; import de.dhbwstuttgart.core.JavaTXCompiler; -public class FieldTph { - +public class InfTest { + private static String path; private static File fileToTest; private static JavaTXCompiler compiler; @@ -22,22 +22,16 @@ public class FieldTph { private static String pathToClassFile; private static Object instanceOfClass; - @BeforeClass - public static void setUpBeforeClass() throws Exception { - path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/FieldTph.jav"; + @Test + public void generateBC() throws Exception { + path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/Inf.jav"; fileToTest = new File(path); compiler = new JavaTXCompiler(fileToTest); - compiler.generateBytecode(System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/"); pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/"; + compiler.generateBytecode(pathToClassFile); loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)}); - classToTest = loader.loadClass("FieldTph"); + classToTest = loader.loadClass("Inf"); instanceOfClass = classToTest.getDeclaredConstructor().newInstance(); } - @Test - public void test() { - Field[] fields = classToTest.getFields(); - assertEquals(1, fields.length); - } - } diff --git a/src/test/java/bytecode/KompTphTest.java b/src/test/java/bytecode/KompTphTest.java new file mode 100644 index 00000000..8fca0c0b --- /dev/null +++ b/src/test/java/bytecode/KompTphTest.java @@ -0,0 +1,37 @@ +package bytecode; + +import static org.junit.Assert.*; + +import java.io.File; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; + +import org.junit.BeforeClass; +import org.junit.Test; + +import de.dhbwstuttgart.core.JavaTXCompiler; + +public class KompTphTest { + + private static String path; + private static File fileToTest; + private static JavaTXCompiler compiler; + private static ClassLoader loader; + private static Class classToTest; + private static String pathToClassFile; + private static Object instanceOfClass; + + @Test + public void generateBC() throws Exception { + path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/KompTph.jav"; + fileToTest = new File(path); + compiler = new JavaTXCompiler(fileToTest); + pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/"; + compiler.generateBytecode(pathToClassFile); + loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)}); + classToTest = loader.loadClass("KompTph"); + instanceOfClass = classToTest.getDeclaredConstructor().newInstance(); + } + +} diff --git a/src/test/java/bytecode/MatrixOpTest.java b/src/test/java/bytecode/MatrixOpTest.java index 11018701..ea906853 100644 --- a/src/test/java/bytecode/MatrixOpTest.java +++ b/src/test/java/bytecode/MatrixOpTest.java @@ -4,6 +4,7 @@ import static org.junit.Assert.*; import java.io.File; import java.io.IOException; +import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.net.URL; @@ -27,7 +28,7 @@ public class MatrixOpTest { private static Object instanceOfClass_m3; @Test - public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException, InstantiationException { + public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException, InstantiationException, NoSuchFieldException { path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/MatrixOP.jav"; fileToTest = new File(path); compiler = new JavaTXCompiler(fileToTest); @@ -35,7 +36,7 @@ public class MatrixOpTest { compiler.generateBytecode(pathToClassFile); loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)}); classToTest = loader.loadClass("MatrixOP"); -/* + Vector> vv = new Vector>(); Vector v1 = new Vector (); v1.addElement(2); @@ -48,6 +49,7 @@ public class MatrixOpTest { //m1.addElement(v2); vv.addElement(v1); vv.addElement(v2); + instanceOfClass_m1 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv); //Matrix m1 = new Matrix(vv); Vector> vv1 = new Vector>(); @@ -62,13 +64,23 @@ public class MatrixOpTest { //m2.addElement(v4); vv1.addElement(v3); vv1.addElement(v4); + instanceOfClass_m2 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv1);//Matrix m2 = new Matrix(vv1); //Matrix m3 = m1.mul(vv1); - Method mul = classToTest.getDeclaredMethod("mul", Vector.class); - Object result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2); +// Method mul = classToTest.getDeclaredMethod("mul", Vector.class); +// Object result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2); + Field mul = classToTest.getField("mul"); + mul.setAccessible(true); + + Class lambda = mul.get(instanceOfClass_m1).getClass(); + Method apply = lambda.getMethod("apply", Object.class,Object.class); + // Damit man auf die Methode zugreifen kann + apply.setAccessible(true); + + Object result = apply.invoke(mul.get(instanceOfClass_m1),instanceOfClass_m1, instanceOfClass_m2); System.out.println(instanceOfClass_m1.toString() + " * " + instanceOfClass_m2.toString() + " = " + result.toString()); Vector> res = new Vector>(); @@ -85,7 +97,7 @@ public class MatrixOpTest { res.addElement(v6); instanceOfClass_m3 = classToTest.getDeclaredConstructor(Vector.class).newInstance(res); assertEquals(result, instanceOfClass_m3); -*/ + } } diff --git a/src/test/java/bytecode/simplifyalgo/FinderTest.java b/src/test/java/bytecode/simplifyalgo/FinderTest.java new file mode 100644 index 00000000..edf43605 --- /dev/null +++ b/src/test/java/bytecode/simplifyalgo/FinderTest.java @@ -0,0 +1,64 @@ +package bytecode.simplifyalgo; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.objectweb.asm.Type; + +import de.dhbwstuttgart.bytecode.TPHExtractor; +import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint; +import de.dhbwstuttgart.bytecode.constraint.TPHConstraint; +import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation; +import de.dhbwstuttgart.bytecode.utilities.ConstraintsFinder; +import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH; +import de.dhbwstuttgart.bytecode.utilities.Simplify; +import de.dhbwstuttgart.typedeployment.TypeInsertPlacer; + +/** + * + * @author Fayez Abu Alia + * + */ +public class FinderTest { + + @Test + public void testM1() { + List allCons = new ArrayList<>(); + // L < M + TPHConstraint c1 = new ExtendsConstraint("L", "M", Relation.EXTENDS); + // L < N + TPHConstraint c2 = new ExtendsConstraint("L", "N", Relation.EXTENDS); + // M < O + TPHConstraint c3 = new ExtendsConstraint("M", "O", Relation.EXTENDS); + // M < P + TPHConstraint c4 = new ExtendsConstraint("M", "P", Relation.EXTENDS); + + allCons.add(c1); + allCons.add(c2); + allCons.add(c3); + allCons.add(c4); + List> res = new ArrayList<>(); + List l1 = new ArrayList<>(); + List l2 = new ArrayList<>(); + + l1.add(c1); + l1.add(c2); + + l2.add(c3); + l2.add(c4); + + res.add(l1); + res.add(l2); + + ConstraintsFinder finder = new ConstraintsFinder(allCons); + + assertEquals(finder.findConstraints(), res); + } + +} diff --git a/src/test/resources/bytecode/javFiles/FieldTphMMeth.jav b/src/test/resources/bytecode/javFiles/FieldTphMMeth.jav new file mode 100644 index 00000000..ad97edc4 --- /dev/null +++ b/src/test/resources/bytecode/javFiles/FieldTphMMeth.jav @@ -0,0 +1,27 @@ +import java.lang.Boolean; + +public class FieldTphMMeth { + a; + + public FieldTphMMeth(c,d,e) { + a = m(c,d,e); + } + + m(b,d,e) { + if(e) { + return m3(b); + } else{ + return m3(d); + } + + } + + m2(b) { + a = m3(b); + } + + m3(b){ + return b; + } + +} \ No newline at end of file diff --git a/src/test/resources/bytecode/javFiles/Inf.jav b/src/test/resources/bytecode/javFiles/Inf.jav new file mode 100644 index 00000000..3c785a6e --- /dev/null +++ b/src/test/resources/bytecode/javFiles/Inf.jav @@ -0,0 +1,19 @@ +public class Inf { + m(x,y,a){ + var z; + var v; + var w; + var b; + y=x; + z=x; + v=y; + w=y; + y=a; + b=a; + } +} +// v w +// \ / +// z y b +// \ / \ / +// x a \ No newline at end of file diff --git a/src/test/resources/bytecode/javFiles/KompTph.jav b/src/test/resources/bytecode/javFiles/KompTph.jav new file mode 100644 index 00000000..ec34e154 --- /dev/null +++ b/src/test/resources/bytecode/javFiles/KompTph.jav @@ -0,0 +1,13 @@ +public class KompTph { + public m(a, b, c) { + var d = a; + var e = a; + a = b; + c = b; + m2(a,c); + } + + public m2(a,b){ + m(a,a,b); + } +} \ No newline at end of file diff --git a/src/test/resources/bytecode/javFiles/MatrixOP.jav b/src/test/resources/bytecode/javFiles/MatrixOP.jav index daa11349..ffa3dbe7 100644 --- a/src/test/resources/bytecode/javFiles/MatrixOP.jav +++ b/src/test/resources/bytecode/javFiles/MatrixOP.jav @@ -18,7 +18,7 @@ public class MatrixOP extends Vector> { } } - mul = (m1, m2) -> { + public mul = (m1, m2) -> { var ret = new MatrixOP(); var i = 0; while(i < m1.size()) {