JavaTX/JavaCompilerCore
2
0
Fork 3
Code Issues 99 Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'unify' of ssh://gohorb.ba-horb.de/bahome/projekt/git/JavaCompilerCore into refactoring

Browse Source
This commit is contained in:
JanUlrich 2016-04-29 03:09:31 +02:00
commit f2410154aa
6 changed files with 269 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
View File

@ -124,7 +124,7 @@ public class UnifyTypeFactory {
}
public static UnifyType convert(GenericTypeVar t){
return new ReferenceType(t.get_Name());
return new PlaceholderType(t.get_Name());
}
public static UnifyConstraintsSet convert(ConstraintsSet constraints) {

12
src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java
View File

@ -8,9 +8,17 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
public class TypeUnify {
public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc) {
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc);
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true);
ForkJoinPool pool = new ForkJoinPool();
pool.invoke(unifyTask);
return unifyTask.join();
Set<Set<UnifyPair>> res = unifyTask.join();
return res;
}
public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc) {
TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false);
Set<Set<UnifyPair>> res = unifyTask.compute();
return res;
}
}

57
src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
View File

@ -54,14 +54,17 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
protected IFiniteClosure fc;
public TypeUnifyTask(Set<UnifyPair> eq, IFiniteClosure fc) {
protected boolean parallel;
public TypeUnifyTask(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel) {
this.eq = eq;
this.fc = fc;
this.parallel = parallel;
}
@Override
protected Set<Set<UnifyPair>> compute() {
return unify(eq, fc);
return unify(eq, fc, parallel);
}
/**
@ -70,7 +73,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
* @param fc The finite closure
* @return The set of all principal type unifiers
*/
public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc) {
protected Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel) {
/*
* Step 1: Repeated application of reduce, adapt, erase, swap
*/
@ -165,17 +168,27 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
/*
* Step 6 a) Restart (fork) for pairs where subst was applied
*/
if (eqPrime.equals(eq))
eqPrimePrimeSet.add(eqPrime);
else if(eqPrimePrime.isPresent()) {
TypeUnifyTask fork = new TypeUnifyTask(eqPrimePrime.get(), fc);
forks.add(fork);
fork.fork();
if(parallel) {
if (eqPrime.equals(eq))
eqPrimePrimeSet.add(eqPrime);
else if(eqPrimePrime.isPresent()) {
TypeUnifyTask fork = new TypeUnifyTask(eqPrimePrime.get(), fc, true);
forks.add(fork);
fork.fork();
}
else {
TypeUnifyTask fork = new TypeUnifyTask(eqPrime, fc, true);
forks.add(fork);
fork.fork();
}
}
else {
TypeUnifyTask fork = new TypeUnifyTask(eqPrime, fc);
forks.add(fork);
fork.fork();
else { // sequentiell (Step 6b is included)
if (eqPrime.equals(eq))
eqPrimePrimeSet.add(eqPrime);
else if(eqPrimePrime.isPresent())
eqPrimePrimeSet.addAll(unify(eqPrimePrime.get(), fc, false));
else
eqPrimePrimeSet.addAll(unify(eqPrime, fc, false));
}
}
@ -183,9 +196,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
* Step 6 b) Build the union over everything.
*/
// TODO Parallel stream und synced set?
for(TypeUnifyTask fork : forks)
eqPrimePrimeSet.addAll(fork.join());
if(parallel)
for(TypeUnifyTask fork : forks)
eqPrimePrimeSet.addAll(fork.join());
/*
* Step 7: Filter empty sets;
@ -279,6 +292,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
// ReduceTphExt, ReduceTphSup
optSet = optSet.isPresent() ? optSet : rules.reduceTphExt(pair);
optSet = optSet.isPresent() ? optSet : rules.reduceTphSup(pair);
// FunN Rules
optSet = optSet.isPresent() ? optSet : rules.reduceFunN(pair);
optSet = optSet.isPresent() ? optSet : rules.greaterFunN(pair);
optSet = optSet.isPresent() ? optSet : rules.smallerFunN(pair);
// One of the rules has been applied
if(optSet.isPresent()) {
@ -405,7 +424,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
*/
protected Set<Set<UnifyPair>> unifyCase1(PlaceholderType a, UnifyType thetaPrime, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
Set<UnifyType> cs = fc.getAllTypesByName(thetaPrime.getName());
cs.add(thetaPrime);
@ -423,7 +442,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
candidateParams.add(fc.grArg(param));
for(TypeParams tp : permuteParams(candidateParams))
try {
thetaQPrimes.add(c.setTypeParams(tp));
} catch(Exception e) {
System.out.println("f");
}
}
for(UnifyType tqp : thetaQPrimes) {

2
src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java
View File

@ -233,7 +233,7 @@ public class FiniteClosure implements IFiniteClosure {
Unifier sigma2 = sigma2Opt.get();
if(sigma2.size() == 0) // type.equals(theta2)
continue;
sigma2.swapPlaceholderSubstitutions(type.getTypeParams());
sigma2.swapPlaceholderSubstitutionsReverse(type.getTypeParams());
Set<UnifyType> theta1s = greater(theta2);
for (UnifyType theta1 : theta1s) {
// Because only the most general type is calculated, sigma1

25
src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java
View File

@ -98,10 +98,27 @@ public class Unifier implements Function<UnifyType, UnifyType>, Iterable<Entry<P
if(!(tph instanceof PlaceholderType))
continue;
// Swap a substitutions (a -> b) if a is an element of the target params.
if(substitutions.containsKey(tph) && substitutions.get(tph) instanceof PlaceholderType) {
PlaceholderType newLhs = (PlaceholderType) substitutions.get(tph);
substitutions.remove(tph);
substitutions.put(newLhs, tph);
if(substitutions.containsKey(tph)) {
if((substitutions.get(tph) instanceof PlaceholderType)) {
PlaceholderType newLhs = (PlaceholderType) substitutions.get(tph);
substitutions.remove(tph);
substitutions.put(newLhs, tph);
}
}
}
}
public void swapPlaceholderSubstitutionsReverse(Iterable<UnifyType> sourceParams) {
for(UnifyType tph : sourceParams) {
if(!(tph instanceof PlaceholderType))
continue;
if(substitutions.containsValue(tph)) {
UnifyType key = substitutions.values().stream().filter(x -> x.equals(tph)).findAny().get();
if(key instanceof PlaceholderType) {
PlaceholderType newLhs = (PlaceholderType) tph;
substitutions.remove(key);
substitutions.put(newLhs, key);
}
}
}
}

225
test/unify/UnifyTest.java
View File

@ -11,13 +11,14 @@ import org.junit.Test;
import de.dhbwstuttgart.typeinference.unify.TypeUnify;
import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
import de.dhbwstuttgart.typeinference.unify.model.FunNType;
import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
import junit.framework.Assert;
public class UnifyTest extends TypeUnify{
public class UnifyTest {
/**
* Testing the unification for cases with (n)one pair and without generics.
@ -51,7 +52,7 @@ public class UnifyTest extends TypeUnify{
Set<UnifyPair> eq = new HashSet<UnifyPair>();
Set<Set<UnifyPair>> expected = new HashSet<>();
expected.add(new HashSet<>());
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
/*
@ -69,7 +70,7 @@ public class UnifyTest extends TypeUnify{
addAsSet(expected, new UnifyPair(tphA, integer, PairOperator.EQUALSDOT));
addAsSet(expected, new UnifyPair(tphA, doubl, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -87,7 +88,7 @@ public class UnifyTest extends TypeUnify{
addAsSet(expected, new UnifyPair(tphA, number, PairOperator.EQUALSDOT));
addAsSet(expected, new UnifyPair(tphA, object, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -104,7 +105,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
addAsSet(expected, new UnifyPair(tphA, number, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -128,7 +129,7 @@ public class UnifyTest extends TypeUnify{
addAsSet(expected, new UnifyPair(tphA, supNumber, PairOperator.EQUALSDOT));
addAsSet(expected, new UnifyPair(tphA, supObject, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("? super Integer");
System.out.println(actual);
actual = filterGeneratedTPHsMultiple(actual);
@ -156,7 +157,7 @@ public class UnifyTest extends TypeUnify{
addAsSet(expected, new UnifyPair(tphA, supDouble, PairOperator.EQUALSDOT));
addAsSet(expected, new UnifyPair(tphA, supNumber, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
actual = filterGeneratedTPHsMultiple(actual);
Assert.assertEquals(expected, actual);
@ -174,7 +175,7 @@ public class UnifyTest extends TypeUnify{
addAsSet(expected, new UnifyPair(tphA, extNumber, PairOperator.EQUALSDOT));
addAsSet(expected, new UnifyPair(tphA, extObject, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
actual = filterGeneratedTPHsMultiple(actual);
Assert.assertEquals(expected, actual);
@ -199,7 +200,7 @@ public class UnifyTest extends TypeUnify{
addAsSet(expected, new UnifyPair(tphA, integer, PairOperator.EQUALSDOT));
addAsSet(expected, new UnifyPair(tphA, number, PairOperator.EQUALSDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
actual = filterGeneratedTPHsMultiple(actual);
Assert.assertEquals(expected, actual);
@ -216,7 +217,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
expected.add(new HashSet<>());
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -231,7 +232,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -248,7 +249,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
addAsSet(expected, new UnifyPair(tphA, tphB, PairOperator.SMALLERDOT));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -264,7 +265,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
addAsSet(expected, new UnifyPair(tphA, tphB, PairOperator.SMALLERDOTWC));
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
@ -286,7 +287,7 @@ public class UnifyTest extends TypeUnify{
IFiniteClosure voidFC = fcb.getFiniteClosure();
actual = unify(eq, voidFC);
actual = new TypeUnify().unifySequential(eq, fc);
Assert.assertEquals(expected, actual);
}
@ -331,7 +332,7 @@ public class UnifyTest extends TypeUnify{
eq.add(new UnifyPair(tf.getSimpleType("List", tphB), tf.getSimpleType("List", extNum), PairOperator.SMALLERDOT));
Set<Set<UnifyPair>> expected = new HashSet<>();
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
//System.out.println(actual);
//Assert.assertEquals(actual, expected);
@ -350,7 +351,7 @@ public class UnifyTest extends TypeUnify{
eq.add(new UnifyPair(tf.getSimpleType("Vector", extA), tf.getSimpleType("Vector", extNum), PairOperator.SMALLERDOT));
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
//System.out.println(actual);
//Assert.assertEquals(actual, expected);
@ -366,7 +367,7 @@ public class UnifyTest extends TypeUnify{
eq.add(new UnifyPair(tf.getSimpleType("Vector", extNum), tf.getSimpleType("Vector", extA), PairOperator.SMALLERDOT));
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println(actual);
//Assert.assertEquals(actual, expected);
@ -387,7 +388,7 @@ public class UnifyTest extends TypeUnify{
eq.add(new UnifyPair(extNum, tphB, PairOperator.SMALLERDOTWC));
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
//System.out.println(actual);
//Assert.assertEquals(actual, expected);
@ -449,7 +450,7 @@ public class UnifyTest extends TypeUnify{
eq.add(new UnifyPair(tf.getSimpleType("List", integer), tf.getSimpleType("List", tphB), PairOperator.SMALLERDOT));
Set<Set<UnifyPair>> expected = new HashSet<>();
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println(actual);
//Assert.assertEquals(actual, expected);
@ -469,7 +470,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Case 2");
System.out.println(actual);
@ -489,7 +490,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Case 3");
@ -514,7 +515,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println(actual);
//Assert.assertEquals(expected, actual);
@ -533,7 +534,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println(actual);
//Assert.assertEquals(expected, actual);
@ -552,7 +553,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Case 7");
System.out.println(actual);
@ -573,7 +574,7 @@ public class UnifyTest extends TypeUnify{
expected = new HashSet<>();
actual = unify(eq, fc);
actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Case 8:");
System.out.println(actual);
@ -608,7 +609,7 @@ public class UnifyTest extends TypeUnify{
eq.add(new UnifyPair(tf.getSimpleType("Matrix"), tf.getSimpleType("Vector", tf.getPlaceholderType("a")), PairOperator.SMALLERDOT));
Set<Set<UnifyPair>> expected = new HashSet<>();
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Test Matrix:");
System.out.println(actual);
@ -675,7 +676,7 @@ public class UnifyTest extends TypeUnify{
expected.add(solution);
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Test Void:");
System.out.println(actual);
@ -683,6 +684,172 @@ public class UnifyTest extends TypeUnify{
Assert.assertEquals(expected, actual);
}
// @Test
// public void unifyTestMatrixSimple() {
//// [(C <. C),
//// (D <. D),
//// (java.lang.Boolean <. PC),
//// (java.lang.Integer <. E1),
//// (java.util.Vector<java.lang.Integer> <. java.util.Vector<E1>),
//// (java.lang.Integer <. PD),
//// (java.util.Vector<java.lang.Integer> <. java.util.Vector<E3>),
//// (PE <. java.lang.Boolean),
//// (C <. java.lang.Integer),
//// (PD <. java.lang.Integer),
//// (PE <. java.lang.Boolean),
//// (E2 <. PF),
//// (C <. java.lang.Integer),
//// (java.util.Vector<java.lang.Integer> <. java.util.Vector<E2>),
//// (PG <. java.lang.Double),
//// (java.lang.Integer <. java.lang.Double),
//// (PF <. java.lang.Double),
//// (PG <. D),
//// (D <. PH),
//// (void <. B),
//// (void <. PI),
//// (Matrix <. java.util.Vector<E4>),
//// (void <. void)]
//
// TypeFactory tf = new TypeFactory();
// FiniteClosureBuilder fcb = new FiniteClosureBuilder();
//
// UnifyType tphC = tf.getPlaceholderType("C");
// UnifyType tphD = tf.getPlaceholderType("D");
// UnifyType tphPC = tf.getPlaceholderType("PC");
// UnifyType tphE1 = tf.getPlaceholderType("E1");
// UnifyType tphPD = tf.getPlaceholderType("PD");
// UnifyType tphE3 = tf.getPlaceholderType("E3");
// UnifyType tphPE = tf.getPlaceholderType("PE");
// UnifyType tphE2 = tf.getPlaceholderType("E2");
// UnifyType tphPG = tf.getPlaceholderType("PG");
// UnifyType tphPF = tf.getPlaceholderType("PF");
// UnifyType tphPH = tf.getPlaceholderType("PH");
// UnifyType tphPI = tf.getPlaceholderType("PI");
// UnifyType tphE4 = tf.getPlaceholderType("E4");
// UnifyType tphB = tf.getPlaceholderType("B");
//
// UnifyType integer = tf.getSimpleType("java.lang.Integer");
// UnifyType voidType = tf.getSimpleType("void");
// UnifyType bool = tf.getSimpleType("java.lang.Boolean");
// UnifyType object = tf.getSimpleType("java.lang.Object");
// UnifyType doubl = tf.getSimpleType("java.lang.Double");
// UnifyType number = tf.getSimpleType("java.lang.Number");
//
// fcb.add(integer, number);
// fcb.add(bool, object);
// fcb.add(doubl, number);
// fcb.add(number, object);
// fcb.add(voidType, voidType);
//
// IFiniteClosure fc = fcb.getFiniteClosure();
//
// Set<UnifyPair> eq = new HashSet<UnifyPair>();
// eq.add(new UnifyPair(tphC, tphC, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphD, tphD, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(bool, tphPC, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(integer, tphE1, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tf.getSimpleType("Vector", integer), tf.getSimpleType("Vector", tphE1), PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(integer, tphPD, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tf.getSimpleType("Vector", integer), tf.getSimpleType("Vector", tphE3), PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphPE, bool, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphC, integer, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphPD, integer, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphPE, bool, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphE2, tphPF, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphC, integer, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tf.getSimpleType("Vector", integer), tf.getSimpleType("Vector", tphE2), PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphPG, doubl, PairOperator.SMALLERDOT));
// //eq.add(new UnifyPair(integer, doubl, PairOperator.SMALLERDOT)); KEIN WUNDER INFERIERT DAS NICHT
// eq.add(new UnifyPair(tphPF, doubl, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphPG, tphD, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tphD, tphPH, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(voidType, tphB, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(voidType, tphPI, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(tf.getSimpleType("Matrix"), tphPI, PairOperator.SMALLERDOT));
// eq.add(new UnifyPair(voidType, tphPI, PairOperator.SMALLERDOT));
//
// Set<Set<UnifyPair>> expected = new HashSet<>();
//
// Set<Set<UnifyPair>> actual = unify(eq, fc);
//
// System.out.println("Test Void:");
// System.out.println(actual);
//
// //Assert.assertEquals(expected, actual);
// }
@Test
public void unifyTestLambda6() {
// [(D <. D),
// (R455538610 <. ND),
// (Matrix <. T1455538610),
// (C <. T2455538610),
// (B <. Fun2<R455538610,T1455538610,T2455538610>),
// (ND <. NE),
// (Fun1<? extends NE,? super B> <. NC),
// (NC <. NF),
// (Fun1<? extends NF,? super C> <. NB),
// (NB <. D),
// (void <. NG),
// (Matrix <. java.lang.Object),
// (void <. void)]
TypeFactory tf = new TypeFactory();
FiniteClosureBuilder fcb = new FiniteClosureBuilder();
UnifyType tphD = tf.getPlaceholderType("D");
UnifyType tphND = tf.getPlaceholderType("ND");
UnifyType tphR4 = tf.getPlaceholderType("R4");
UnifyType tphT1 = tf.getPlaceholderType("T1");
UnifyType tphT2 = tf.getPlaceholderType("T2");
UnifyType tphC = tf.getPlaceholderType("C");
UnifyType tphNE = tf.getPlaceholderType("NE");
UnifyType tphNC = tf.getPlaceholderType("NC");
UnifyType tphB = tf.getPlaceholderType("B");
UnifyType tphNF = tf.getPlaceholderType("NF");
UnifyType tphNB = tf.getPlaceholderType("NB");
UnifyType tphNG = tf.getPlaceholderType("NG");
UnifyType voidType = tf.getSimpleType("void");
UnifyType object = tf.getSimpleType("java.lang.Object");
UnifyType matrix = tf.getSimpleType("java.lang.Matrix");
UnifyType r = tf.getPlaceholderType("R");
UnifyType t1 = tf.getPlaceholderType("T1");
UnifyType t2 = tf.getPlaceholderType("T2");
UnifyType fun1 = FunNType.getFunNType(new TypeParams(r, t1));
UnifyType fun2 = FunNType.getFunNType(new TypeParams(r, t1, t2));
fcb.add(matrix, object);
fcb.add(voidType, voidType);
IFiniteClosure fc = fcb.getFiniteClosure();
Set<UnifyPair> eq = new HashSet<UnifyPair>();
eq.add(new UnifyPair(tphD, tphD, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphR4, tphND, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(matrix, tphT1, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphC, tphT2, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphB, FunNType.getFunNType(new TypeParams(tphR4, tphT1, tphT2)), PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphND, tphNE, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(FunNType.getFunNType(new TypeParams(tphNE, tphB)), tphNC, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphNC, tphNF, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(FunNType.getFunNType(new TypeParams(tphNF, tphC)), tphNB, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphNB, tphD, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(voidType, tphNG, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(matrix, object, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(voidType, voidType, PairOperator.SMALLERDOT));
Set<Set<UnifyPair>> expected = new HashSet<>();
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Test Lambda6:");
System.out.println(actual);
//Assert.assertEquals(expected, actual);
}
@Test
public void unifyTestOverloading(){
/*
@ -723,7 +890,7 @@ public class UnifyTest extends TypeUnify{
expectedSolution.add(new UnifyPair(tphT1, ol, PairOperator.EQUALSDOT));
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Test Overloading:");
System.out.println(actual);
@ -774,7 +941,7 @@ public class UnifyTest extends TypeUnify{
solution.add(new UnifyPair(tphT2, integer, PairOperator.EQUALSDOT));
expected.add(solution);
Set<Set<UnifyPair>> actual = unify(eq, fc);
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Test Subclass:");
System.out.println(actual);