From d0a261f55cdb466e612b42324a9738f43f2312c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Pl=C3=BCmicke?= Date: Wed, 9 Jan 2019 00:40:24 +0100 Subject: [PATCH] modified: ../../../main/java/de/dhbwstuttgart/core/JavaTXCompiler.java modified: ../../../main/java/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java Set fBounded = new HashSet<>(pair.getfBounded()); //PL 2019-01-09 new HashSet eingefuegt modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java modified: ../../../main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java modified: ../../resources/bytecode/javFiles/Matrix.jav --- .../de/dhbwstuttgart/core/JavaTXCompiler.java | 13 +++---- .../syntaxtree/factory/UnifyTypeFactory.java | 5 +-- .../typeinference/unify/TypeUnifyTask.java | 35 ++++++++++++++++--- .../unify/interfaces/IFiniteClosure.java | 1 + .../unify/model/FiniteClosure.java | 35 ++++++++++++++++--- .../unify/model/OrderingUnifyPair.java | 16 ++++++--- .../unify/model/PlaceholderType.java | 9 +++++ .../typeinference/unify/model/UnifyPair.java | 2 +- .../resources/bytecode/javFiles/Matrix.jav | 2 +- 9 files changed, 95 insertions(+), 23 deletions(-) diff --git a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java index 28a9d20e..8729dd3e 100644 --- a/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java +++ b/src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java @@ -272,15 +272,16 @@ public class JavaTXCompiler { } final ConstraintSet cons = getConstraints(); - - FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses); - System.out.println(finiteClosure); - ConstraintSet unifyCons = UnifyTypeFactory.convert(cons); - - TypeUnify unify = new TypeUnify(); Set> results = new HashSet<>(); try { FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName())); + + FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile); + System.out.println(finiteClosure); + ConstraintSet unifyCons = UnifyTypeFactory.convert(cons); + + TypeUnify unify = new TypeUnify(); + //Set> results = new HashSet<>(); Nach vorne gezogen logFile.write("FC:\\" + finiteClosure.toString()+"\n"); for(SourceFile sf : this.sourceFiles.values()) { logFile.write(ASTTypePrinter.print(sf)); diff --git a/src/main/java/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/main/java/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java index 71985334..743fbb74 100644 --- a/src/main/java/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java +++ b/src/main/java/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.factory; +import java.io.FileWriter; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -29,7 +30,7 @@ public class UnifyTypeFactory { private static ArrayList PLACEHOLDERS = new ArrayList<>(); - public static FiniteClosure generateFC(List fromClasses) throws ClassNotFoundException { + public static FiniteClosure generateFC(List fromClasses, FileWriter logFile) throws ClassNotFoundException { /* Die transitive Hülle muss funktionieren. Man darf schreiben List extends AL @@ -40,7 +41,7 @@ public class UnifyTypeFactory { Generell dürfen sie immer die gleichen Namen haben. TODO: die transitive Hülle bilden */ - return new FiniteClosure(FCGenerator.toUnifyFC(fromClasses)); + return new FiniteClosure(FCGenerator.toUnifyFC(fromClasses), logFile); } public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr){ diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java index 75b070de..a9d02c95 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java @@ -814,6 +814,7 @@ public class TypeUnifyTask extends RecursiveTask>> { //Alle Variablen bestimmen die nicht hinzugefügt wurden in a //PL 2018-12-28: Hier gab es eine ClassCastException, war nicht reproduzierbar + System.out.println(""); List vars_a = a.stream().filter(x -> (x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName()) ||x.getLhsType().getName().equals(x.getBasePair().getRhsType().getName()))) @@ -1483,7 +1484,6 @@ public class TypeUnifyTask extends RecursiveTask>> { // System.out.println(""); //} Set cs = fc.getAllTypesByName(thetaPrime.getName());//cs= [java.util.Vector, java.util.Vector>, ????java.util.Vector???] - //Set cs = fc.getAllTypesByMatch(thetaPrime); //PL 2019-01-02 geaendet wegen Bug 127//SO GEHT ES NICHT //PL 18-02-06 entfernt, kommt durch unify wieder rein @@ -1607,6 +1607,7 @@ public class TypeUnifyTask extends RecursiveTask>> { UnifyType aPrime = PlaceholderType.freshPlaceholder(); ((PlaceholderType)aPrime).setVariance(((PlaceholderType)a).getVariance()); + ((PlaceholderType)aPrime).disableWildcardtable(); UnifyType extAPrime = new ExtendsType(aPrime); UnifyType thetaPrime = extThetaPrime.getExtendedType(); Set resultPrime = new HashSet<>(); @@ -1627,12 +1628,14 @@ public class TypeUnifyTask extends RecursiveTask>> { */ private Set> unifyCase3(UnifyPair pair, IFiniteClosure fc) { PlaceholderType a = (PlaceholderType) pair.getLhsType(); + a.reversVariance(); SuperType subThetaPrime = (SuperType) pair.getRhsType(); byte variance = pair.getVariance(); Set> result = new HashSet<>(); UnifyType aPrime = PlaceholderType.freshPlaceholder(); ((PlaceholderType)aPrime).setVariance(((PlaceholderType)a).getVariance()); + ((PlaceholderType)aPrime).disableWildcardtable(); UnifyType supAPrime = new SuperType(aPrime); UnifyType thetaPrime = subThetaPrime.getSuperedType(); Set resultPrime = new HashSet<>(); @@ -1666,7 +1669,28 @@ public class TypeUnifyTask extends RecursiveTask>> { break; } - for(UnifyType thetaS : fc.greater(theta, pair.getfBounded())) { + //eingefuegt PL 2019-01-03 ANFANG + fc.setLogTrue(); + writeLog("FBOUNDED: " + pair.getfBounded()); + writeLog("Pair: " + pair); + Set greater = fc.greater(theta, pair.getfBounded()); + writeLog("GREATER: " + greater + pair + "THETA: " + theta + "FBOUNDED: " + pair.getfBounded() + " "); + + /*if (a.isWildcardable()) { + Set greater_ext = greater.stream().filter(x -> !(x instanceof ExtendsType) && !(x instanceof SuperType)) + .map(x -> { + //BinaryOperator> combiner = (aa,b) -> { aa.putAll(b); return aa;}; //Variablenumbenennung rausgenommen + //HashMap hm = x.getInvolvedPlaceholderTypes().stream() //Variablen muessen wahrscheinlich erhalten bleiben + // .reduce(new HashMap(), + // (aa, b)-> { aa.put(b,PlaceholderType.freshPlaceholder()); return aa; }, combiner); + return new SuperType (x);})//.accept(new freshPlaceholder(), hm));} + .collect(Collectors.toCollection(HashSet::new)); + greater.addAll(greater_ext); + } + //eingefuegt PL 2019-01-03 ENDE + */ + //for(UnifyType thetaS : fc.greater(theta, pair.getfBounded())) { + for(UnifyType thetaS : greater) { Set resultPrime = new HashSet<>(); Match match = new Match(); @@ -1674,7 +1698,7 @@ public class TypeUnifyTask extends RecursiveTask>> { for(int i = 0; !allGen && i < freshTphs.length; i++) { freshTphs[i] = PlaceholderType.freshPlaceholder(); ((PlaceholderType)freshTphs[i]).setVariance(((PlaceholderType)a).getVariance()); - Set fBounded = pair.getfBounded(); + Set fBounded = new HashSet<>(pair.getfBounded()); //PL 2019-01-09 new HashSet eingefuegt int i_ef = i; BiFunction f = (x,y) -> @@ -1688,7 +1712,7 @@ public class TypeUnifyTask extends RecursiveTask>> { //} BinaryOperator bo = (x,y) -> (x || y); if (fBounded.stream().reduce(false,f,bo)) { - resultPrime.add(new UnifyPair(thetaS.getTypeParams().get(i), freshTphs[i], PairOperator.EQUALSDOT, pair.getSubstitution(), pair)); + resultPrime.add(new UnifyPair(freshTphs[i], thetaS.getTypeParams().get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair)); } else { fBounded.add(thetaS.getTypeParams().get(i)); @@ -1702,7 +1726,8 @@ public class TypeUnifyTask extends RecursiveTask>> { resultPrime.add(new UnifyPair(a, thetaS.setTypeParams(new TypeParams(freshTphs)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair)); resultPrime = resultPrime.stream().map(x -> { x.setVariance(variance); return x;}).collect(Collectors.toCollection(HashSet::new)); result.add(resultPrime); - //writeLog(resultPrime.toString()); + writeLog("FBOUNDED2: " + pair.getfBounded()); + //writeLog("resultPrime Theta < a: " + greater + pair + "THETA: " + theta + "FBOUNDED: " + pair.getfBounded() + " " + resultPrime.toString()); } return result; diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java index 3e20f433..37d70d55 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java @@ -17,6 +17,7 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyType; */ public interface IFiniteClosure { + public void setLogTrue(); /** * Returns all types of the finite closure that are subtypes of the argument. * @return The set of subtypes of the argument. diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java index 2c2cbd5d..b0198f87 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java @@ -1,5 +1,7 @@ package de.dhbwstuttgart.typeinference.unify.model; +import java.io.FileWriter; +import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -30,6 +32,11 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify; public class FiniteClosure //extends Ordering //entfernt PL 2018-12-11 implements IFiniteClosure { + FileWriter logFile; + static Boolean log = false; + public void setLogTrue() { + log = true; + } /** * A map that maps every type to the node in the inheritance graph that contains that type. */ @@ -49,7 +56,8 @@ implements IFiniteClosure { /** * Creates a new instance using the inheritance tree defined in the pairs. */ - public FiniteClosure(Set pairs) { + public FiniteClosure(Set pairs, FileWriter logFile) { + this.logFile = logFile; this.pairs = new HashSet<>(pairs); inheritanceGraph = new HashMap>(); @@ -214,6 +222,15 @@ implements IFiniteClosure { // if T <* T' then sigma(T) <* sigma(T') Set> candidates = strInheritanceGraph.get(type.getName()); + + try { + if (log) logFile.write(candidates.toString()); + //log = false; + } + catch (IOException e) { + System.err.println("no LogFile"); + } + for(Node candidate : candidates) { UnifyType theta1 = candidate.getContent(); @@ -222,9 +239,13 @@ implements IFiniteClosure { termList.add(new UnifyPair(theta1,type, PairOperator.EQUALSDOT)); Optional optSigma = match.match(termList); //PL 18-04-05 Unifier durch Matcher ersetzt ENDE - if(!optSigma.isPresent()) + if(!optSigma.isPresent()) { + if ((type.getName().equals("java.util.Vector")) && (type instanceof ReferenceType) && + (((ReferenceType)type).getTypeParams().get(0).getName().equals("java.lang.Integer"))) { + System.out.println(type.toString() + candidates); + } continue; - + } Unifier sigma = optSigma.get(); sigma.swapPlaceholderSubstitutionsReverse(theta1.getTypeParams()); @@ -237,7 +258,13 @@ implements IFiniteClosure { PairResultFBounded.add(new Pair<>(theta2.apply(sigma), fBoundedNew)); } } - + try { + if (log) logFile.write(PairResultFBounded.toString()); + log = false; + } + catch (IOException e) { + System.err.println("no LogFile"); + } for(Pair> pt : PairResultFBounded) { UnifyType t = pt.getKey(); Set lfBounded = pt.getValue().get(); diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java index c655e6fd..636a6029 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java @@ -110,17 +110,25 @@ public class OrderingUnifyPair extends Ordering> { && x.getPairOp() == PairOperator.SMALLERDOTWC)) .collect(Collectors.toCollection(HashSet::new)); //System.out.println(left.toString()); - //Fall 2 und 3 + //Fall 2 //if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) { // System.out.print(""); //} - if (lefteq.size() == 1 && leftle.size() == 1 && righteq.size() == 0 && rightle.size() == 1) { + if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof ExtendsType && leftle.size() == 1 && righteq.size() == 0 && rightle.size() == 1) { return 1; } - //Fall 2 und 3 - if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && rightle.size() == 1) { + //Fall 2 + if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && righteq.iterator().next().getRhsType() instanceof ExtendsType && rightle.size() == 1) { return -1; } + //Fall 3 + if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof SuperType && leftle.size() == 1 && righteq.size() == 0 && rightle.size() == 1) { + return -1; + } + //Fall 3 + if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && righteq.iterator().next().getRhsType() instanceof SuperType && rightle.size() == 1) { + return 1; + } //Fall 5 if (lefteq.size() == 1 && leftle.size() == 0 && righteq.size() == 1 && rightle.size() == 1) { return -1; diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java index 8a357bbb..09402c2f 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java @@ -108,6 +108,15 @@ public final class PlaceholderType extends UnifyType{ return variance; } + public void reversVariance() { + if (variance == 1) { + setVariance(-1); + } else { + if (variance == -1) { + setVariance(1); + }} + } + public Boolean isWildcardable() { return wildcardable; } diff --git a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java index 57b4e61e..1266a824 100644 --- a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java +++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java @@ -224,7 +224,7 @@ public class UnifyPair { if (rhs instanceof PlaceholderType) { ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString(); } - return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ", [" + getfBounded().toString()+ "])"; + return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + "])"; //+ ", [" + getfBounded().toString()+ "])"; } /* diff --git a/src/test/resources/bytecode/javFiles/Matrix.jav b/src/test/resources/bytecode/javFiles/Matrix.jav index 29505161..9e87c1e6 100644 --- a/src/test/resources/bytecode/javFiles/Matrix.jav +++ b/src/test/resources/bytecode/javFiles/Matrix.jav @@ -1,6 +1,6 @@ import java.util.Vector; import java.lang.Integer; -import java.lang.Float; +//import java.lang.Float; //import java.lang.Byte; //import java.lang.Boolean;