Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Ruben
|
e1007cce30 |
@@ -18,7 +18,7 @@ jobs:
|
||||
uses: actions/setup-java@v4
|
||||
with:
|
||||
distribution: 'temurin'
|
||||
java-version: '25'
|
||||
java-version: '24'
|
||||
cache: 'maven'
|
||||
- name: Compile project
|
||||
run: |
|
||||
|
||||
@@ -24,7 +24,7 @@ jobs:
|
||||
uses: actions/setup-java@v4
|
||||
with:
|
||||
distribution: 'temurin'
|
||||
java-version: '25'
|
||||
java-version: '24'
|
||||
cache: 'maven'
|
||||
- name: Compile project
|
||||
run: |
|
||||
|
||||
@@ -44,11 +44,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
|
||||
<artifactId>asm</artifactId>
|
||||
<version>9.8</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.ow2.asm</groupId>
|
||||
<artifactId>asm-util</artifactId>
|
||||
<version>9.8</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
@@ -77,8 +72,9 @@ http://maven.apache.org/maven-v4_0_0.xsd">
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>3.14.0</version>
|
||||
<configuration>
|
||||
<source>25</source>
|
||||
<target>25</target>
|
||||
<compilerArgs>--enable-preview</compilerArgs>
|
||||
<source>24</source>
|
||||
<target>24</target>
|
||||
</configuration>
|
||||
</plugin>
|
||||
<plugin>
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
class Bug378Id {
|
||||
id2 = x -> x;
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
import Bug378Id;
|
||||
import java.lang.Integer;
|
||||
|
||||
public class Bug378Main {
|
||||
public static main(args) {
|
||||
var hallo = (new Bug378Id<Integer>().id2).apply(1);
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
import java.lang.Integer;
|
||||
import java.lang.Double;
|
||||
import java.lang.System;
|
||||
import java.io.PrintStream;
|
||||
|
||||
public class Bug379 {
|
||||
public Fun1$$<Double, Double> fact = (x) -> {
|
||||
if (x == 1) {
|
||||
return 1;
|
||||
} else {
|
||||
return x * (fact.apply(x-1));
|
||||
}
|
||||
};
|
||||
|
||||
public getFact(x) {
|
||||
return fact.apply(x);
|
||||
}
|
||||
|
||||
public static void main(x) {
|
||||
var f = new Bug379();
|
||||
var intRes = f.getFact(3);
|
||||
System.out.println(intRes);
|
||||
}
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
sealed interface List<T> permits Cons, Empty {}
|
||||
record Cons<T>(T a , List<T> l ) implements List <T> {}
|
||||
record Empty<T>() implements List <T> {}
|
||||
|
||||
public class Bug380 {
|
||||
public <T> List<T> append(l1, List<T> l2) {
|
||||
return switch ( l1 ) {
|
||||
case Cons(e, rest) -> new Cons<>(e, append(rest, l2)); //::Typ TPH A
|
||||
case Empty() -> l2;//::TPH B
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
import java.lang.Runnable;
|
||||
import java.lang.String;
|
||||
import java.lang.System;
|
||||
import java.io.PrintStream;
|
||||
import java.lang.Thread;
|
||||
|
||||
public class Bug382 {
|
||||
public static main(a) {
|
||||
var f = () -> System.out.println("Hallo Welt!");
|
||||
new Thread(f).run();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
import java.lang.String;
|
||||
import java.lang.System;
|
||||
import java.io.PrintStream;
|
||||
|
||||
public class Bug383 {
|
||||
public static main(a) {
|
||||
var f = () -> System.out.println("Hello from Thread!");
|
||||
f.apply();
|
||||
}
|
||||
}
|
||||
@@ -1,18 +1,17 @@
|
||||
import java.lang.Integer;
|
||||
import java.lang.Double;
|
||||
import java.lang.Number;
|
||||
import java.lang.String;
|
||||
|
||||
public record R(String n) {}
|
||||
public record R(Number n) {}
|
||||
|
||||
public class SwitchOverload {
|
||||
|
||||
f() { return 10; }
|
||||
g() { return 20; }
|
||||
public f(){}
|
||||
|
||||
public m(r) {
|
||||
return switch(r) {
|
||||
case R("test") -> f();
|
||||
case R("foo") -> g();
|
||||
case R r -> 0;
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -125,7 +125,7 @@ public class Codegen {
|
||||
}
|
||||
|
||||
private void popValue(State state, TargetType type) {
|
||||
if (type.equals(TargetType.double_) || type.equals(TargetType.long_))
|
||||
if (type.equals(TargetType.Double) || type.equals(TargetType.Long))
|
||||
state.mv.visitInsn(POP2);
|
||||
else
|
||||
state.mv.visitInsn(POP);
|
||||
@@ -134,21 +134,21 @@ public class Codegen {
|
||||
private void boxPrimitive(State state, TargetType type) {
|
||||
if (type instanceof TargetExtendsWildcard ew) type = ew.innerType();
|
||||
var mv = state.mv;
|
||||
if (type.equals(TargetType.boolean_)) {
|
||||
if (type.equals(TargetType.Boolean) || type.equals(TargetType.boolean_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
|
||||
} else if (type.equals(TargetType.byte_)) {
|
||||
} else if (type.equals(TargetType.Byte) || type.equals(TargetType.byte_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;", false);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
} else if (type.equals(TargetType.Double) || type.equals(TargetType.double_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false);
|
||||
} else if (type.equals(TargetType.long_)) {
|
||||
} else if (type.equals(TargetType.Long) || type.equals(TargetType.long_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;", false);
|
||||
} else if (type.equals(TargetType.int_)) {
|
||||
} else if (type.equals(TargetType.Integer) || type.equals(TargetType.int_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
} else if (type.equals(TargetType.Float) || type.equals(TargetType.float_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false);
|
||||
} else if (type.equals(TargetType.short_)) {
|
||||
} else if (type.equals(TargetType.Short) || type.equals(TargetType.short_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;", false);
|
||||
} else if (type.equals(TargetType.char_)) {
|
||||
} else if (type.equals(TargetType.Char) || type.equals(TargetType.char_)) {
|
||||
mv.visitMethodInsn(INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false);
|
||||
}
|
||||
}
|
||||
@@ -185,11 +185,9 @@ public class Codegen {
|
||||
convertTo(state, op.right().type(), type);
|
||||
mv.visitJumpInsn(code, if_true);
|
||||
mv.visitInsn(ICONST_0);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(GOTO, end);
|
||||
mv.visitLabel(if_true);
|
||||
mv.visitInsn(ICONST_1);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitLabel(end);
|
||||
}
|
||||
|
||||
@@ -204,11 +202,9 @@ public class Codegen {
|
||||
mv.visitInsn(cmp);
|
||||
mv.visitJumpInsn(code, if_true);
|
||||
mv.visitInsn(ICONST_0);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(GOTO, end);
|
||||
mv.visitLabel(if_true);
|
||||
mv.visitInsn(ICONST_1);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitLabel(end);
|
||||
}
|
||||
|
||||
@@ -237,85 +233,65 @@ public class Codegen {
|
||||
if (source instanceof TargetExtendsWildcard ew) source = ew.innerType();
|
||||
if (dest instanceof TargetExtendsWildcard ew) dest = ew.innerType();
|
||||
|
||||
var mv = state.mv;
|
||||
if (source.equals(dest))
|
||||
return;
|
||||
|
||||
if (isFunctionalInterface(source) && isFunctionalInterface(dest) &&
|
||||
if (source.equals(TargetType.Long)) {
|
||||
if (dest.equals(TargetType.Integer))
|
||||
mv.visitInsn(L2I);
|
||||
else if (dest.equals(TargetType.Float))
|
||||
mv.visitInsn(L2F);
|
||||
else if (dest.equals(TargetType.Double))
|
||||
mv.visitInsn(L2D);
|
||||
else if (dest.equals(TargetType.Byte) || dest.equals(TargetType.Char) || dest.equals(TargetType.Short)) {
|
||||
mv.visitInsn(L2I);
|
||||
convertTo(state, TargetType.Integer, dest);
|
||||
}
|
||||
} else if (source.equals(TargetType.Float)) {
|
||||
if (dest.equals(TargetType.Integer))
|
||||
mv.visitInsn(F2I);
|
||||
else if (dest.equals(TargetType.Double))
|
||||
mv.visitInsn(F2D);
|
||||
else if (dest.equals(TargetType.Long))
|
||||
mv.visitInsn(F2L);
|
||||
else if (dest.equals(TargetType.Byte) || dest.equals(TargetType.Char) || dest.equals(TargetType.Short)) {
|
||||
mv.visitInsn(F2I);
|
||||
convertTo(state, TargetType.Integer, dest);
|
||||
}
|
||||
} else if (source.equals(TargetType.Double)) {
|
||||
if (dest.equals(TargetType.Integer))
|
||||
mv.visitInsn(D2I);
|
||||
else if (dest.equals(TargetType.Float))
|
||||
mv.visitInsn(D2F);
|
||||
else if (dest.equals(TargetType.Long))
|
||||
mv.visitInsn(D2L);
|
||||
else if (dest.equals(TargetType.Byte) || dest.equals(TargetType.Char) || dest.equals(TargetType.Short)) {
|
||||
mv.visitInsn(D2I);
|
||||
convertTo(state, TargetType.Integer, dest);
|
||||
}
|
||||
} else if (source.equals(TargetType.Byte) || source.equals(TargetType.Char) || source.equals(TargetType.Short) || source.equals(TargetType.Integer)) {
|
||||
if (dest.equals(TargetType.Byte))
|
||||
mv.visitInsn(I2B);
|
||||
else if (dest.equals(TargetType.Char))
|
||||
mv.visitInsn(I2C);
|
||||
else if (dest.equals(TargetType.Short))
|
||||
mv.visitInsn(I2S);
|
||||
else if (dest.equals(TargetType.Long))
|
||||
mv.visitInsn(I2L);
|
||||
else if (dest.equals(TargetType.Float))
|
||||
mv.visitInsn(I2F);
|
||||
else if (dest.equals(TargetType.Double))
|
||||
mv.visitInsn(I2D);
|
||||
} else if (source.equals(TargetType.Boolean)) {
|
||||
unboxPrimitive(state, dest);
|
||||
} else if (isFunctionalInterface(source) && isFunctionalInterface(dest) &&
|
||||
!(source instanceof TargetFunNType && dest instanceof TargetFunNType)) {
|
||||
boxFunctionalInterface(state, source, dest);
|
||||
return;
|
||||
}
|
||||
|
||||
var mv = state.mv;
|
||||
if ((source instanceof TargetRefType || source instanceof TargetGenericType) &&
|
||||
(dest instanceof TargetRefType || dest instanceof TargetGenericType)) {
|
||||
if (dest instanceof TargetGenericType) return;
|
||||
} else if (!(dest instanceof TargetGenericType)) {
|
||||
//boxPrimitive(state, source);
|
||||
mv.visitTypeInsn(CHECKCAST, dest.getInternalName());
|
||||
return;
|
||||
}
|
||||
|
||||
if (!(source instanceof TargetPrimitiveType)) {
|
||||
unboxPrimitive(state, source);
|
||||
source = TargetType.toPrimitive(source);
|
||||
}
|
||||
|
||||
var origDest = dest;
|
||||
dest = TargetType.toPrimitive(dest);
|
||||
if (source.equals(TargetType.long_)) {
|
||||
if (dest.equals(TargetType.int_))
|
||||
mv.visitInsn(L2I);
|
||||
else if (dest.equals(TargetType.float_))
|
||||
mv.visitInsn(L2F);
|
||||
else if (dest.equals(TargetType.double_))
|
||||
mv.visitInsn(L2D);
|
||||
else if (dest.equals(TargetType.byte_) || dest.equals(TargetType.char_) || dest.equals(TargetType.short_)) {
|
||||
mv.visitInsn(L2I);
|
||||
convertTo(state, TargetType.int_, dest);
|
||||
}
|
||||
} else if (source.equals(TargetType.float_)) {
|
||||
if (dest.equals(TargetType.int_))
|
||||
mv.visitInsn(F2I);
|
||||
else if (dest.equals(TargetType.double_))
|
||||
mv.visitInsn(F2D);
|
||||
else if (dest.equals(TargetType.long_))
|
||||
mv.visitInsn(F2L);
|
||||
else if (dest.equals(TargetType.byte_) || dest.equals(TargetType.char_) || dest.equals(TargetType.short_)) {
|
||||
mv.visitInsn(F2I);
|
||||
convertTo(state, TargetType.int_, dest);
|
||||
}
|
||||
} else if (source.equals(TargetType.double_)) {
|
||||
if (dest.equals(TargetType.int_))
|
||||
mv.visitInsn(D2I);
|
||||
else if (dest.equals(TargetType.float_))
|
||||
mv.visitInsn(D2F);
|
||||
else if (dest.equals(TargetType.long_))
|
||||
mv.visitInsn(D2L);
|
||||
else if (dest.equals(TargetType.byte_) || dest.equals(TargetType.char_) || dest.equals(TargetType.short_)) {
|
||||
mv.visitInsn(D2I);
|
||||
convertTo(state, TargetType.int_, dest);
|
||||
}
|
||||
} else if (source.equals(TargetType.byte_) || source.equals(TargetType.char_) || source.equals(TargetType.short_) || source.equals(TargetType.int_)) {
|
||||
if (dest.equals(TargetType.byte_))
|
||||
mv.visitInsn(I2B);
|
||||
else if (dest.equals(TargetType.char_))
|
||||
mv.visitInsn(I2C);
|
||||
else if (dest.equals(TargetType.short_))
|
||||
mv.visitInsn(I2S);
|
||||
else if (dest.equals(TargetType.long_))
|
||||
mv.visitInsn(I2L);
|
||||
else if (dest.equals(TargetType.float_))
|
||||
mv.visitInsn(I2F);
|
||||
else if (dest.equals(TargetType.double_))
|
||||
mv.visitInsn(I2D);
|
||||
} else if (source.equals(TargetType.boolean_)) {
|
||||
unboxPrimitive(state, dest);
|
||||
}
|
||||
|
||||
if (!(origDest instanceof TargetPrimitiveType)) {
|
||||
if (dest instanceof TargetPrimitiveType)
|
||||
boxPrimitive(state, dest);
|
||||
else boxPrimitive(state, source);
|
||||
}
|
||||
}
|
||||
|
||||
record TypePair(TargetType from, TargetType to) {}
|
||||
@@ -374,9 +350,9 @@ public class Codegen {
|
||||
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V", false);
|
||||
} else {
|
||||
generate(state, add.left());
|
||||
convertTo(state, add.left().type(), TargetType.toPrimitive(add.type()));
|
||||
convertTo(state, add.left().type(), add.type());
|
||||
generate(state, add.right());
|
||||
convertTo(state, add.right().type(), TargetType.toPrimitive(add.type()));
|
||||
convertTo(state, add.right().type(), add.type());
|
||||
var type = add.type();
|
||||
if (type.equals(TargetType.Byte) || type.equals(TargetType.Char) || type.equals(TargetType.Integer) || type.equals(TargetType.Short)) {
|
||||
mv.visitInsn(IADD);
|
||||
@@ -389,7 +365,6 @@ public class Codegen {
|
||||
} else {
|
||||
throw new CodeGenException("Invalid argument to Add expression, type: " + add.type());
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
}
|
||||
if (add.type().equals(TargetType.String)) {
|
||||
generate(state, add.right());
|
||||
@@ -401,9 +376,9 @@ public class Codegen {
|
||||
}
|
||||
case Sub sub: {
|
||||
generate(state, sub.left());
|
||||
convertTo(state, sub.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, sub.left().type(), op.type());
|
||||
generate(state, sub.right());
|
||||
convertTo(state, sub.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, sub.right().type(), op.type());
|
||||
var type = sub.type();
|
||||
if (type.equals(TargetType.Byte) || type.equals(TargetType.Char) || type.equals(TargetType.Integer) || type.equals(TargetType.Short)) {
|
||||
mv.visitInsn(ISUB);
|
||||
@@ -416,14 +391,13 @@ public class Codegen {
|
||||
} else {
|
||||
throw new CodeGenException("Invalid argument to Sub expression");
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Div div: {
|
||||
generate(state, div.left());
|
||||
convertTo(state, div.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, div.left().type(), op.type());
|
||||
generate(state, div.right());
|
||||
convertTo(state, div.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, div.right().type(), op.type());
|
||||
var type = div.type();
|
||||
if (type.equals(TargetType.Byte) || type.equals(TargetType.Char) || type.equals(TargetType.Integer) || type.equals(TargetType.Short)) {
|
||||
mv.visitInsn(IDIV);
|
||||
@@ -436,14 +410,13 @@ public class Codegen {
|
||||
} else {
|
||||
throw new CodeGenException("Invalid argument to Div expression");
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Mul mul: {
|
||||
generate(state, mul.left());
|
||||
convertTo(state, mul.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, mul.left().type(), op.type());
|
||||
generate(state, mul.right());
|
||||
convertTo(state, mul.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, mul.right().type(), op.type());
|
||||
var type = mul.type();
|
||||
if (type.equals(TargetType.Byte) || type.equals(TargetType.Char) || type.equals(TargetType.Integer) || type.equals(TargetType.Short)) {
|
||||
mv.visitInsn(IMUL);
|
||||
@@ -456,14 +429,13 @@ public class Codegen {
|
||||
} else {
|
||||
throw new CodeGenException("Invalid argument to Mul expression");
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Rem rem: {
|
||||
generate(state, rem.left());
|
||||
convertTo(state, rem.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, rem.left().type(), op.type());
|
||||
generate(state, rem.right());
|
||||
convertTo(state, rem.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, rem.right().type(), op.type());
|
||||
var type = rem.type();
|
||||
if (type.equals(TargetType.Byte) || type.equals(TargetType.Char) || type.equals(TargetType.Integer) || type.equals(TargetType.Short)) {
|
||||
mv.visitInsn(IREM);
|
||||
@@ -476,7 +448,6 @@ public class Codegen {
|
||||
} else {
|
||||
throw new CodeGenException("Invalid argument to Rem expression");
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Or or: {
|
||||
@@ -484,18 +455,14 @@ public class Codegen {
|
||||
Label or_true = new Label();
|
||||
Label end = new Label();
|
||||
generate(state, or.left());
|
||||
convertTo(state, or.left().type(), TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(IFNE, or_true);
|
||||
generate(state, or.right());
|
||||
convertTo(state, or.right().type(), TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(IFEQ, or_false);
|
||||
mv.visitLabel(or_true);
|
||||
mv.visitInsn(ICONST_1);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(GOTO, end);
|
||||
mv.visitLabel(or_false);
|
||||
mv.visitInsn(ICONST_0);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitLabel(end);
|
||||
break;
|
||||
}
|
||||
@@ -503,54 +470,47 @@ public class Codegen {
|
||||
Label and_false = new Label();
|
||||
Label end = new Label();
|
||||
generate(state, and.left());
|
||||
convertTo(state, and.left().type(), TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(IFEQ, and_false);
|
||||
generate(state, and.right());
|
||||
convertTo(state, and.right().type(), TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(IFEQ, and_false);
|
||||
mv.visitInsn(ICONST_1);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitJumpInsn(GOTO, end);
|
||||
mv.visitLabel(and_false);
|
||||
mv.visitInsn(ICONST_0);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitLabel(end);
|
||||
break;
|
||||
}
|
||||
case BAnd band: {
|
||||
generate(state, band.left());
|
||||
convertTo(state, band.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, band.left().type(), op.type());
|
||||
generate(state, band.right());
|
||||
convertTo(state, band.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, band.right().type(), op.type());
|
||||
if (band.type().equals(TargetType.Long))
|
||||
mv.visitInsn(LAND);
|
||||
else
|
||||
mv.visitInsn(IAND);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case BOr bor: {
|
||||
generate(state, bor.left());
|
||||
convertTo(state, bor.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, bor.left().type(), op.type());
|
||||
generate(state, bor.right());
|
||||
convertTo(state, bor.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, bor.right().type(), op.type());
|
||||
if (bor.type().equals(TargetType.Long))
|
||||
mv.visitInsn(LOR);
|
||||
else
|
||||
mv.visitInsn(IOR);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case XOr xor: {
|
||||
generate(state, xor.left());
|
||||
convertTo(state, xor.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, xor.left().type(), op.type());
|
||||
generate(state, xor.right());
|
||||
convertTo(state, xor.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, xor.right().type(), op.type());
|
||||
if (xor.type().equals(TargetType.Long))
|
||||
mv.visitInsn(LXOR);
|
||||
else
|
||||
mv.visitInsn(IXOR);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Instof instof: {
|
||||
@@ -559,47 +519,44 @@ public class Codegen {
|
||||
}
|
||||
case Shl shl: {
|
||||
generate(state, shl.left());
|
||||
convertTo(state, shl.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, shl.left().type(), op.type());
|
||||
generate(state, shl.right());
|
||||
convertTo(state, shl.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, shl.right().type(), op.type());
|
||||
if (shl.type().equals(TargetType.Long))
|
||||
mv.visitInsn(LSHL);
|
||||
else
|
||||
mv.visitInsn(ISHL);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Shr shr: {
|
||||
generate(state, shr.left());
|
||||
convertTo(state, shr.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, shr.left().type(), op.type());
|
||||
generate(state, shr.right());
|
||||
convertTo(state, shr.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, shr.right().type(), op.type());
|
||||
if (shr.type().equals(TargetType.Long))
|
||||
mv.visitInsn(LSHR);
|
||||
else
|
||||
mv.visitInsn(ISHR);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case UShr ushr: {
|
||||
generate(state, ushr.left());
|
||||
convertTo(state, ushr.left().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, ushr.left().type(), op.type());
|
||||
generate(state, ushr.right());
|
||||
convertTo(state, ushr.right().type(), TargetType.toPrimitive(op.type()));
|
||||
convertTo(state, ushr.right().type(), op.type());
|
||||
if (ushr.type().equals(TargetType.Long))
|
||||
mv.visitInsn(LUSHR);
|
||||
else
|
||||
mv.visitInsn(IUSHR);
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
break;
|
||||
}
|
||||
case Greater greater: {
|
||||
var type = TargetType.toPrimitive(largerType(greater.left().type(), greater.right().type()));
|
||||
if (type.equals(TargetType.long_)) {
|
||||
var type = largerType(greater.left().type(), greater.right().type());
|
||||
if (type.equals(TargetType.Long)) {
|
||||
generateRelationalOperator(state, greater, type, LCMP, IFGT);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
} else if (type.equals(TargetType.Float)) {
|
||||
generateRelationalOperator(state, greater, type, FCMPL, IFGT);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
} else if (type.equals(TargetType.Double)) {
|
||||
generateRelationalOperator(state, greater, type, DCMPL, IFGT);
|
||||
} else {
|
||||
generateRelationalOperator(state, greater, type, IF_ICMPGT);
|
||||
@@ -607,12 +564,12 @@ public class Codegen {
|
||||
break;
|
||||
}
|
||||
case Less less: {
|
||||
var type = TargetType.toPrimitive(largerType(less.left().type(), less.right().type()));
|
||||
if (type.equals(TargetType.long_)) {
|
||||
var type = largerType(less.left().type(), less.right().type());
|
||||
if (type.equals(TargetType.Long)) {
|
||||
generateRelationalOperator(state, less, type, LCMP, IFLT);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
} else if (type.equals(TargetType.Float)) {
|
||||
generateRelationalOperator(state, less, type, FCMPL, IFLT);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
} else if (type.equals(TargetType.Double)) {
|
||||
generateRelationalOperator(state, less, type, DCMPL, IFLT);
|
||||
} else {
|
||||
generateRelationalOperator(state, less, type, IF_ICMPLT);
|
||||
@@ -620,12 +577,12 @@ public class Codegen {
|
||||
break;
|
||||
}
|
||||
case GreaterOrEqual greaterOrEqual: {
|
||||
var type = TargetType.toPrimitive(largerType(greaterOrEqual.left().type(), greaterOrEqual.right().type()));
|
||||
if (type.equals(TargetType.long_)) {
|
||||
var type = largerType(greaterOrEqual.left().type(), greaterOrEqual.right().type());
|
||||
if (type.equals(TargetType.Long)) {
|
||||
generateRelationalOperator(state, greaterOrEqual, type, LCMP, IFGE);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
} else if (type.equals(TargetType.Float)) {
|
||||
generateRelationalOperator(state, greaterOrEqual, type, FCMPL, IFGE);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
} else if (type.equals(TargetType.Double)) {
|
||||
generateRelationalOperator(state, greaterOrEqual, type, DCMPL, IFGE);
|
||||
} else {
|
||||
generateRelationalOperator(state, greaterOrEqual, type, IF_ICMPGE);
|
||||
@@ -633,12 +590,12 @@ public class Codegen {
|
||||
break;
|
||||
}
|
||||
case LessOrEqual lessOrEqual: {
|
||||
var type = TargetType.toPrimitive(largerType(lessOrEqual.left().type(), lessOrEqual.right().type()));
|
||||
if (type.equals(TargetType.long_)) {
|
||||
var type = largerType(lessOrEqual.left().type(), lessOrEqual.right().type());
|
||||
if (type.equals(TargetType.Long)) {
|
||||
generateRelationalOperator(state, lessOrEqual, type, LCMP, IFLE);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
} else if (type.equals(TargetType.Float)) {
|
||||
generateRelationalOperator(state, lessOrEqual, type, FCMPL, IFLE);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
} else if (type.equals(TargetType.Double)) {
|
||||
generateRelationalOperator(state, lessOrEqual, type, DCMPL, IFLE);
|
||||
} else {
|
||||
generateRelationalOperator(state, lessOrEqual, type, IF_ICMPLE);
|
||||
@@ -646,30 +603,30 @@ public class Codegen {
|
||||
break;
|
||||
}
|
||||
case Equal equal: {
|
||||
var type = TargetType.toPrimitive(largerType(equal.left().type(), equal.right().type()));
|
||||
if (type.equals(TargetType.long_)) {
|
||||
generateRelationalOperator(state, equal, TargetType.long_, LCMP, IFEQ);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
generateRelationalOperator(state, equal, TargetType.float_, FCMPL, IFEQ);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
generateRelationalOperator(state, equal, TargetType.double_, DCMPL, IFEQ);
|
||||
} else if (type.equals(TargetType.char_) || type.equals(TargetType.short_) || type.equals(TargetType.byte_) || type.equals(TargetType.int_) || type.equals(TargetType.boolean_)) {
|
||||
generateRelationalOperator(state, equal, TargetType.int_, IF_ICMPEQ);
|
||||
var type = largerType(equal.left().type(), equal.right().type());
|
||||
if (type.equals(TargetType.Long)) {
|
||||
generateRelationalOperator(state, equal, type, LCMP, IFEQ);
|
||||
} else if (type.equals(TargetType.Float)) {
|
||||
generateRelationalOperator(state, equal, type, FCMPL, IFEQ);
|
||||
} else if (type.equals(TargetType.Double)) {
|
||||
generateRelationalOperator(state, equal, type, DCMPL, IFEQ);
|
||||
} else if (type.equals(TargetType.Char) || type.equals(TargetType.Short) || type.equals(TargetType.Byte) || type.equals(TargetType.Integer) || type.equals(TargetType.Boolean)) {
|
||||
generateRelationalOperator(state, equal, type, IF_ICMPEQ);
|
||||
} else {
|
||||
generateRelationalOperator(state, equal, type, IF_ACMPEQ);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case NotEqual notEqual: {
|
||||
var type = TargetType.toPrimitive(largerType(notEqual.left().type(), notEqual.right().type()));
|
||||
if (type.equals(TargetType.long_)) {
|
||||
generateRelationalOperator(state, notEqual, TargetType.long_, LCMP, IFNE);
|
||||
} else if (type.equals(TargetType.float_)) {
|
||||
generateRelationalOperator(state, notEqual, TargetType.float_, FCMPL, IFNE);
|
||||
} else if (type.equals(TargetType.double_)) {
|
||||
generateRelationalOperator(state, notEqual, TargetType.double_, DCMPL, IFNE);
|
||||
} else if (type.equals(TargetType.char_) || type.equals(TargetType.short_) || type.equals(TargetType.byte_) || type.equals(TargetType.int_) || type.equals(TargetType.boolean_)) {
|
||||
generateRelationalOperator(state, notEqual, TargetType.int_, IF_ICMPNE);
|
||||
var type = largerType(notEqual.left().type(), notEqual.right().type());
|
||||
if (type.equals(TargetType.Long)) {
|
||||
generateRelationalOperator(state, notEqual, type, LCMP, IFNE);
|
||||
} else if (type.equals(TargetType.Float)) {
|
||||
generateRelationalOperator(state, notEqual, type, FCMPL, IFNE);
|
||||
} else if (type.equals(TargetType.Double)) {
|
||||
generateRelationalOperator(state, notEqual, type, DCMPL, IFNE);
|
||||
} else if (type.equals(TargetType.Char) || type.equals(TargetType.Short) || type.equals(TargetType.Byte) || type.equals(TargetType.Integer)) {
|
||||
generateRelationalOperator(state, notEqual, type, IF_ICMPNE);
|
||||
} else {
|
||||
generateRelationalOperator(state, notEqual, type, IF_ACMPNE);
|
||||
}
|
||||
@@ -700,7 +657,6 @@ public class Codegen {
|
||||
generate(state, add.expr());
|
||||
case TargetUnaryOp.Negate negate -> {
|
||||
generate(state, negate.expr());
|
||||
convertTo(state, negate.expr().type(), TargetType.boolean_);
|
||||
if (negate.type().equals(TargetType.Double))
|
||||
mv.visitInsn(DNEG);
|
||||
else if (negate.type().equals(TargetType.Float))
|
||||
@@ -709,11 +665,9 @@ public class Codegen {
|
||||
mv.visitInsn(LNEG);
|
||||
else
|
||||
mv.visitInsn(INEG);
|
||||
boxPrimitive(state, TargetType.toPrimitive(negate.expr().type()));
|
||||
}
|
||||
case TargetUnaryOp.Not not -> {
|
||||
generate(state, not.expr());
|
||||
convertTo(state, not.expr().type(), TargetType.boolean_);
|
||||
if (not.type().equals(TargetType.Long)) {
|
||||
mv.visitLdcInsn(-1L);
|
||||
mv.visitInsn(LXOR);
|
||||
@@ -721,86 +675,93 @@ public class Codegen {
|
||||
mv.visitInsn(ICONST_M1);
|
||||
mv.visitInsn(IXOR);
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(not.expr().type()));
|
||||
}
|
||||
case TargetUnaryOp.PreIncrement preIncrement -> {
|
||||
generate(state, preIncrement.expr());
|
||||
convertTo(state, preIncrement.expr().type(), TargetType.toPrimitive(op.type()));
|
||||
if (preIncrement.type().equals(TargetType.Float)) {
|
||||
mv.visitLdcInsn(1F);
|
||||
mv.visitInsn(FADD);
|
||||
mv.visitInsn(DUP);
|
||||
} else if (preIncrement.type().equals(TargetType.Double)) {
|
||||
mv.visitLdcInsn(1D);
|
||||
mv.visitInsn(DADD);
|
||||
mv.visitInsn(DUP2);
|
||||
} else if (preIncrement.type().equals(TargetType.Long)) {
|
||||
mv.visitLdcInsn(1L);
|
||||
mv.visitInsn(LADD);
|
||||
mv.visitInsn(DUP2);
|
||||
} else {
|
||||
mv.visitLdcInsn(1);
|
||||
mv.visitInsn(IADD);
|
||||
mv.visitInsn(DUP);
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitInsn(DUP);
|
||||
boxPrimitive(state, preIncrement.type());
|
||||
afterIncDec(state, preIncrement);
|
||||
}
|
||||
case TargetUnaryOp.PreDecrement preDecrement -> {
|
||||
generate(state, preDecrement.expr());
|
||||
convertTo(state, preDecrement.expr().type(), TargetType.toPrimitive(op.type()));
|
||||
if (preDecrement.type().equals(TargetType.Float)) {
|
||||
mv.visitLdcInsn(1F);
|
||||
mv.visitInsn(FSUB);
|
||||
mv.visitInsn(DUP);
|
||||
} else if (preDecrement.type().equals(TargetType.Double)) {
|
||||
mv.visitLdcInsn(1D);
|
||||
mv.visitInsn(DSUB);
|
||||
mv.visitInsn(DUP2);
|
||||
} else if (preDecrement.type().equals(TargetType.Long)) {
|
||||
mv.visitLdcInsn(1L);
|
||||
mv.visitInsn(LSUB);
|
||||
mv.visitInsn(DUP2);
|
||||
} else {
|
||||
mv.visitLdcInsn(1);
|
||||
mv.visitInsn(ISUB);
|
||||
mv.visitInsn(DUP);
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
mv.visitInsn(DUP);
|
||||
boxPrimitive(state, preDecrement.type());
|
||||
afterIncDec(state, preDecrement);
|
||||
}
|
||||
case TargetUnaryOp.PostIncrement postIncrement -> {
|
||||
generate(state, postIncrement.expr());
|
||||
mv.visitInsn(DUP);
|
||||
convertTo(state, postIncrement.expr().type(), TargetType.toPrimitive(op.type()));
|
||||
if (postIncrement.type().equals(TargetType.Float)) {
|
||||
mv.visitInsn(DUP);
|
||||
mv.visitLdcInsn(1F);
|
||||
mv.visitInsn(FADD);
|
||||
} else if (postIncrement.type().equals(TargetType.Double)) {
|
||||
mv.visitInsn(DUP2);
|
||||
mv.visitLdcInsn(1D);
|
||||
mv.visitInsn(DADD);
|
||||
} else if (postIncrement.type().equals(TargetType.Long)) {
|
||||
mv.visitInsn(DUP2);
|
||||
mv.visitLdcInsn(1L);
|
||||
mv.visitInsn(LADD);
|
||||
} else {
|
||||
mv.visitInsn(DUP);
|
||||
mv.visitLdcInsn(1);
|
||||
mv.visitInsn(IADD);
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
boxPrimitive(state, postIncrement.type());
|
||||
afterIncDec(state, postIncrement);
|
||||
}
|
||||
case TargetUnaryOp.PostDecrement postDecrement -> {
|
||||
generate(state, postDecrement.expr());
|
||||
mv.visitInsn(DUP);
|
||||
convertTo(state, postDecrement.expr().type(), TargetType.toPrimitive(op.type()));
|
||||
if (postDecrement.type().equals(TargetType.Float)) {
|
||||
mv.visitInsn(DUP);
|
||||
mv.visitLdcInsn(1F);
|
||||
mv.visitInsn(FSUB);
|
||||
} else if (postDecrement.type().equals(TargetType.Double)) {
|
||||
mv.visitInsn(DUP2);
|
||||
mv.visitLdcInsn(1D);
|
||||
mv.visitInsn(DSUB);
|
||||
} else if (postDecrement.type().equals(TargetType.Long)) {
|
||||
mv.visitInsn(DUP2);
|
||||
mv.visitLdcInsn(1L);
|
||||
mv.visitInsn(LSUB);
|
||||
} else {
|
||||
mv.visitInsn(DUP);
|
||||
mv.visitLdcInsn(1);
|
||||
mv.visitInsn(ISUB);
|
||||
}
|
||||
boxPrimitive(state, TargetType.toPrimitive(op.type()));
|
||||
boxPrimitive(state, postDecrement.type());
|
||||
afterIncDec(state, postDecrement);
|
||||
}
|
||||
}
|
||||
@@ -948,7 +909,7 @@ public class Codegen {
|
||||
var local = state.createVariable(varDecl.name(), varDecl.varType());
|
||||
if (varDecl.value() != null) {
|
||||
generate(state, varDecl.value());
|
||||
boxPrimitive(state, varDecl.value().type());
|
||||
boxPrimitive(state, varDecl.varType());
|
||||
mv.visitVarInsn(ASTORE, local.index());
|
||||
} else {
|
||||
mv.visitInsn(ACONST_NULL);
|
||||
@@ -997,14 +958,14 @@ public class Codegen {
|
||||
mv.visitVarInsn(ALOAD, local.index());
|
||||
// This is a bit weird but sometimes the types don't match (see lambda expressions)
|
||||
convertTo(state, local.type(), localVar.type());
|
||||
//unboxPrimitive(state, local.type());
|
||||
unboxPrimitive(state, local.type());
|
||||
break;
|
||||
}
|
||||
case TargetFieldVar dot: {
|
||||
if (!dot.isStatic())
|
||||
generate(state, dot.left());
|
||||
mv.visitFieldInsn(dot.isStatic() ? GETSTATIC : GETFIELD, dot.left().type().getInternalName(), dot.right(), dot.type().toDescriptor());
|
||||
//unboxPrimitive(state, dot.type());
|
||||
unboxPrimitive(state, dot.type());
|
||||
break;
|
||||
}
|
||||
case TargetFor _for: {
|
||||
@@ -1020,14 +981,11 @@ public class Codegen {
|
||||
Label start = new Label();
|
||||
Label end = new Label();
|
||||
mv.visitLabel(start);
|
||||
if (_for.termination() != null) {
|
||||
if (_for.termination() != null)
|
||||
generate(state, _for.termination());
|
||||
convertTo(state, _for.termination().type(), TargetType.boolean_);
|
||||
mv.visitJumpInsn(IFEQ, end);
|
||||
} else {
|
||||
else
|
||||
mv.visitInsn(ICONST_1);
|
||||
mv.visitJumpInsn(IFEQ, end);
|
||||
}
|
||||
mv.visitJumpInsn(IFEQ, end);
|
||||
|
||||
var env = new BreakEnv();
|
||||
env.startLabel = start;
|
||||
@@ -1059,7 +1017,6 @@ public class Codegen {
|
||||
Label end = new Label();
|
||||
mv.visitLabel(start);
|
||||
generate(state, _while.cond());
|
||||
convertTo(state, _while.cond().type(), TargetType.boolean_);
|
||||
mv.visitJumpInsn(IFEQ, end);
|
||||
|
||||
var env = new BreakEnv();
|
||||
@@ -1090,7 +1047,6 @@ public class Codegen {
|
||||
|
||||
mv.visitLabel(check);
|
||||
generate(state, _do.cond());
|
||||
convertTo(state, _do.cond().type(), TargetType.boolean_);
|
||||
mv.visitJumpInsn(IFEQ, end);
|
||||
mv.visitJumpInsn(GOTO, start);
|
||||
mv.visitLabel(end);
|
||||
@@ -1098,7 +1054,6 @@ public class Codegen {
|
||||
}
|
||||
case TargetIf _if: {
|
||||
generate(state, _if.cond());
|
||||
convertTo(state, _if.cond().type(), TargetType.boolean_);
|
||||
Label _else = new Label();
|
||||
Label end = new Label();
|
||||
mv.visitJumpInsn(IFEQ, _else);
|
||||
@@ -1112,23 +1067,20 @@ public class Codegen {
|
||||
break;
|
||||
}
|
||||
case TargetReturn ret: {
|
||||
if (ret.expression() != null) {
|
||||
if (ret.expression() != null && state.returnType != null) {
|
||||
if (state.returnType instanceof TargetPrimitiveType) {
|
||||
generate(state, ret.expression());
|
||||
// Lambdas wrap the expression in a return if they are a single expression
|
||||
// It means we have to execute the code anyway but not return anything
|
||||
if (state.returnType != null) {
|
||||
convertTo(state, ret.expression().type(), state.returnType);
|
||||
mv.visitInsn(findReturnCode(state.returnType));
|
||||
}
|
||||
|
||||
unboxPrimitive(state, state.returnType);
|
||||
mv.visitInsn(findReturnCode(state.returnType));
|
||||
} else {
|
||||
generate(state, ret.expression());
|
||||
if (state.returnType != null) {
|
||||
convertTo(state, ret.expression().type(), state.returnType);
|
||||
mv.visitInsn(ARETURN);
|
||||
}
|
||||
boxPrimitive(state, ret.expression().type());
|
||||
convertTo(state, ret.expression().type(), state.returnType);
|
||||
mv.visitInsn(ARETURN);
|
||||
}
|
||||
} else mv.visitInsn(RETURN);
|
||||
} else
|
||||
mv.visitInsn(RETURN);
|
||||
break;
|
||||
}
|
||||
case TargetYield yield: {
|
||||
@@ -1175,14 +1127,12 @@ public class Codegen {
|
||||
var arg = call.parameterTypes().get(i);
|
||||
generate(state, e);
|
||||
convertTo(state, e.type(), arg);
|
||||
if (!(arg instanceof TargetPrimitiveType))
|
||||
boxPrimitive(state, e.type());
|
||||
}
|
||||
var descriptor = call.getDescriptor();
|
||||
if (call.owner() instanceof TargetFunNType owner) {
|
||||
// Decay FunN
|
||||
descriptor = TargetMethod.getDescriptor(
|
||||
(owner.returnArguments() == 0 ? null : TargetType.Object),
|
||||
call.parameterTypes().stream().map(x -> TargetType.Object).toArray(TargetType[]::new));
|
||||
}
|
||||
if (call.owner() instanceof TargetFunNType) // Decay FunN
|
||||
descriptor = TargetMethod.getDescriptor(call.returnType() == null ? null : TargetType.Object, call.parameterTypes().stream().map(x -> TargetType.Object).toArray(TargetType[]::new));
|
||||
|
||||
int insn = INVOKEVIRTUAL;
|
||||
if (call.isStatic()) insn = INVOKESTATIC;
|
||||
@@ -1191,13 +1141,11 @@ public class Codegen {
|
||||
|
||||
mv.visitMethodInsn(insn, call.owner().getInternalName(), call.name(), descriptor, call.isInterface());
|
||||
|
||||
/*if (call.type() != null && call.returnType() != null && !(call.returnType() instanceof TargetPrimitiveType)) {
|
||||
if (call.type() != null && call.returnType() != null && !(call.returnType() instanceof TargetPrimitiveType)) {
|
||||
if (!call.returnType().equals(call.type()) && !(call.type() instanceof TargetGenericType))
|
||||
mv.visitTypeInsn(CHECKCAST, call.type().getInternalName());
|
||||
unboxPrimitive(state, call.type());
|
||||
}*/
|
||||
if (call.type() != null)
|
||||
convertTo(state, call.returnType(), call.type());
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TargetLambdaExpression lambda:
|
||||
@@ -1206,10 +1154,9 @@ public class Codegen {
|
||||
case TargetNew _new: {
|
||||
mv.visitTypeInsn(NEW, _new.type().getInternalName());
|
||||
mv.visitInsn(DUP);
|
||||
for (var i = 0; i < _new.params().size(); i++) {
|
||||
var e = _new.params().get(i);
|
||||
for (TargetExpression e : _new.params()) {
|
||||
generate(state, e);
|
||||
convertTo(state, e.type(), _new.signature().get(i));
|
||||
boxPrimitive(state, e.type());
|
||||
}
|
||||
mv.visitMethodInsn(INVOKESPECIAL, _new.type().getInternalName(), "<init>", _new.getDescriptor(), false);
|
||||
break;
|
||||
@@ -1221,7 +1168,6 @@ public class Codegen {
|
||||
}
|
||||
case TargetTernary ternary: {
|
||||
generate(state, ternary.cond());
|
||||
convertTo(state, ternary.cond().type(), TargetType.boolean_);
|
||||
var iffalse = new Label();
|
||||
var end = new Label();
|
||||
mv.visitJumpInsn(IFEQ, iffalse);
|
||||
@@ -1275,7 +1221,6 @@ public class Codegen {
|
||||
if (instanceOf.right() instanceof TargetTypePattern right && right.name() == null) {
|
||||
generate(state, instanceOf.left());
|
||||
mv.visitTypeInsn(INSTANCEOF, right.type().getInternalName());
|
||||
boxPrimitive(state, TargetType.boolean_);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -1283,7 +1228,6 @@ public class Codegen {
|
||||
}
|
||||
|
||||
private void yieldValue(State state, TargetType type) {
|
||||
if (type == null) return;
|
||||
boxPrimitive(state, type);
|
||||
state.mv.visitVarInsn(ASTORE, state.switchResultValue.peek());
|
||||
}
|
||||
@@ -1299,7 +1243,6 @@ public class Codegen {
|
||||
state.pushSwitch();
|
||||
|
||||
generate(state, aSwitch.expr());
|
||||
unboxPrimitive(state, aSwitch.expr().type());
|
||||
|
||||
state.enterScope();
|
||||
|
||||
@@ -1435,7 +1378,6 @@ public class Codegen {
|
||||
|
||||
if (label instanceof TargetGuard gd) {
|
||||
generate(state, gd.expression());
|
||||
unboxPrimitive(state, TargetType.Boolean);
|
||||
var next = new Label();
|
||||
mv.visitJumpInsn(IFNE, next);
|
||||
mv.visitVarInsn(ALOAD, tmp);
|
||||
@@ -1473,7 +1415,7 @@ public class Codegen {
|
||||
if (aSwitch.isExpression()) {
|
||||
if (aSwitch.type() != null) {
|
||||
mv.visitVarInsn(ALOAD, state.switchResultValue.peek());
|
||||
//unboxPrimitive(state, aSwitch.type());
|
||||
unboxPrimitive(state, aSwitch.type());
|
||||
}
|
||||
state.popSwitch();
|
||||
}
|
||||
@@ -1490,8 +1432,8 @@ public class Codegen {
|
||||
}
|
||||
|
||||
private void bindPattern(State state, TargetType type, TargetPattern pat, Label start, int index, int depth) {
|
||||
//if (pat.type() instanceof TargetPrimitiveType)
|
||||
// boxPrimitive(state, pat.type());
|
||||
if (pat.type() instanceof TargetPrimitiveType)
|
||||
boxPrimitive(state, pat.type());
|
||||
|
||||
if (pat.type() instanceof TargetRefType) {
|
||||
state.mv.visitInsn(DUP);
|
||||
@@ -1512,14 +1454,11 @@ public class Codegen {
|
||||
}
|
||||
|
||||
if (pat instanceof TargetExpressionPattern ep) {
|
||||
var cur = state.createVariable(TargetType.toWrapper(pat.type()));
|
||||
var cur = state.createVariable(pat.type());
|
||||
state.mv.visitVarInsn(ASTORE, cur.index);
|
||||
|
||||
// For Strings we must use equals, and why not make it work for all types?
|
||||
generate(state, new TargetLocalVar(cur.type, cur.name));
|
||||
generate(state, ep.expression());
|
||||
boxPrimitive(state, ep.expression().type());
|
||||
state.mv.visitMethodInsn(INVOKESTATIC, "java/util/Objects", "equals", "(Ljava/lang/Object;Ljava/lang/Object;)Z", false);
|
||||
var expr = new Equal(pat.type(), new TargetLocalVar(cur.type, cur.name), ep.expression());
|
||||
generate(state, expr);
|
||||
|
||||
var cont = new Label();
|
||||
state.mv.visitJumpInsn(IFNE, cont);
|
||||
@@ -1717,7 +1656,7 @@ public class Codegen {
|
||||
generate(state, method.block());
|
||||
if (method.signature().returnType() == null)
|
||||
mv.visitInsn(RETURN);
|
||||
mv.visitMaxs(0, 0);
|
||||
mv.visitMaxs(0, 0);
|
||||
}
|
||||
mv.visitEnd();
|
||||
}
|
||||
@@ -1733,8 +1672,6 @@ public class Codegen {
|
||||
}
|
||||
if (clazz.superType() != null)
|
||||
ret += clazz.superType().toSignature();
|
||||
else ret += "Ljava/lang/Object;";
|
||||
|
||||
for (var intf : clazz.implementingInterfaces()) {
|
||||
ret += intf.toSignature();
|
||||
}
|
||||
@@ -1837,12 +1774,8 @@ public class Codegen {
|
||||
} else convertTo(state, fromReturn, toReturn);
|
||||
}
|
||||
|
||||
if (toReturn != null) {
|
||||
if ((fromReturn instanceof TargetRefType || fromReturn instanceof TargetGenericType)
|
||||
&& (toReturn instanceof TargetPrimitiveType))
|
||||
unboxPrimitive(state, TargetType.toWrapper(toReturn));
|
||||
if (toReturn != null)
|
||||
mv.visitInsn(findReturnCode(toReturn));
|
||||
}
|
||||
|
||||
else mv.visitInsn(RETURN);
|
||||
mv.visitMaxs(0, 0);
|
||||
@@ -1851,13 +1784,19 @@ public class Codegen {
|
||||
cw2.visitEnd();
|
||||
var bytes = cw2.toByteArray();
|
||||
compiler.auxiliaries.put(className, bytes);
|
||||
|
||||
// TODO These class loading shenanigans happen in a few places, the tests load the classes individually.
|
||||
// Instead we should just look at the folder.
|
||||
try {
|
||||
converter.classLoader.findClass(className);
|
||||
} catch (ClassNotFoundException e) {
|
||||
try {
|
||||
converter.classLoader.loadClass(className, bytes);
|
||||
} catch (LinkageError ignored) {}
|
||||
}
|
||||
}
|
||||
|
||||
cw.visitEnd();
|
||||
//ClassReader cr = new ClassReader(cw.toByteArray());
|
||||
//System.out.println("Checking class " + className);
|
||||
// TODO This fails for multi class projects because it tries to load the other classes
|
||||
//CheckClassAdapter.verify(cr, false, new PrintWriter(System.err));
|
||||
return cw.toByteArray();
|
||||
}
|
||||
|
||||
|
||||
@@ -75,7 +75,7 @@ public class FunNGenerator {
|
||||
if (type == null) return VOID;
|
||||
var res = "L" + type.getInternalName();
|
||||
if (type instanceof TargetSpecializedType a) {
|
||||
if (!a.params().isEmpty() && !(a.params().size() == 1 && a.params().getFirst() == null)) {
|
||||
if (a.params().size() > 0) {
|
||||
res += "<";
|
||||
for (var param : a.params()) {
|
||||
if (param instanceof TargetGenericType gp) {
|
||||
@@ -115,12 +115,11 @@ public class FunNGenerator {
|
||||
superFunNMethodSignature.append(String.format("T%s;", argumentGenericBase + currentParameter));
|
||||
superFunNMethodDescriptor.append(objectSignature);
|
||||
}
|
||||
superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
|
||||
if (numReturnTypes > 0) {
|
||||
superFunNClassSignature.append(String.format("%s:%s>%s", returnGeneric, objectSignature, objectSignature));
|
||||
superFunNMethodSignature.append(String.format(")T%s;", returnGeneric));
|
||||
superFunNMethodDescriptor.append(String.format(")%s", objectSignature));
|
||||
} else {
|
||||
superFunNClassSignature = new StringBuilder(objectSignature);
|
||||
superFunNMethodSignature.append(")V");
|
||||
superFunNMethodDescriptor.append(")V");
|
||||
}
|
||||
|
||||
@@ -67,8 +67,8 @@ public class LanguageServerInterface {
|
||||
compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
|
||||
|
||||
return new LanguageServerTransferObject(tiResults, parsedSource, "", compiler.getGeneratedGenerics());
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(e.getMessage(), e);
|
||||
}catch (Exception e){
|
||||
throw new RuntimeException(e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -111,7 +111,7 @@ public class SyntaxTreeGenerator {
|
||||
this.allmodifiers.put(Modifier.toString(Modifier.INTERFACE), Modifier.INTERFACE);
|
||||
this.allmodifiers.put("sealed", 4096);
|
||||
this.allmodifiers.put("non-sealed", 8192);
|
||||
this.allmodifiers.put("default", 0); // Doesn't exist
|
||||
this.allmodifiers.put("default", 16384);
|
||||
this.allmodifiers.put("strictfp", 32768);
|
||||
|
||||
this.compiler = compiler;
|
||||
|
||||
@@ -168,7 +168,7 @@ public class TypeGenerator {
|
||||
if (generics.contains(name)) {
|
||||
return new GenericRefType(name, offset);
|
||||
} else {
|
||||
Pattern p = Pattern.compile("Fun(Void|VoidImpl|Wrapper)?(\\d+)[$][$]"); // TODO Regex shenanigans
|
||||
Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
|
||||
Matcher m = p.matcher(name);
|
||||
if (m.matches()) {// es ist FunN$$-Type
|
||||
return new RefType(new JavaClassName(name), convert(typeArguments, reg, generics), offset);
|
||||
|
||||
@@ -846,6 +846,13 @@ public class ASTToTargetAST {
|
||||
compiler.usedFunNSuperTypes.add(params.size());
|
||||
var code = FunNGenerator.generateSuperBytecode(params.size() - 1, returnType != null ? 1 : 0);
|
||||
var superClassName = FunNGenerator.getSuperClassName(params.size() - 1, returnType != null ? 1 : 0);
|
||||
try {
|
||||
compiler.classLoader.findClass(superClassName);
|
||||
} catch (ClassNotFoundException e) {
|
||||
try {
|
||||
compiler.classLoader.loadClass(superClassName, code);
|
||||
} catch (LinkageError ignored) {}
|
||||
}
|
||||
compiler.auxiliaries.put(superClassName, code);
|
||||
}
|
||||
FunNGenerator.GenericParameters gep = null;
|
||||
|
||||
@@ -161,6 +161,7 @@ public class StatementToTargetExpression implements ASTVisitor {
|
||||
|
||||
@Override
|
||||
public void visit(FieldVar fieldVar) {
|
||||
var isStatic = false;
|
||||
var type = converter.convert(fieldVar.receiver.getType());
|
||||
var clazz = converter.compiler.getClass(new JavaClassName(type.name()));
|
||||
var field = clazz.getField(fieldVar.fieldVarName).orElseThrow();
|
||||
|
||||
@@ -8,42 +8,42 @@ public sealed interface TargetLiteral extends TargetExpression {
|
||||
record BooleanLiteral(Boolean value) implements TargetLiteral {
|
||||
@Override
|
||||
public TargetType type() {
|
||||
return TargetType.boolean_;
|
||||
return TargetType.Boolean;
|
||||
}
|
||||
}
|
||||
|
||||
record CharLiteral(Character value) implements TargetLiteral {
|
||||
@Override
|
||||
public TargetType type() {
|
||||
return TargetType.char_;
|
||||
return TargetType.Char;
|
||||
}
|
||||
}
|
||||
|
||||
record IntLiteral(Integer value) implements TargetLiteral {
|
||||
@Override
|
||||
public TargetType type() {
|
||||
return TargetType.int_;
|
||||
return TargetType.Integer;
|
||||
}
|
||||
}
|
||||
|
||||
record LongLiteral(Long value) implements TargetLiteral {
|
||||
@Override
|
||||
public TargetType type() {
|
||||
return TargetType.long_;
|
||||
return TargetType.Long;
|
||||
}
|
||||
}
|
||||
|
||||
record FloatLiteral(Float value) implements TargetLiteral {
|
||||
@Override
|
||||
public TargetType type() {
|
||||
return TargetType.float_;
|
||||
return TargetType.Float;
|
||||
}
|
||||
}
|
||||
|
||||
record DoubleLiteral(Double value) implements TargetLiteral {
|
||||
@Override
|
||||
public TargetType type() {
|
||||
return TargetType.double_;
|
||||
return TargetType.Double;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -33,10 +33,4 @@ public record TargetFunNType(String name, List<TargetType> funNParams, List<Targ
|
||||
public String getInternalName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toSignature() {
|
||||
var args = FunNGenerator.getArguments(funNParams);
|
||||
return "LFun" + args.size() + "$$" + TargetSpecializedType.signatureParameters(funNParams) + ";";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,20 +8,14 @@ public sealed interface TargetSpecializedType extends TargetType permits TargetF
|
||||
@Override
|
||||
default String toSignature() {
|
||||
String ret = "L" + getInternalName();
|
||||
ret += signatureParameters(params());
|
||||
ret += ";";
|
||||
return ret;
|
||||
}
|
||||
|
||||
static String signatureParameters(List<TargetType> params) {
|
||||
var ret = "";
|
||||
if (!params.isEmpty()) {
|
||||
if (!params().isEmpty()) {
|
||||
ret += "<";
|
||||
for (var param : params) {
|
||||
for (var param : params()) {
|
||||
ret += param.toSignature();
|
||||
}
|
||||
ret += ">";
|
||||
}
|
||||
ret += ";";
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@@ -935,7 +935,7 @@ public class TYPEStmt implements StatementVisitor {
|
||||
@Override
|
||||
public void visit(Yield aYield) {
|
||||
aYield.retexpr.accept(this);
|
||||
constraintsSet.addUndConstraint(new Pair(aYield.getType(), switchStack.peek().getType(), PairOperator.SMALLERDOT, loc(aYield.getOffset())));
|
||||
constraintsSet.addUndConstraint(new Pair(aYield.getType(), switchStack.peek().getType(), PairOperator.EQUALSDOT, loc(aYield.getOffset())));
|
||||
// TODO Auto-generated method stub
|
||||
}
|
||||
}
|
||||
|
||||
@@ -745,7 +745,7 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
if((!(lhsType instanceof ReferenceType) && !(lhsType instanceof FunNType)) || !(rhsType instanceof ExtendsType))
|
||||
if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof ExtendsType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
@@ -771,7 +771,7 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
if((!(lhsType instanceof ReferenceType) && !(lhsType instanceof FunNType)) || !(rhsType instanceof SuperType))
|
||||
if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof SuperType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
|
||||
@@ -861,19 +861,16 @@ public class RuleSet implements IRuleSet{
|
||||
UnifyType r = x.getRhsType();
|
||||
if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
|
||||
} );
|
||||
|
||||
try {
|
||||
logFile.write("FUNgreater: " + pair + "\n");
|
||||
logFile.write("FUNgreater: " + result + "\n");
|
||||
logFile.flush();
|
||||
}
|
||||
logFile.write("FUNgreater: " + pair + "\n");
|
||||
logFile.write("FUNred: " + result + "\n");
|
||||
logFile.flush();
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.out.println("lofFile-Error");
|
||||
System.out.println("logFile-Error");
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
@@ -900,7 +897,7 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
|
||||
var retType = fiArgs.getFirst();
|
||||
var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType); //FALSCHRUM????
|
||||
var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType);
|
||||
var lhsRet = lhsArgs.getFirst();
|
||||
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
@@ -937,8 +934,8 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
Set<UnifyPair> result = new HashSet<UnifyPair>();
|
||||
|
||||
int variance = ((PlaceholderType)rhsType).getVariance();
|
||||
int inversVariance = distributeVariance.inverseVariance(variance);
|
||||
Integer variance = ((PlaceholderType)rhsType).getVariance();
|
||||
Integer inversVariance = distributeVariance.inverseVariance(variance);
|
||||
|
||||
UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
|
||||
for(int i = 0; i < freshPlaceholders.length-1; i++) {
|
||||
@@ -946,7 +943,6 @@ public class RuleSet implements IRuleSet{
|
||||
((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
|
||||
}
|
||||
freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
|
||||
|
||||
((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
|
||||
result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
@@ -957,94 +953,42 @@ public class RuleSet implements IRuleSet{
|
||||
result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
result.stream().forEach(x -> { UnifyType l = x.getLhsType();
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
UnifyType r = x.getRhsType();
|
||||
if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
|
||||
} );
|
||||
|
||||
try {
|
||||
logFile.write("FUNgreater: " + pair + "\n");
|
||||
logFile.write("FUNsmaller: " + result + "\n");
|
||||
logFile.flush();
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.out.println("lofFile-Error");
|
||||
}
|
||||
|
||||
try {
|
||||
logFile.write("FUNgreater: " + pair + "\n");
|
||||
logFile.write("FUNgreater: " + result + "\n");
|
||||
logFile.flush();
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.out.println("lofFile-Error");
|
||||
}
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair, IFiniteClosure fc) {
|
||||
public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair) {
|
||||
if(pair.getPairOp() != PairOperator.SMALLERDOT)
|
||||
return Optional.empty();
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
|
||||
if(!(rhsType instanceof FunNType))
|
||||
if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof FunNType))
|
||||
return Optional.empty();
|
||||
|
||||
/* muss nach angepasst werden */
|
||||
//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
|
||||
if (lhsType instanceof ReferenceType) {
|
||||
UnifyType typeFI = pair.getLhsType();
|
||||
|
||||
Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
|
||||
if(!opt.isPresent())
|
||||
return Optional.empty();
|
||||
|
||||
if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
|
||||
return Optional.empty();
|
||||
|
||||
var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
|
||||
var retType = fiArgs.getFirst();
|
||||
var rhsArgs = intf.getFunctionalInterfaceTypeArguments(rhsType);
|
||||
var rhsRet = rhsArgs.getFirst();
|
||||
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
//if (retType instanceof ExtendsType) {
|
||||
result.add(new UnifyPair(retType, rhsRet, PairOperator.SMALLER));
|
||||
//} else if (retType instanceof SuperType) {
|
||||
// return Optional.empty();
|
||||
//} else {
|
||||
// result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
|
||||
for (var i = 1; i < fiArgs.size(); i++) {
|
||||
var rh = rhsArgs.get(i);
|
||||
var lh = fiArgs.get(i);
|
||||
|
||||
//if (rh instanceof SuperType) {
|
||||
result.add(new UnifyPair(rh, lh, PairOperator.SMALLER));
|
||||
//} else if (rh instanceof ExtendsType) {
|
||||
// return Optional.empty();
|
||||
//} else {
|
||||
// result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
else {
|
||||
if(!(lhsType instanceof PlaceholderType))
|
||||
return Optional.empty();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
FunNType funNRhsType = (FunNType) rhsType;
|
||||
|
||||
Set<UnifyPair> result = new HashSet<UnifyPair>();
|
||||
|
||||
int variance = ((PlaceholderType)lhsType).getVariance();
|
||||
int inversVariance = distributeVariance.inverseVariance(variance);
|
||||
Integer variance = ((PlaceholderType)lhsType).getVariance();
|
||||
Integer inversVariance = distributeVariance.inverseVariance(variance);
|
||||
|
||||
UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
|
||||
for(int i = 0; i < freshPlaceholders.length-1; i++) {
|
||||
freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
|
||||
freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
|
||||
((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
|
||||
}
|
||||
freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
|
||||
@@ -1059,139 +1003,21 @@ public class RuleSet implements IRuleSet{
|
||||
result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
|
||||
result.stream().forEach(x -> { UnifyType l = x.getLhsType();
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
|
||||
UnifyType r = x.getRhsType();
|
||||
if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
|
||||
} );
|
||||
|
||||
|
||||
try {
|
||||
logFile.write("FUNgreater: " + pair + "\n");
|
||||
logFile.write("FUNsmaller: " + result + "\n");
|
||||
logFile.flush();
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.out.println("lofFile-Error");
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Optional<Set<UnifyPair>> reduceFIFunN(UnifyPair pair, IFiniteClosure fc) {
|
||||
if(pair.getPairOp() != PairOperator.EQUALSDOT)
|
||||
return Optional.empty();
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
|
||||
if(!(rhsType instanceof FunNType))
|
||||
return Optional.empty();
|
||||
|
||||
/* muss nach angepasst werden */
|
||||
//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
|
||||
if (lhsType instanceof ReferenceType) {
|
||||
UnifyType typeFI = pair.getLhsType();
|
||||
|
||||
Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
|
||||
if(!opt.isPresent())
|
||||
return Optional.empty();
|
||||
|
||||
if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
|
||||
return Optional.empty();
|
||||
|
||||
var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
|
||||
var retType = fiArgs.getFirst();
|
||||
var rhsArgs = intf.getFunctionalInterfaceTypeArguments(rhsType);
|
||||
var rhsRet = rhsArgs.getFirst();
|
||||
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
//if (retType instanceof ExtendsType) {
|
||||
result.add(new UnifyPair(retType, rhsRet, PairOperator.EQUALSDOT));
|
||||
//} else if (retType instanceof SuperType) {
|
||||
// return Optional.empty();
|
||||
//} else {
|
||||
// result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
|
||||
for (var i = 1; i < fiArgs.size(); i++) {
|
||||
var rh = rhsArgs.get(i);
|
||||
var lh = fiArgs.get(i);
|
||||
|
||||
//if (rh instanceof SuperType) {
|
||||
result.add(new UnifyPair(rh, lh, PairOperator.EQUALSDOT));
|
||||
//} else if (rh instanceof ExtendsType) {
|
||||
// return Optional.empty();
|
||||
//} else {
|
||||
// result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
else {
|
||||
return Optional.empty();
|
||||
try {
|
||||
logFile.write("FUNgreater: " + pair + "\n");
|
||||
logFile.write("FUNsmaller: " + result + "\n");
|
||||
logFile.flush();
|
||||
}
|
||||
catch (IOException e) {
|
||||
System.out.println("lofFile-Error");
|
||||
}
|
||||
|
||||
@Override
|
||||
public Optional<Set<UnifyPair>> reduceFunNFi(UnifyPair pair, IFiniteClosure fc) {
|
||||
if(pair.getPairOp() != PairOperator.EQUALSDOT)
|
||||
return Optional.empty();
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
|
||||
if(!(lhsType instanceof FunNType))
|
||||
return Optional.empty();
|
||||
|
||||
//FunN$$<...> <. FunctinalInterface<...> wird umgewandelt in FunN$$<...> <. FunN$$<... args aus FuntionalInterface ...>
|
||||
if (rhsType instanceof ReferenceType) {
|
||||
UnifyType typeFI = pair.getRhsType();
|
||||
|
||||
Optional<UnifyType> opt = fc.getRightHandedFunctionalInterfaceType(typeFI.getName());
|
||||
if(!opt.isPresent())
|
||||
return Optional.empty();
|
||||
|
||||
if (!(typeFI instanceof ReferenceType refType) || !(refType instanceof FunInterfaceType intf))
|
||||
return Optional.empty();
|
||||
|
||||
var fiArgs = intf.getFunctionalInterfaceTypeArguments(refType);
|
||||
var retType = fiArgs.getFirst();
|
||||
var lhsArgs = intf.getFunctionalInterfaceTypeArguments(lhsType);
|
||||
var lhsRet = lhsArgs.getFirst();
|
||||
|
||||
Set<UnifyPair> result = new HashSet<>();
|
||||
//if (retType instanceof ExtendsType) {
|
||||
// result.add(new UnifyPair(lhsRet, retType, PairOperator.SMALLERDOTWC));
|
||||
//} else if (retType instanceof SuperType) {
|
||||
// return Optional.empty();
|
||||
//} else {
|
||||
result.add(new UnifyPair(lhsRet, retType, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
|
||||
for (var i = 1; i < fiArgs.size(); i++) {
|
||||
var lh = lhsArgs.get(i);
|
||||
var rh = fiArgs.get(i);
|
||||
|
||||
//if (rh instanceof SuperType) {
|
||||
// result.add(new UnifyPair(lh, rh, PairOperator.SMALLERDOTWC));
|
||||
//} else if (rh instanceof ExtendsType) {
|
||||
// return Optional.empty();
|
||||
//} else {
|
||||
result.add(new UnifyPair(lh, rh, PairOperator.EQUALSDOT));
|
||||
//}
|
||||
}
|
||||
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
else {
|
||||
return Optional.empty();
|
||||
}
|
||||
return Optional.of(result);
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public Optional<UnifyPair> reduceTph(UnifyPair pair) {
|
||||
if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
|
||||
@@ -1199,7 +1025,7 @@ public class RuleSet implements IRuleSet{
|
||||
|
||||
UnifyType lhsType = pair.getLhsType();
|
||||
UnifyType rhsType = pair.getRhsType();
|
||||
if(!(lhsType instanceof PlaceholderType) || (!(rhsType instanceof ReferenceType) && !(rhsType instanceof FunNType)))
|
||||
if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof ReferenceType))
|
||||
return Optional.empty();
|
||||
|
||||
return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
@@ -1225,7 +1051,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(isGen)
|
||||
result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
else {
|
||||
UnifyType freshTph = PlaceholderType.freshPlaceholder();
|
||||
UnifyType freshTph = PlaceholderType.freshPlaceholder();
|
||||
result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
}
|
||||
@@ -1253,7 +1079,7 @@ public class RuleSet implements IRuleSet{
|
||||
if(isGen)
|
||||
result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
else {
|
||||
UnifyType freshTph = PlaceholderType.freshPlaceholder();
|
||||
UnifyType freshTph = PlaceholderType.freshPlaceholder();
|
||||
result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
|
||||
Set<UnifyType> fBounded = pair.getfBounded();
|
||||
fBounded.add(lhsType);
|
||||
|
||||
@@ -1828,7 +1828,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
|
||||
// FunN Rules
|
||||
optSet = optSet.isPresent() ? optSet : rules.reduceFunN(pair);
|
||||
optSet = optSet.isPresent() ? optSet : rules.greaterFunN(pair, fc);
|
||||
optSet = optSet.isPresent() ? optSet : rules.smallerFunN(pair,fc);
|
||||
optSet = optSet.isPresent() ? optSet : rules.smallerFunN(pair);
|
||||
|
||||
// One of the rules has been applied
|
||||
if(optSet.isPresent()) {
|
||||
|
||||
@@ -40,8 +40,6 @@ public class UnifyResultModel {
|
||||
Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
|
||||
Optional<Set<UnifyPair>> res = new RuleSet().subst(x.stream().map(y -> {
|
||||
if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
|
||||
if (y.getPairOp() == PairOperator.SMALLERDOTWC)
|
||||
y.setPairOp(PairOperator.EQUALSDOT);
|
||||
return y; //alle Paare a <.? b erden durch a =. b ersetzt
|
||||
}).collect(Collectors.toCollection(HashSet::new)));
|
||||
if (res.isPresent()) {//wenn subst ein Erg liefert wurde was veraendert
|
||||
|
||||
@@ -61,9 +61,7 @@ public interface IRuleSet {
|
||||
*/
|
||||
public Optional<Set<UnifyPair>> reduceFunN(UnifyPair pair);
|
||||
public Optional<Set<UnifyPair>> greaterFunN(UnifyPair pair, IFiniteClosure fc);
|
||||
public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair, IFiniteClosure fc);
|
||||
public Optional<Set<UnifyPair>> reduceFIFunN(UnifyPair pair, IFiniteClosure fc);
|
||||
public Optional<Set<UnifyPair>> reduceFunNFi(UnifyPair pair, IFiniteClosure fc);
|
||||
public Optional<Set<UnifyPair>> smallerFunN(UnifyPair pair);
|
||||
|
||||
/**
|
||||
* Checks whether the erase1-Rule applies to the pair.
|
||||
|
||||
@@ -63,12 +63,11 @@ public class AllgemeinTest {
|
||||
//String className = "Cycle";
|
||||
//String className = "TripleTest";
|
||||
//String className = "WildcardList";
|
||||
//String className = "List";
|
||||
String className = "List";
|
||||
//String className = "Box";
|
||||
//String className = "GenBox";
|
||||
//String className = "InnerInf";
|
||||
//String className = "Foo";
|
||||
String className = "Kombinatoren_After_Lazy";
|
||||
//PL 2019-10-24: genutzt fuer unterschiedliche Tests
|
||||
path = System.getProperty("user.dir")+"/resources/AllgemeinTest/" + className + ".jav";
|
||||
//path = System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/Overloading_Generics.jav";
|
||||
|
||||
@@ -735,17 +735,8 @@ public class TestComplete {
|
||||
public void testSwitchRecordLiteral() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "PatternMatchingLiteralStyle.jav");
|
||||
var clazz = classFiles.get("SwitchOverload");
|
||||
var record = classFiles.get("R");
|
||||
var rctor = record.getDeclaredConstructor(String.class);
|
||||
|
||||
var instance = clazz.getDeclaredConstructor().newInstance();
|
||||
var m = clazz.getDeclaredMethod("m", record);
|
||||
assertEquals(10, m.invoke(instance, rctor.newInstance("test")));
|
||||
assertEquals(20, m.invoke(instance, rctor.newInstance("foo")));
|
||||
assertEquals(0, m.invoke(instance, rctor.newInstance("???")));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSwitchCaseHeritageDetection() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "SwitchCaseHeritageDetection.jav");
|
||||
@@ -1485,42 +1476,4 @@ public class TestComplete {
|
||||
var m = clazz.getDeclaredMethod("main");
|
||||
m.invoke(null);
|
||||
}
|
||||
|
||||
@Disabled("Doesn't work yet")
|
||||
@Test
|
||||
public void testBug378() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "Bug378Main.jav");
|
||||
var clazz = classFiles.get("Bug378Main");
|
||||
var main = clazz.getDeclaredMethod("main", List.class);
|
||||
main.invoke(null, List.of());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBug379() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "Bug379.jav");
|
||||
var clazz = classFiles.get("Bug379");
|
||||
clazz.getDeclaredConstructor().newInstance();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBug380() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "Bug380.jav");
|
||||
var clazz = classFiles.get("Bug380");
|
||||
clazz.getDeclaredConstructor().newInstance();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBug382() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "Bug382.jav");
|
||||
var clazz = classFiles.get("Bug382");
|
||||
clazz.getDeclaredMethod("main", List.class).invoke(null, List.of());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBug383() throws Exception {
|
||||
var classFiles = generateClassFiles(createClassLoader(), "Bug383.jav");
|
||||
var clazz = classFiles.get("Bug383");
|
||||
clazz.getDeclaredMethod("main", List.class).invoke(null, List.of());
|
||||
// TODO This logs output that we should validate
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user