Change internals of Codegen to use boxed types by default

Fix #379
Add a validator step, fix invalid attributes

pom.xml

@@ -44,6 +44,11 @@ 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>

resources/KPSPresentation/AddEle.jav

@@ -1,9 +0,0 @@
-import java.util.Vector;
-import java.util.Collection;
-
-class AddEle {
-	addEle(x, y) {
-		x.add(y);
-		return x;
-	}
-} 

resources/KPSPresentation/Fac.jav

@@ -1,15 +0,0 @@
-import java.lang.Double;
-import java.lang.Integer;
-  
-public class Fac   {
-	  
-	 getFac(n){ 
-		var res = 1; 
-		var i = 1; 
-		while(i<=n) {  
-			res = res * i;
-			i++;
-		}
-		return res; 
-	}
-}     

resources/KPSPresentation/Faculty.jav

@@ -1,18 +0,0 @@
-import java.lang.Integer;
-import java.lang.Float;
- 
-public class Faculty { 
-    public Fun1$$<Integer, Integer> fact = (x) -> {
-            if (x == 1) {
-                return 1;
-            }
-            else { 
-              return x * (fact.apply(x-1));
-            }
-        };
-    
-    public getFact(x) {  
-        return fact.apply(x);
-    }     
-    
-}       

resources/KPSPresentation/FacultyBug.jav

@@ -1,18 +0,0 @@
-import java.lang.Integer;
-import java.lang.Float;
- 
-public class FacultyBug { 
-    public Fun1$$<Float, Float> fact = (x) -> {
-            if (x == 1) {
-                return 1;
-            }
-            else { 
-              return x * (fact.apply(x-1));
-            }
-        };
-    
-    public getFact(x) {  
-        return fact.apply(x);
-    }     
-    
-}       

resources/KPSPresentation/Id.jav

@@ -1,11 +0,0 @@
-class Id {
-    id2 = x -> x;
-   
-   id(x) { 
-   	 return x;
-   }
-   
-    id3(x) { 
-   		return id(x); 
-   }
-}   

resources/KPSPresentation/Lambda.jav

@@ -1,11 +0,0 @@
-import java.lang.Integer;
-
-public class Lambda {
- 
-  m () {
-   var lam1 = (x) -> {
-        return x * x;
-   };
-   return lam1; 
-  } 
-} 

resources/KPSPresentation/Main.jav

@@ -1,105 +0,0 @@
-import java.lang.String ;
-import java.lang.System; 
-import java.io.PrintStream;
-import java.lang.Character;
-import java.lang.Object;
-import java.lang.Integer;
-import fst;
-import Id;
-import OLMain;
-import Fac;
-import Faculty;
-import applyLambda;
-import java.util.Vector;
-import Matrix;
-
-public class Main {
-	public  static main(x) { 
-	/*
-	  new fst().main(5);
-	  System.out.println(new fst().main(5));
-	  
-	  //Id.jav: the identity-function
-	  //applied to an integer
-	  System.out.println(new Id().id(1));
-	  //applied to a string
-	  System.out.println(new Id().id("hallo"));
-	  //lamda-Expr
-	  //System.out.println(new Id().id2.apply(1));
-	  //Bug: https://gitea.hb.dhbw-stuttgart.de/JavaTX/JavaCompilerCore/issues/378
-	  
-	  //OL.jav: Overloading
-	  OLMain ol = new OLMain();
-	  
-	  //the function main is applied to an integer
-	  System.out.println(ol.main(2));
-	  //the main is applied to a double
-	  System.out.println(ol.main(2.0)); 
-	  System.out.println(ol.main("Hallo"));
-	  //Fac.jav
-	  System.out.println(new Fac().getFac(6));
-	    
-
-	  //Faculty.jav
-	  //System.out.println(new Faculty().fact.apply(6));
-	  //Bug: https://gitea.hb.dhbw-stuttgart.de/JavaTX/JavaCompilerCore/issues/378
-	  System.out.println(new Faculty().getFact(3));
-
-	    //Lambda.jav: An lambda expression applied by the method apply
-	    //System.out.println(new Lambda().m().apply(77));
-	    //Bug: https://gitea.hb.dhbw-stuttgart.de/JavaTX/JavaCompilerCore/issues/378
-		
-		//applyLambda.jav: A defined lambda expression is applied 
-		System.out.println(new applyLambda().m());
-*/
-		 Vector<Vector<Integer>> vv = new Vector<Vector<Integer>>();
-		 Vector<Integer> v1 = new Vector<Integer> ();
-		 v1.addElement(2);
-		 v1.addElement(2);
-		 Vector<Integer> v2 = new Vector<Integer> ();
-		 v2.addElement(3);
-		 v2.addElement(3);
-		 Matrix m1 = new Matrix();
-		 m1.addElement(v1);
-		 m1.addElement(v2);
-		 //vv.addElement(v1);
-		 //vv.addElement(v2);
-		 //Matrix m1 = new Matrix(vv);
-
-		 Vector<Vector<Integer>> vv1 = new Vector<Vector<Integer>>();
-		 Vector<Integer> v3 = new Vector<Integer> ();
-		 v3.addElement(2);
-		 v3.addElement(2);
-		 Vector<Integer> v4 = new Vector<Integer> ();
-		 v4.addElement(3);
-		 v4.addElement(3);
-		 Matrix m2 = new Matrix();
-		 m2.addElement(v3);
-		 m2.addElement(v4);
-		 //vv1.addElement(v3);
-		 //vv1.addElement(v4);
-		 //Matrix m2 = new Matrix(vv1);
-		 
-
-		 //Matrix m3 = m1.mul(vv1);
-		 Matrix m3 = m1.mul(m2);
-		 System.out.println(m1.toString() + " * " + m2.toString() + " = " + m3.toString());
-/*					 						
-		 //MatrixOP 
-		 MatrixOP mOp1 = new MatrixOP();
-		 mOp1.addElement(v1);
-		 mOp1.addElement(v2);
-		 MatrixOP mOp2 = mOp1.mul.apply(mOp1, mOp1);
-		 System.out.println(m1.toString() + " * " + m2.toString() + " = " + mOp2.toString());
-	}       
-}
-
-public class MainBug {
-	public  static main(x) { 
-		System.out.println(new fst().main(5));
-		//System.out.println(new FacultyBug().getFact(3));
-
-	}  
-*/     
-}
-}

resources/KPSPresentation/Matrix.jav

@@ -1,41 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-import java.lang.Boolean;
-
-public class Matrix extends Vector<Vector<Integer>> {
-   
-	   
-	public Matrix () {  
-    }
-
-	public Matrix(vv) { 
-      var i = 0; 
-	  while(i < vv.size()) {
-		  this.add(vv.elementAt(i));
-		  i=i+1;
-	  } 
-    } 
-     
-
-	 mul(m) { 
-        var ret = new Matrix();
-        var i = 0;
-        while(i < size()) {
-            var v1 = this.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                    erg = erg + v1.elementAt(k)
-                             * m.elementAt(k).elementAt(j);
-                    k++; }
-                v2.addElement(erg);
-                j++; }
-            ret.addElement(v2);
-            i++; 
-         }
-        return ret;
-    }
-}

resources/KPSPresentation/MatrixOP.jav

@@ -1,42 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-import java.lang.Byte;
-import java.lang.Boolean;
-
-public class MatrixOP    extends Vector<Vector<Integer>> {
-   
-	 MatrixOP () {
-    }  
-
-	MatrixOP(vv) {
-    	Integer i;   
-    	i = 0;
-	   while(i < vv.size()) { 
-		  this.add(vv.elementAt(i));  
-		  i=i+1;
-	  }  
-    }     
-      
-     Fun2$$<Vector<? extends Vector<? extends Integer>>, Vector<? extends Vector<? extends Integer>>, MatrixOP> mul = (m1, m2) -> { 
-        var ret = new MatrixOP();
-        var i = 0;
-        while(i < m1.size()) { 
-            var v1 = m1.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                    erg = erg + v1.elementAt(k)
-                             * m2.elementAt(k).elementAt(j);
-                    k++; }
-//                v2.addElement(new Integer(erg));
-                v2.addElement(erg);
-                j++; }
-            ret.addElement(v2);
-            i++; 
-         }
-        return ret;
-    };
-}

resources/KPSPresentation/OL.jav

@@ -1,30 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double; 
-import java.lang.Boolean; 
-import java.lang.Object;
-
-  
-  
-
-class OL  {
-
-      m(x) { return x + x; }
-  
-	  
-    m(x) { return x || x; } 
-
-	 
-}   
-  
-    
-          
-class OLMain {
-
-	main(x) {  
-		var ol;
-		ol = new OL(); 
-		return ol.m(x); 
-	}  
-}
-

resources/KPSPresentation/OLFun.jav

@@ -1,20 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double;
-import java.util.Vector;
-import java.lang.Boolean; 
-
-
-
-
-
-public class OLFun    {
-	x;
-	
-	 
-	m(f, y) {
-		y = f.apply(x+x);
-		return x;
-	}
-	
-} 

resources/KPSPresentation/Pair.jav

@@ -1,12 +0,0 @@
-class Pair { 
-    fst;
-    snd;     
-
-    Pair(fst, snd) { this.fst=fst; this.snd=snd; } 
-
-    getfst() { return this.fst; }
-    
-    swap() {
-        return new Pair<>(this.snd, this.fst);
-    } 
-} 

resources/KPSPresentation/Plus.jav

@@ -1,9 +0,0 @@
-import java.lang.Integer;
-import java.lang.String;
-
-public class Plus {
-	 
-	m(a, b) {
-		return a+b;
-	}
-} 

resources/KPSPresentation/Sorting.jav

@@ -1,25 +0,0 @@
-import java.util.List;
-import java.util.ArrayList;
-import java.lang.String;
-
-public class Sorting{
-    merge(a, b){
-        a.addAll(b);
-        return a;
-    }
-   
-
-sort(in){
-	var firstHalf = in;
-	var secondHalf = in; 
-	return merge(sort(firstHalf), sort(secondHalf));
-}
-
-
-
-	/*
-	void sort(a){
-		a = merge(a,a);
-	}
-	*/
-}

resources/KPSPresentation/Swap.jav

@@ -1,20 +0,0 @@
-import java.lang.String;
-import java.lang.Object;
-import java.lang.System;
-import java.io.PrintStream;
-import java.lang.Character;
-
-public class Swap{
-       <ZDP, ZEA, ZDO, YZP, ZCY, ZDZ> Fun1$$<ZCY, Fun1$$<ZDZ, ZEA>> swap(f){
-        return x->y->f.apply(y).apply(x);
-    } 
-
-     Fun1$$<String, Fun1$$<String, Fun1$$<String, String>>> swap(f){
-        return x -> y -> z -> f.apply(z).apply(x).apply(y);
-        }
-    
-    public static main (y) {
-        var func = x -> y -> z -> x + y + z; 
-        var res = new Swap().swap(func).apply("A").apply("B").apply("C");
-        System.out.println(res);}
-    } 

resources/KPSPresentation/TPHMethod.jav

@@ -1,6 +0,0 @@
-class TPHMethod  {
-  void m(a, b) {
-  	a = b;
-  	b=a;
-  }
-}

resources/KPSPresentation/Test.jav

@@ -1,16 +0,0 @@
-class Test{
-	void m( op, a, b ){
-		op.myapply(a, b);
-	}
-}
-
-class Atype{}
-class Btype{}
-
-class Operator1{
-	void myapply(Atype p1, Atype p2){...}
-}
-
-class Operator2{
-	void myapply(Btype p1, Btype p2){...}
-} 

resources/KPSPresentation/Uncurrier.jav

@@ -1,7 +0,0 @@
-public class Uncurrier{ 
-    uncurry (f){
-     return x -> f.apply(x);} 
-     uncurry (f){
-            return (x, y) -> f.apply(x).apply(y);
-    }
-}    

resources/KPSPresentation/UncurrierMain.jav

@@ -1,7 +0,0 @@
-import Uncurrier;
-
-class UncurrierMain {
-    public static main(x) { 
-        var uc = new Uncurrier() ;
-    }
-}

resources/KPSPresentation/VectorAdd.jav

@@ -1,16 +0,0 @@
-import java.lang.Integer;
-import java.lang.String;
-import java.util.Vector;
-
-class VectorAdd {
-	vectorAdd(v1, v2) {
-		var i = 0;
-		var erg = new Vector<>();
-		while (i < v1.size()) {
-			erg.addElement(v1.elementAt(i) + v2.elementAt(i));
-			i++;
-		} 
-		return erg; 
-	}	
-}
-

resources/KPSPresentation/applyLambda.jav

@@ -1,16 +0,0 @@
-import java.util.Vector;
-class Apply { } 
-
-public class applyLambda {
-
-  public m () {
-   var lam1 = (x) -> {
-        return x;
-   };
-
-   return lam1.apply(new Apply());
-   //return lam1;
-   //return new Vector();
-  }
-}
-

resources/KPSPresentation/fst.jav

@@ -1,7 +0,0 @@
-//import java.lang.Integer;
-
-class fst {
-	main(x) {  
-		return x;
-	}     
-}  

resources/KPSPresentation/genVector.jav

@@ -1,8 +0,0 @@
-import java.util.Vector;
-
-class genVector {
-
-	 m(v) {
-		return v.elementAt(0);
-	}
-}

resources/KPSPresentation/idTest.jav

@@ -1,8 +0,0 @@
-import java.lang.Integer;
-import Id;
-
-class Test { 
-	m() {
-	  Integer o1 = new Id<Integer,Integer>().id2.apply(1);
-	}
-} 

resources/KPSPresentation/lambdaId.jav

@@ -1,9 +0,0 @@
-public class lambdaId  {
-  lambdaId = x -> x;
-
-  /*
-  id3 (x) {
-   	return lambdaId.apply(x);
-  }
-  */
-}

resources/KPSPresentation/mathStruc.jav

@@ -1,9 +0,0 @@
-class mathStruc    { 
-	model;
-	
-    innerOp = (o) -> (ms) -> new mathStruc<>(o.apply(model,ms.model));
-
-	mathStruc(m) { 
-		model =m;  
-	}  
-}

resources/KPSPresentation/mathStrucInteger.jav

@@ -1,18 +0,0 @@
-import java.lang.Integer;
-
-class mathStruc { 
-	model;
-	
-	innerOp = (o) -> (ms) -> new mathStruc<>(o.apply(model,ms.model));
-
-	mathStruc(m) { 
-		model =m;
-	}
-}  
-
-class mathStrucIntegerUse {
-	main() {
-	    var ms = new mathStruc<>(2);
-		return ms.innerOp.apply((x,y) -> x+y).apply(ms);
-	} 
-} 

resources/KPSPresentation/mathStrucMatrixOP.jav

@@ -1,90 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-import java.lang.Boolean;
-
-public class mathStrucMatrixOP {
-	model; 
-	
-	innerOp = (o) -> (ms) -> new mathStrucMatrixOP<>(o.apply(model,ms.model));
-
-	public mathStrucMatrixOP(m) {
-		model =m;
-	}
-}
-
-public class MatrixOP extends Vector<Vector<Integer>> {
-   
-	MatrixOP () {
-    }
-
-	MatrixOP(vv) {
-    	Integer i;
-    	i = 0;
-	  while(i < vv.size()) {
-//	    	Boolean a = this.add(vv.elementAt(i));
-		  this.add(vv.elementAt(i));
-		  i=i+1;
-	  }
-    }
-
-	public mul = (m1, m2) -> {
-        var ret = new MatrixOP();
-        var i = 0;
-        while(i < m1.size()) {
-            var v1 = m1.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                    erg = erg + v1.elementAt(k)
-                             * m2.elementAt(k).elementAt(j);
-                    k++; }
-//                v2.addElement(new Integer(erg));
-                v2.addElement(erg);
-                j++; }
-            ret.addElement(v2);
-            i++; 
-         }
-        return ret;
-    };
-}
-
- 
-class mathStrucUseMatrixOP {
-
-    main() {
-		Vector<Vector<Integer>> vv = new Vector<Vector<Integer>>();
-		Vector<Integer> v1 = new Vector<Integer>();
-		v1.addElement(2);
-		v1.addElement(2);
-		Vector<Integer> v2 = new Vector<Integer>();
-		v2.addElement(3);
-		v2.addElement(3);
-		vv.addElement(v1);
-		vv.addElement(v2);
-
-		MatrixOP m1 = new MatrixOP(vv);
-	
-		Vector<Vector<Integer>> vv1 = new Vector<Vector<Integer>>();
-		Vector<Integer> v3 = new Vector<Integer>();
-		v3.addElement(2);
-		v3.addElement(2);
-		Vector<Integer> v4 = new Vector<Integer>();
-		v4.addElement(3);
-		v4.addElement(3);
-		vv1.addElement(v3);
-		vv1.addElement(v4);
-
-		MatrixOP m2 = new MatrixOP(vv1);
-
-		var mms;
-		mms = new mathStrucMatrixOP<>(m1);
-		var mms2;
-		mms2 = new mathStrucMatrixOP<>(m2);
-		var mms3;
-		mms3 = mms.innerOp.apply(m1.mul).apply(mms2);
-		return mms3;
-    }
-}

resources/KPSPresentation/test1.jav

@@ -1,14 +0,0 @@
-import java.lang.String;
-import java.lang.Boolean;
-import java.lang.Integer;
-import java.io.Serializable;
-
-public class testclass{
-
-    public testMethod(ele){
-        if(ele){
-            return 1;
-        }
-        return "";
-    }
-}

resources/bytecode/javFiles/Bug378Id.jav

@@ -0,0 +1,3 @@
+class Bug378Id {
+    id2 = x -> x;
+}

resources/bytecode/javFiles/Bug378Main.jav

@@ -0,0 +1,8 @@
+import Bug378Id;
+import java.lang.Integer;
+
+class Bug378Main {
+    static main(args) {
+        var hallo = (new Bug378Id<Integer>().id2).apply(1);
+    }
+}

resources/bytecode/javFiles/Bug379.jav

@@ -0,0 +1,24 @@
+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);
+	}
+}

resources/bytecode/javFiles/MatrixOP.jav

@@ -2,7 +2,6 @@ import java.util.Vector;
 import java.lang.Integer;
 //import java.lang.Byte;
 import java.lang.Boolean;
-import java.util.function.BiFunction;
 
 public class MatrixOP    extends Vector<Vector<Integer>> {
 

src/main/java/de/dhbwstuttgart/bytecode/Codegen.java

@@ -9,7 +9,9 @@ import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 import org.objectweb.asm.*;
+import org.objectweb.asm.util.CheckClassAdapter;
 
+import java.io.PrintWriter;
 import java.lang.invoke.*;
 import java.lang.reflect.Modifier;
 import java.util.*;
@@ -125,7 +127,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 +136,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) || type.equals(TargetType.boolean_)) {
+        if (type.equals(TargetType.boolean_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
-        } else if (type.equals(TargetType.Byte) || type.equals(TargetType.byte_)) {
+        } else if (type.equals(TargetType.byte_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;", false);
-        } else if (type.equals(TargetType.Double) || type.equals(TargetType.double_)) {
+        } else if (type.equals(TargetType.double_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false);
-        } else if (type.equals(TargetType.Long) || type.equals(TargetType.long_)) {
+        } else if (type.equals(TargetType.long_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;", false);
-        } else if (type.equals(TargetType.Integer) || type.equals(TargetType.int_)) {
+        } else if (type.equals(TargetType.int_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false);
-        } else if (type.equals(TargetType.Float) || type.equals(TargetType.float_)) {
+        } else if (type.equals(TargetType.float_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false);
-        } else if (type.equals(TargetType.Short) || type.equals(TargetType.short_)) {
+        } else if (type.equals(TargetType.short_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;", false);
-        } else if (type.equals(TargetType.Char) || type.equals(TargetType.char_)) {
+        } else if (type.equals(TargetType.char_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false);
         }
     }
@@ -185,9 +187,11 @@ 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);
     }
 
@@ -202,9 +206,11 @@ 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);
     }
 
@@ -233,64 +239,82 @@ 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 (source.equals(TargetType.Long)) {
-            if (dest.equals(TargetType.Integer))
+
+        var mv = state.mv;
+        if ((source instanceof TargetRefType || source instanceof TargetGenericType) &&
+                (dest instanceof TargetRefType || dest instanceof TargetGenericType)) {
+            if (dest instanceof TargetGenericType) return;
+            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))
+            else if (dest.equals(TargetType.float_))
                 mv.visitInsn(L2F);
-            else if (dest.equals(TargetType.Double))
+            else if (dest.equals(TargetType.double_))
                 mv.visitInsn(L2D);
-            else if (dest.equals(TargetType.Byte) || dest.equals(TargetType.Char) || dest.equals(TargetType.Short)) {
+            else if (dest.equals(TargetType.byte_) || dest.equals(TargetType.char_) || dest.equals(TargetType.short_)) {
                 mv.visitInsn(L2I);
-                convertTo(state, TargetType.Integer, dest);
+                convertTo(state, TargetType.int_, dest);
             }
-        } else if (source.equals(TargetType.Float)) {
-            if (dest.equals(TargetType.Integer))
+        } else if (source.equals(TargetType.float_)) {
+            if (dest.equals(TargetType.int_))
                 mv.visitInsn(F2I);
-            else if (dest.equals(TargetType.Double))
+            else if (dest.equals(TargetType.double_))
                 mv.visitInsn(F2D);
-            else if (dest.equals(TargetType.Long))
+            else if (dest.equals(TargetType.long_))
                 mv.visitInsn(F2L);
-            else if (dest.equals(TargetType.Byte) || dest.equals(TargetType.Char) || dest.equals(TargetType.Short)) {
+            else if (dest.equals(TargetType.byte_) || dest.equals(TargetType.char_) || dest.equals(TargetType.short_)) {
                 mv.visitInsn(F2I);
-                convertTo(state, TargetType.Integer, dest);
+                convertTo(state, TargetType.int_, dest);
             }
-        } else if (source.equals(TargetType.Double)) {
-            if (dest.equals(TargetType.Integer))
+        } else if (source.equals(TargetType.double_)) {
+            if (dest.equals(TargetType.int_))
                 mv.visitInsn(D2I);
-            else if (dest.equals(TargetType.Float))
+            else if (dest.equals(TargetType.float_))
                 mv.visitInsn(D2F);
-            else if (dest.equals(TargetType.Long))
+            else if (dest.equals(TargetType.long_))
                 mv.visitInsn(D2L);
-            else if (dest.equals(TargetType.Byte) || dest.equals(TargetType.Char) || dest.equals(TargetType.Short)) {
+            else if (dest.equals(TargetType.byte_) || dest.equals(TargetType.char_) || dest.equals(TargetType.short_)) {
                 mv.visitInsn(D2I);
-                convertTo(state, TargetType.Integer, dest);
+                convertTo(state, TargetType.int_, dest);
             }
-        } else if (source.equals(TargetType.Byte) || source.equals(TargetType.Char) || source.equals(TargetType.Short) || source.equals(TargetType.Integer)) {
-            if (dest.equals(TargetType.Byte))
+        } 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))
+            else if (dest.equals(TargetType.char_))
                 mv.visitInsn(I2C);
-            else if (dest.equals(TargetType.Short))
+            else if (dest.equals(TargetType.short_))
                 mv.visitInsn(I2S);
-            else if (dest.equals(TargetType.Long))
+            else if (dest.equals(TargetType.long_))
                 mv.visitInsn(I2L);
-            else if (dest.equals(TargetType.Float))
+            else if (dest.equals(TargetType.float_))
                 mv.visitInsn(I2F);
-            else if (dest.equals(TargetType.Double))
+            else if (dest.equals(TargetType.double_))
                 mv.visitInsn(I2D);
-        } else if (source.equals(TargetType.Boolean)) {
+        } 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);
-        } else if (!(dest instanceof TargetGenericType)) {
-            //boxPrimitive(state, source);
-            mv.visitTypeInsn(CHECKCAST, dest.getInternalName());
-            unboxPrimitive(state, dest);
+            return;
+        }
+
+        if (!(origDest instanceof TargetPrimitiveType)) {
+            if (dest instanceof TargetPrimitiveType)
+                boxPrimitive(state, dest);
+            else boxPrimitive(state, source);
         }
     }
 
@@ -350,9 +374,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(), add.type());
+                convertTo(state, add.left().type(), TargetType.toPrimitive(add.type()));
                 generate(state, add.right());
-                convertTo(state, add.right().type(), add.type());
+                convertTo(state, add.right().type(), TargetType.toPrimitive(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);
@@ -365,6 +389,7 @@ 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());
@@ -376,9 +401,9 @@ public class Codegen {
         }
         case Sub sub: {
             generate(state, sub.left());
-            convertTo(state, sub.left().type(), op.type());
+            convertTo(state, sub.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, sub.right());
-            convertTo(state, sub.right().type(), op.type());
+            convertTo(state, sub.right().type(), TargetType.toPrimitive(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);
@@ -391,13 +416,14 @@ 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(), op.type());
+            convertTo(state, div.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, div.right());
-            convertTo(state, div.right().type(), op.type());
+            convertTo(state, div.right().type(), TargetType.toPrimitive(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);
@@ -410,13 +436,14 @@ 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(), op.type());
+            convertTo(state, mul.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, mul.right());
-            convertTo(state, mul.right().type(), op.type());
+            convertTo(state, mul.right().type(), TargetType.toPrimitive(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);
@@ -429,13 +456,14 @@ 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(), op.type());
+            convertTo(state, rem.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, rem.right());
-            convertTo(state, rem.right().type(), op.type());
+            convertTo(state, rem.right().type(), TargetType.toPrimitive(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);
@@ -448,6 +476,7 @@ public class Codegen {
             } else {
                 throw new CodeGenException("Invalid argument to Rem expression");
             }
+            boxPrimitive(state, TargetType.toPrimitive(op.type()));
             break;
         }
         case Or or: {
@@ -455,14 +484,18 @@ 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;
         }
@@ -470,47 +503,54 @@ 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(), op.type());
+            convertTo(state, band.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, band.right());
-            convertTo(state, band.right().type(), op.type());
+            convertTo(state, band.right().type(), TargetType.toPrimitive(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(), op.type());
+            convertTo(state, bor.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, bor.right());
-            convertTo(state, bor.right().type(), op.type());
+            convertTo(state, bor.right().type(), TargetType.toPrimitive(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(), op.type());
+            convertTo(state, xor.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, xor.right());
-            convertTo(state, xor.right().type(), op.type());
+            convertTo(state, xor.right().type(), TargetType.toPrimitive(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: {
@@ -519,44 +559,47 @@ public class Codegen {
         }
         case Shl shl: {
             generate(state, shl.left());
-            convertTo(state, shl.left().type(), op.type());
+            convertTo(state, shl.left().type(),  TargetType.toPrimitive(op.type()));
             generate(state, shl.right());
-            convertTo(state, shl.right().type(), op.type());
+            convertTo(state, shl.right().type(), TargetType.toPrimitive(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(), op.type());
+            convertTo(state, shr.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, shr.right());
-            convertTo(state, shr.right().type(), op.type());
+            convertTo(state, shr.right().type(), TargetType.toPrimitive(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(), op.type());
+            convertTo(state, ushr.left().type(), TargetType.toPrimitive(op.type()));
             generate(state, ushr.right());
-            convertTo(state, ushr.right().type(), op.type());
+            convertTo(state, ushr.right().type(), TargetType.toPrimitive(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 = largerType(greater.left().type(), greater.right().type());
-            if (type.equals(TargetType.Long)) {
+            var type = TargetType.toPrimitive(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);
@@ -564,12 +607,12 @@ public class Codegen {
             break;
         }
         case Less less: {
-            var type = largerType(less.left().type(), less.right().type());
-            if (type.equals(TargetType.Long)) {
+            var type = TargetType.toPrimitive(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);
@@ -577,12 +620,12 @@ public class Codegen {
             break;
         }
         case GreaterOrEqual greaterOrEqual: {
-            var type = largerType(greaterOrEqual.left().type(), greaterOrEqual.right().type());
-            if (type.equals(TargetType.Long)) {
+            var type = TargetType.toPrimitive(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);
@@ -590,12 +633,12 @@ public class Codegen {
             break;
         }
         case LessOrEqual lessOrEqual: {
-            var type = largerType(lessOrEqual.left().type(), lessOrEqual.right().type());
-            if (type.equals(TargetType.Long)) {
+            var type = TargetType.toPrimitive(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);
@@ -603,30 +646,30 @@ public class Codegen {
             break;
         }
         case Equal equal: {
-            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);
+            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);
             } else {
                 generateRelationalOperator(state, equal, type, IF_ACMPEQ);
             }
             break;
         }
         case NotEqual notEqual: {
-            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);
+            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);
             } else {
                 generateRelationalOperator(state, notEqual, type, IF_ACMPNE);
             }
@@ -657,6 +700,7 @@ 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))
@@ -665,9 +709,11 @@ public class Codegen {
                     mv.visitInsn(LNEG);
                 else
                     mv.visitInsn(INEG);
+                boxPrimitive(state, TargetType.boolean_);
             }
             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);
@@ -675,93 +721,86 @@ public class Codegen {
                     mv.visitInsn(ICONST_M1);
                     mv.visitInsn(IXOR);
                 }
+                boxPrimitive(state, TargetType.boolean_);
             }
             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, preIncrement.type());
+                boxPrimitive(state, TargetType.toPrimitive(op.type()));
+                mv.visitInsn(DUP);
                 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, preDecrement.type());
+                boxPrimitive(state, TargetType.toPrimitive(op.type()));
+                mv.visitInsn(DUP);
                 afterIncDec(state, preDecrement);
             }
             case TargetUnaryOp.PostIncrement postIncrement -> {
                 generate(state, postIncrement.expr());
-                if (postIncrement.type().equals(TargetType.Float)) {
                 mv.visitInsn(DUP);
+                convertTo(state, postIncrement.expr().type(), TargetType.toPrimitive(op.type()));
+                if (postIncrement.type().equals(TargetType.Float)) {
                     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, postIncrement.type());
+                boxPrimitive(state, TargetType.toPrimitive(op.type()));
                 afterIncDec(state, postIncrement);
             }
             case TargetUnaryOp.PostDecrement postDecrement -> {
                 generate(state, postDecrement.expr());
-                if (postDecrement.type().equals(TargetType.Float)) {
                 mv.visitInsn(DUP);
+                convertTo(state, postDecrement.expr().type(), TargetType.toPrimitive(op.type()));
+                if (postDecrement.type().equals(TargetType.Float)) {
                     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, postDecrement.type());
+                boxPrimitive(state, TargetType.toPrimitive(op.type()));
                 afterIncDec(state, postDecrement);
             }
         }
@@ -958,14 +997,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: {
@@ -981,11 +1020,14 @@ 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());
-            else
+                convertTo(state, _for.termination().type(), TargetType.boolean_);
+                mv.visitJumpInsn(IFEQ, end);
+            } else {
                 mv.visitInsn(ICONST_1);
                 mv.visitJumpInsn(IFEQ, end);
+            }
 
             var env = new BreakEnv();
             env.startLabel = start;
@@ -1017,6 +1059,7 @@ 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();
@@ -1047,6 +1090,7 @@ 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);
@@ -1054,6 +1098,7 @@ 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);
@@ -1071,11 +1116,10 @@ public class Codegen {
                 if (state.returnType instanceof TargetPrimitiveType) {
                     generate(state, ret.expression());
 
-                    unboxPrimitive(state, state.returnType);
+                    convertTo(state, ret.expression().type(), state.returnType);
                     mv.visitInsn(findReturnCode(state.returnType));
                 } else {
                     generate(state, ret.expression());
-                    boxPrimitive(state, ret.expression().type());
                     convertTo(state, ret.expression().type(), state.returnType);
                     mv.visitInsn(ARETURN);
                 }
@@ -1127,8 +1171,6 @@ 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) // Decay FunN
@@ -1141,11 +1183,13 @@ 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:
@@ -1168,6 +1212,7 @@ 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);
@@ -1221,6 +1266,7 @@ 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;
         }
 
@@ -1415,7 +1461,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();
         }
@@ -1432,8 +1478,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);
@@ -1454,13 +1500,14 @@ public class Codegen {
         }
 
         if (pat instanceof TargetExpressionPattern ep) {
-            var cur = state.createVariable(pat.type());
+            var cur = state.createVariable(TargetType.toWrapper(pat.type()));
             state.mv.visitVarInsn(ASTORE, cur.index);
 
             var expr = new Equal(pat.type(), new TargetLocalVar(cur.type, cur.name), ep.expression());
             generate(state, expr);
 
             var cont = new Label();
+            unboxPrimitive(state, TargetType.Boolean);
             state.mv.visitJumpInsn(IFNE, cont);
             for (var i = 0; i < depth - 1; i++) {
                 state.mv.visitInsn(POP);
@@ -1672,6 +1719,8 @@ public class Codegen {
         }
         if (clazz.superType() != null)
             ret += clazz.superType().toSignature();
+        else ret += "Ljava/lang/Object;";
+
         for (var intf : clazz.implementingInterfaces()) {
             ret += intf.toSignature();
         }
@@ -1774,8 +1823,12 @@ public class Codegen {
                 } else convertTo(state, fromReturn, toReturn);
             }
 
-            if (toReturn != null)
+            if (toReturn != null) {
+                if ((fromReturn instanceof TargetRefType || fromReturn instanceof TargetGenericType)
+                        && (toReturn instanceof TargetPrimitiveType))
+                    unboxPrimitive(state, TargetType.toWrapper(toReturn));
                 mv.visitInsn(findReturnCode(toReturn));
+            }
 
             else mv.visitInsn(RETURN);
             mv.visitMaxs(0, 0);
@@ -1797,6 +1850,9 @@ public class Codegen {
         }
 
         cw.visitEnd();
+        ClassReader cr = new ClassReader(cw.toByteArray());
+        System.out.println("Checking class " + className);
+        CheckClassAdapter.verify(cr, false, new PrintWriter(System.err));
         return cw.toByteArray();
     }
 

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntaxTreeGenerator.java

@@ -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", 16384);
+    this.allmodifiers.put("default", 0); // Doesn't exist
     this.allmodifiers.put("strictfp", 32768);
 
     this.compiler = compiler;

src/main/java/de/dhbwstuttgart/target/generate/StatementToTargetExpression.java

@@ -161,7 +161,6 @@ 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();

src/main/java/de/dhbwstuttgart/target/tree/expression/TargetLiteral.java

@@ -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.Integer;
+            return TargetType.int_;
         }
     }
 
     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_;
         }
     }
 

src/main/java/de/dhbwstuttgart/target/tree/type/TargetFunNType.java

@@ -33,4 +33,10 @@ public record TargetFunNType(String name, List<TargetType> funNParams, List<Targ
     public String getInternalName() {
         return name;
     }
+
+    @Override
+    public String toSignature() {
+        var args = FunNGenerator.getArguments(params);
+        return "LFun" + args.size() + "$$" + TargetSpecializedType.signatureParameters(params) + ";";
+    }
 }

src/main/java/de/dhbwstuttgart/target/tree/type/TargetSpecializedType.java

@@ -8,14 +8,20 @@ public sealed interface TargetSpecializedType extends TargetType permits TargetF
     @Override
     default String toSignature() {
         String ret = "L" + getInternalName();
-        if (!params().isEmpty()) {
+        ret += signatureParameters(params());
+        ret += ";";
+        return ret;
+    }
+
+    static String signatureParameters(List<TargetType> params) {
+        var ret = "";
+        if (!params.isEmpty()) {
             ret += "<";
-            for (var param : params()) {
+            for (var param : params) {
                 ret += param.toSignature();
             }
             ret += ">";
         }
-        ret += ";";
         return ret;
     }
 

src/test/java/AllgemeinTest.java

@@ -63,13 +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 = "Uncurrier";
-		String className = "UncurrierMain";
 		//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";

src/test/java/KPSPresentation.java

@@ -1,97 +0,0 @@
-
-
-import static org.junit.jupiter.api.Assertions.*;
-import static targetast.TestCodegen.generateClassFiles;
-
-import java.io.File;
-import java.lang.reflect.Field;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.Arrays;
-
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-
-import com.google.common.collect.Lists;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-
-public class KPSPresentation {
-
-	private static String path;
-	private static File fileToTest;
-	private static JavaTXCompiler compiler;
-	private static ClassLoader loader;
-	private static Class<?> classToTest;
-	private static String pathToClassFile;
-	private static Object instanceOfClass;
-	
-
-	public void testAlgo(String className) throws Exception {
-		//PL 2019-10-24: genutzt fuer unterschiedliche Tests
-		path = System.getProperty("user.dir")+"/resources/KPSPresentation/" + className + ".jav";
-		//path = System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/Overloading_Generics.jav";
-		//path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/mathStrucInteger.jav";
-		//compiler = new JavaTXCompiler(Lists.newArrayList(new File(System.getProperty("user.dir")+"/src/test/resources/AllgemeinTest/Overloading_Generics.jav")));
-		///*
-		   compiler = new JavaTXCompiler(
-                Lists.newArrayList(new File(path)),
-                Lists.newArrayList(new File(System.getProperty("user.dir")+"/resources/KPSPresentation/classFiles/")),
-			   	new File(System.getProperty("user.dir")+"/resources/KPSPresentation/classFiles/"));
-		//*/
-		compiler.generateBytecode();
-		pathToClassFile = System.getProperty("user.dir")+"/resources/KPSPresentation/classFiles/";
-		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
-		classToTest = loader.loadClass(className);
-		//classToTest = loader.loadClass("Overloading_Generics");
-		//instanceOfClass = classToTest.getDeclaredConstructor().newInstance("A");
-		//classToTest = loader.loadClass("Overloading_Generics1");
-		//instanceOfClass = classToTest.getDeclaredConstructor(Object.class).newInstance("B");
-	}
-
-	@Test
-	public void MainTest() throws Exception {
-		testAlgo("Main");
-	}
-	
-	@Test
-	public void fstTest() throws Exception {
-		testAlgo("fst");
-	}
-	
-	@Test
-	public void IdTest() throws Exception {
-		testAlgo("Id");
-	}
-	
-	@Test
-	public void OLTest() throws Exception {
-		testAlgo("OL");
-	}
-	
-	@Test
-	public void FacTest() throws Exception {
-		testAlgo("Fac");
-	}
-	
-	@Test
-	public void FacultyTest() throws Exception {
-		testAlgo("Faculty");
-	}
-	
-	@Test
-	public void Lambda() throws Exception {
-		testAlgo("Lambda");
-	}
-	
-	@Test
-	public void applyLambda() throws Exception {
-		testAlgo("applyLambda");
-	}
-	
-	@Test
-	public void Matrix() throws Exception {
-		testAlgo("Matrix");
-	}
-	
-}

src/test/java/TestComplete.java

@@ -1476,4 +1476,21 @@ 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.setAccessible(true);
+        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();
+    }
 }