modified: Main.jav

modified:   Matrix.jav
	modified:   ../../src/test/java/KPSPresentation.java

.gitea/workflows/build_and_test.yml

@@ -1,5 +1,8 @@
 name: Build and Test with Maven
-on: [push]
+on:
+  push:
+    branches-ignore:
+      - master
 
 jobs:
   Build-and-test-with-Maven:

.gitea/workflows/sonarqube.yml

@@ -0,0 +1,45 @@
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+      types: [opened, synchronize, reopened]
+
+name: SonarQube Scan
+jobs:
+  sonarqube:
+    name: SonarQube Trigger
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checking out
+      uses: actions/checkout@v4
+      with:
+        # Disabling shallow clone is recommended for improving relevancy of reporting
+        fetch-depth: 0
+    - name: Install maven
+      run: |
+        apt update
+        apt install -y maven
+    - name: Install java
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'temurin'
+        java-version: '24'
+        cache: 'maven'
+    - name: Compile project
+      run: |
+        mvn clean dependency:copy-dependencies verify
+    - name: SonarQube Scan
+      uses: SonarSource/sonarqube-scan-action@v5.3.0
+      env:
+        SONAR_HOST_URL: ${{ secrets.SONARQUBE_HOST }}
+        SONAR_TOKEN: ${{ secrets.SONARQUBE_TOKEN }}
+      with:
+        args: >
+          -Dsonar.projectKey=Java-TX
+          -Dsonar.sources=src/main/java
+          -Dsonar.tests=src/test/java
+          -Dsonar.junit.reportPaths=target/test-reports
+          -Dsonar.java.binaries=target/classes
+          -Dsonar.java.libraries=target/dependency/*.jar
+          -Dsonar.coverage.jacoco.xmlReportPaths=target/site/jacoco/jacoco.xml

README.md

@@ -0,0 +1,7 @@
+## Java-TX Compiler
+
+[![Lines of Code](https://gitea.hb.dhbw-stuttgart.de/sonarqube/api/project_badges/measure?project=Java-TX&metric=ncloc&token=sqb_d4a372fca7a6b86441243728a6ea5f88183db5eb)](https://gitea.hb.dhbw-stuttgart.de/sonarqube/dashboard?id=Java-TX)
+[![Coverage](https://gitea.hb.dhbw-stuttgart.de/sonarqube/api/project_badges/measure?project=Java-TX&metric=coverage&token=sqb_d4a372fca7a6b86441243728a6ea5f88183db5eb)](https://gitea.hb.dhbw-stuttgart.de/sonarqube/dashboard?id=Java-TX)
+[![Quality Gate Status](https://gitea.hb.dhbw-stuttgart.de/sonarqube/api/project_badges/measure?project=Java-TX&metric=alert_status&token=sqb_d4a372fca7a6b86441243728a6ea5f88183db5eb)](https://gitea.hb.dhbw-stuttgart.de/sonarqube/dashboard?id=Java-TX)
+
+Work in Progress Java-TX Compiler repository!

pom.xml

@@ -48,6 +48,25 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 
 	<build>
 		<plugins>
+			<plugin>
+				<groupId>org.jacoco</groupId>
+				<artifactId>jacoco-maven-plugin</artifactId>
+				<version>0.8.13</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>prepare-agent</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>report</id>
+						<phase>prepare-package</phase>
+						<goals>
+							<goal>report</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
@@ -65,7 +84,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 				<configuration>
 					<redirectTestOutputToFile>true</redirectTestOutputToFile>
 					<reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
-					<argLine>--enable-preview</argLine>
+					<argLine>${argLine} --enable-preview</argLine>
 					<trimStackTrace>false</trimStackTrace>
 					<excludes>
 						<exclude>**/JavaTXCompilerTest.java</exclude>

resources/KPSPresentation/AddEle.jav

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

resources/KPSPresentation/Fac.jav

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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

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

resources/KPSPresentation/Lambda.jav

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

resources/KPSPresentation/Main.jav

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,12 @@
+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

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

resources/KPSPresentation/Sorting.jav

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,20 @@
+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

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

resources/KPSPresentation/Test.jav

@@ -0,0 +1,16 @@
+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

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

resources/KPSPresentation/UncurrierMain.jav

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

resources/KPSPresentation/VectorAdd.jav

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,16 @@
+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

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

resources/KPSPresentation/genVector.jav

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

resources/KPSPresentation/idTest.jav

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

resources/KPSPresentation/lambdaId.jav

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

resources/KPSPresentation/mathStruc.jav

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

resources/KPSPresentation/mathStrucInteger.jav

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,14 @@
+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/Bug325.jav

@@ -6,7 +6,7 @@ import java.util.stream.Stream;
 
 public class Bug325 {
     public main() {
-      List<Integer> list = new ArrayList<>(List.of(1,2,3,4,5));
+      var list = new ArrayList<>(List.of(1,2,3,4,5));
       var func = x -> x*2;
       return list.stream().map(func).toList();
    }

resources/bytecode/javFiles/Bug373.jav

@@ -0,0 +1,17 @@
+import java.lang.Boolean;
+import java.lang.Integer;
+import java.lang.System;
+import java.io.PrintStream;
+import java.lang.Character;
+
+public class Bug373 {
+    public static main() {
+        System.out.println(true);
+        System.out.println(false);
+        System.out.println(1);
+        System.out.println(1l);
+        System.out.println(1.0);
+        System.out.println(1.0f);
+        System.out.println('a');
+    }
+}

resources/bytecode/javFiles/Main.jav

@@ -0,0 +1,14 @@
+import java.lang.Object;
+import java.lang.System;
+import java.lang.Iterable;
+import java.io.PrintStream;
+import java.util.List;
+import java.lang.String;
+
+class Main {
+    static main(args) {
+        for (var arg : args) {
+            System.out.println(arg);
+        }
+    }
+}

resources/bytecode/javFiles/MatrixOP.jav

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

@@ -132,6 +132,7 @@ 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_)) {
             mv.visitMethodInsn(INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false);
@@ -153,6 +154,7 @@ public class Codegen {
     }
 
     private void unboxPrimitive(State state, TargetType type) {
+        if (type instanceof TargetExtendsWildcard ew) type = ew.innerType();
         var mv = state.mv;
         if (type.equals(TargetType.Boolean)) {
             mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
@@ -228,13 +230,16 @@ public class Codegen {
     }
 
     private void convertTo(State state, TargetType source, TargetType dest) {
+        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)) {
+            if (dest.equals(TargetType.Integer))
                 mv.visitInsn(L2I);
-            } else if (dest.equals(TargetType.Float))
+            else if (dest.equals(TargetType.Float))
                 mv.visitInsn(L2F);
             else if (dest.equals(TargetType.Double))
                 mv.visitInsn(L2D);
@@ -277,6 +282,8 @@ public class Codegen {
                 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);
@@ -638,7 +645,7 @@ public class Codegen {
         } else if (op.expr() instanceof TargetFieldVar fieldVar) {
             generate(state, fieldVar.left());
             mv.visitInsn(SWAP);
-            mv.visitFieldInsn(PUTFIELD, fieldVar.owner().getInternalName(), fieldVar.right(), fieldVar.type().toSignature());
+            mv.visitFieldInsn(PUTFIELD, fieldVar.owner().getInternalName(), fieldVar.right(), fieldVar.type().toDescriptor());
         }
     }
 
@@ -801,7 +808,7 @@ public class Codegen {
         var handle = new Handle(state.isStatic ? H_INVOKESTATIC : H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
 
         var params = new ArrayList<TargetType>();
-        if(!state.isStatic) params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
+        if(!state.isStatic) params.add(new TargetRefType(clazz.qualifiedName().toString()));
         params.addAll(lambda.captures().stream().map(mp -> mp.pattern().type()).toList());
 
         if (!state.isStatic)
@@ -940,7 +947,7 @@ public class Codegen {
                         mv.visitInsn(DUP);
                     else
                         mv.visitInsn(DUP_X1);
-                    mv.visitFieldInsn(dot.isStatic() ? PUTSTATIC : PUTFIELD, dot.owner().getInternalName(), dot.right(), fieldType.toSignature());
+                    mv.visitFieldInsn(dot.isStatic() ? PUTSTATIC : PUTFIELD, dot.owner().getInternalName(), dot.right(), fieldType.toDescriptor());
                 }
                 default -> throw new CodeGenException("Invalid assignment");
             }
@@ -957,7 +964,7 @@ public class Codegen {
         case TargetFieldVar dot: {
             if (!dot.isStatic())
                 generate(state, dot.left());
-            mv.visitFieldInsn(dot.isStatic() ? GETSTATIC : GETFIELD, dot.left().type().getInternalName(), dot.right(), dot.type().toSignature());
+            mv.visitFieldInsn(dot.isStatic() ? GETSTATIC : GETFIELD, dot.left().type().getInternalName(), dot.right(), dot.type().toDescriptor());
             unboxPrimitive(state, dot.type());
             break;
         }
@@ -1421,7 +1428,7 @@ public class Codegen {
             throw new CodeGenException("Couldn't find suitable field accessor for '" + type.name() + "'");
         var field = clazz.getFieldDecl().get(i);
         var fieldType = converter.convert(field.getType());
-        state.mv.visitMethodInsn(INVOKEVIRTUAL, type.getInternalName(), field.getName(), "()" + fieldType.toSignature(), false);
+        state.mv.visitMethodInsn(INVOKEVIRTUAL, type.getInternalName(), field.getName(), "()" + fieldType.toDescriptor(), false);
     }
 
     private void bindPattern(State state, TargetType type, TargetPattern pat, Label start, int index, int depth) {
@@ -1526,7 +1533,7 @@ public class Codegen {
         //if ((access & ACC_PRIVATE) == 0 && (access & ACC_PROTECTED) == 0) // TODO Implement access modifiers properly
         //    access |= ACC_PUBLIC;
 
-        cw.visitField(access, field.name(), field.type().toSignature(), field.type().toDescriptor(), null);
+        cw.visitField(access, field.name(), field.type().toDescriptor(), field.type().toSignature(), null);
     }
 
     private void generateStaticConstructor(TargetMethod constructor) {
@@ -1597,8 +1604,27 @@ public class Codegen {
         generateMethod(method, null);
     }
 
+    private void generateMainMethod() {
+        var mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(ALOAD, 0);
+        mv.visitMethodInsn(INVOKESTATIC, "java/util/List", "of", "([Ljava/lang/Object;)Ljava/util/List;", true);
+        mv.visitMethodInsn(INVOKESTATIC, new TargetRefType(clazz.qualifiedName().toString()).getInternalName(), "main", "(Ljava/util/List;)V", false);
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
     private void generateMethod(TargetMethod method, State parent) {
         var access = method.access();
+
+        var params = method.signature().parameters();
+        if (method.name().equals("main") && method.isStatic() && params.size() == 1 &&
+            params.getFirst().pattern().type().equals(new TargetRefType("java.util.List", List.of(new TargetRefType("java.lang.String"))))) {
+
+            generateMainMethod();
+        }
+
         if (method.block() == null)
             access |= ACC_ABSTRACT;
         if (clazz instanceof TargetInterface)
@@ -1640,12 +1666,12 @@ public class Codegen {
         if (!generics.isEmpty()) {
             ret += "<";
             for (var generic : generics) {
-                ret += generic.name() + ":" + generic.bound().toDescriptor();
+                ret += generic.name() + ":" + generic.bound().toSignature();
             }
             ret += ">";
         }
         if (clazz.superType() != null)
-            ret += clazz.superType().toDescriptor();
+            ret += clazz.superType().toSignature();
         for (var intf : clazz.implementingInterfaces()) {
             ret += intf.toSignature();
         }
@@ -1757,7 +1783,7 @@ public class Codegen {
 
             cw2.visitEnd();
             var bytes = cw2.toByteArray();
-            converter.auxiliaries.put(className, bytes);
+            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.
@@ -1800,7 +1826,7 @@ public class Codegen {
         bootstrapArgs[1] = String.join(";", clazz.fields().stream().map(TargetField::name).toArray(String[]::new));
         for (var i = 0; i < clazz.fields().size(); i++) {
             var field = clazz.fields().get(i);
-            var fieldRef = new Handle(H_GETFIELD, clazz.getName(), field.name(), field.type().toSignature(), false);
+            var fieldRef = new Handle(H_GETFIELD, clazz.getName(), field.name(), field.type().toDescriptor(), false);
             bootstrapArgs[i + 2] = fieldRef;
         }
 

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

@@ -98,7 +98,7 @@ public class FunNGenerator {
     }
 
     private static String applySignature(TargetType a) { return a.toSignature(); }
-    private static String applyNameDescriptor(TargetType a){ return a instanceof TargetGenericType ? "LTPH;" : String.format("%s", applySignature(a)); }
+    private static String applyNameDescriptor(TargetType a){ return a instanceof TargetGenericType ? "LTPH;" : String.format("%s", a.toDescriptor()); }
 
     public static String encodeType(TargetType type) {
         if (type == null) return VOID;

src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -2,6 +2,7 @@
 package de.dhbwstuttgart.core;
 
 import de.dhbwstuttgart.bytecode.Codegen;
+import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
@@ -73,6 +74,11 @@ public class JavaTXCompiler {
 	public final List<File> classPath;
 	private final File outputPath;
 
+	public final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
+	public final Set<Integer> usedFunNSuperTypes = new HashSet<>();
+
+	public Map<String, byte[]> auxiliaries = new HashMap<>();
+
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
@@ -646,7 +652,7 @@ public class JavaTXCompiler {
 		}
 		generatedGenerics.put(sf, converter.javaGenerics());
 		converter.generateFunNTypes();
-		converter.auxiliaries.forEach((name, source) -> {
+		auxiliaries.forEach((name, source) -> {
 			generatedClasses.put(new JavaClassName(name), source);
 		});
 		return generatedClasses;

src/main/java/de/dhbwstuttgart/environment/CompilationEnvironment.java

@@ -30,7 +30,7 @@ public class CompilationEnvironment {
 	public final PackageCrawler packageCrawler;
 
 	/**
-	 * Imitiert die Environment beim Aufruf des JavaCompilers auf einer Menge von java-Dateien Die Environment enth<EFBFBD>lt automatisch die Java Standard Library
+	 * Imitiert die Environment beim Aufruf des JavaCompilers auf einer Menge von java-Dateien Die Environment enthält automatisch die Java Standard Library
 	 * 
 	 * @param sourceFiles die zu kompilierenden Dateien
 	 */

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

@@ -150,7 +150,7 @@ public class StatementGenerator {
                 } else {
                 	type = methodparameters?
                 			TypePlaceholder.fresh(fp.getStart(), 1, false) 
-                			: TypePlaceholder.fresh(fp.getStart());
+                			: TypePlaceholder.fresh(fp.getStart(), 1, false);
                 }
                 ret.add(new FormalParameter(paramName, type, fp.getStart()));
                 localVars.put(paramName, type); 
@@ -1065,7 +1065,7 @@ public class StatementGenerator {
             List<Pattern> parameterList = new ArrayList<>();
             for (IdentifierContext identifier : lambdaParams.identifier()) {
                 Token offset = identifier.getStart();
-                parameterList.add(new FormalParameter(identifier.getText(), TypePlaceholder.fresh(offset), offset));
+                parameterList.add(new FormalParameter(identifier.getText(), TypePlaceholder.fresh(offset, 1, false), offset));
             }
             params = new ParameterList(parameterList, lambdaParams.getStart());
         } else if (lambdaParams.formalParameterList() != null) {
@@ -1075,7 +1075,7 @@ public class StatementGenerator {
             List<Pattern> parameterList = new ArrayList<>();
             for (LambdaLVTIParameterContext param : lambdaParams.lambdaLVTIList().lambdaLVTIParameter()) {
                 Token offset = param.getStart();
-                parameterList.add(new FormalParameter(param.identifier().getText(), TypePlaceholder.fresh(offset), offset));
+                parameterList.add(new FormalParameter(param.identifier().getText(), TypePlaceholder.fresh(offset, 1, false), offset));
             }
             params = new ParameterList(parameterList, lambdaParams.getStart());
         } else {

src/main/java/de/dhbwstuttgart/parser/scope/JavaClassName.java

@@ -41,7 +41,7 @@ public class JavaClassName {
 	}
 
 	/**
-	 * Gibt von einem Klassennamen nur den Namen der Klasse zur<EFBFBD>ck
+	 * Gibt von einem Klassennamen nur den Namen der Klasse zurück
 	 * Beispiel:
 	 * java.lang.Object wird zu: Object
 	 */

src/main/java/de/dhbwstuttgart/parser/scope/JavaClassRegistry.java

@@ -5,7 +5,7 @@ import de.dhbwstuttgart.exceptions.NotImplementedException;
 import java.util.*;
 
 /**
- * Speichert die Klassen f<EFBFBD>r einen bestimmten Projektscope
+ * Speichert die Klassen für einen bestimmten Projektscope
  */
 public class JavaClassRegistry{
     final Map<JavaClassName, Integer> existingClasses = new HashMap<>();

src/main/java/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java

@@ -6,10 +6,12 @@ import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.target.tree.TargetGeneric;
 import org.antlr.v4.runtime.Token;
 
 import java.lang.reflect.Modifier;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * Stellt jede Art von Klasse dar. Auch abstrakte Klassen und Interfaces
@@ -31,6 +33,7 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope {
   private List<RefType> implementedInterfaces;
   private List<RefType> permittedSubtypes;
   private List<Constructor> constructors;
+  private Set<GenericTypeVar> userDefinedGenerics;
 
   public ClassOrInterface(int modifiers, JavaClassName name, List<Field> fielddecl, Optional<Constructor> fieldInitializations, Optional<Method> staticInitializer, List<Method> methods, List<Constructor> constructors, GenericDeclarationList genericClassParameters, RefType superClass, Boolean isInterface, Boolean isFunctionalInterface, List<RefType> implementedInterfaces, List<RefType> permittedSubtypes, Token offset, String fileName) {
     super(offset);
@@ -199,4 +202,22 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope {
   public int hashCode() {
     return Objects.hash(name);
   }
+
+  public Set<GenericTypeVar> getUserDefinedGenerics() {
+    if (this.userDefinedGenerics != null) return this.userDefinedGenerics;
+
+    var genericsIter = getGenerics().iterator();
+    if (genericsIter.hasNext()) {
+      // Add empty set of generics to cache so that it doesn't try to calculate it later
+      this.userDefinedGenerics = new HashSet<>();
+      while (genericsIter.hasNext()) {
+        var next = genericsIter.next();
+        userDefinedGenerics.add(next);
+      }
+    } else {
+      this.userDefinedGenerics = new HashSet<>();
+    }
+
+    return this.userDefinedGenerics;
+  }
 }

src/main/java/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -5,8 +5,10 @@ import java.util.*;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
 //import sun.security.x509.X509CertInfo;
 
 public class SourceFile extends SyntaxTreeNode {
@@ -18,6 +20,7 @@ public class SourceFile extends SyntaxTreeNode {
   private boolean isGenerated;
 
   public List<ClassOrInterface> availableClasses = new ArrayList<>();
+  public List<ASTToTargetAST.Generics> generics = new ArrayList<>();
 
   /**
    * Die SourceFile repräsntiert eine zu einem Syntaxbaum eingelesene Java-Datei.
@@ -40,6 +43,10 @@ public class SourceFile extends SyntaxTreeNode {
     this.imports = new HashSet<>(sf.imports);
   }
 
+  public void addResultSet(ResultSet rs) {
+
+  }
+
   public void setPackageName(String packageName) {
     this.pkgName = packageName;
   }

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

@@ -36,7 +36,6 @@ public class ASTToTargetAST {
     public Generics generics;
     public List<Generics> currentMethodOverloads;
 
-    final Map<ClassOrInterface, Set<GenericTypeVar>> userDefinedGenerics = new HashMap<>();
     final Map<Method, Set<SignaturePair>> tphsInMethods = new HashMap<>();
     private Method currentMethod;
 
@@ -61,9 +60,11 @@ public class ASTToTargetAST {
     }
 
     public record Generics(JavaGenerics javaGenerics, TxGenerics txGenerics) {
+        public Generics(JavaTXCompiler compiler, ResultSet set) {
+            this(new JavaGenerics(compiler, set), new TxGenerics(compiler, set));
+        }
     }
 
-
     public IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
@@ -81,9 +82,9 @@ public class ASTToTargetAST {
 
         all = new ArrayList<>();
         for (var set : resultSets) {
-            all.add(new Generics(new JavaGenerics(this, set), new TxGenerics(this, set)));
+            all.add(new Generics(compiler, set));
         }
-        this.generics = all.get(0);
+        this.generics = all.getFirst();
     }
 
     public void addSignaturePair(TypePlaceholder signature, RefTypeOrTPHOrWildcardOrGeneric parameter) {
@@ -93,9 +94,13 @@ public class ASTToTargetAST {
     }
 
     Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList) {
+        return findMethod(owner, name, argumentList, this.generics.javaGenerics, this.compiler);
+    }
+
+    public static Optional<Method> findMethod(ClassOrInterface owner, String name, List<TargetType> argumentList, GenerateGenerics generics, JavaTXCompiler compiler) {
         Optional<Method> method = Optional.empty();
         while (method.isEmpty()) {
-            method = owner.getMethods().stream().filter(m -> m.name.equals(name) && parameterEquals(m.getParameterList(), argumentList)).findFirst();
+            method = owner.getMethods().stream().filter(m -> m.name.equals(name) && parameterEquals(m.getParameterList(), argumentList, generics)).findFirst();
             if (owner.getClassName().toString().equals("java.lang.Object")) break;
             owner = compiler.getClass(owner.getSuperClass().getName());
         }
@@ -103,16 +108,16 @@ public class ASTToTargetAST {
     }
 
     Optional<Constructor> findConstructor(ClassOrInterface owner, List<TargetType> argumentList) {
-        return owner.getConstructors().stream().filter(c -> parameterEquals(c.getParameterList(), argumentList)).findFirst();
+        return owner.getConstructors().stream().filter(c -> parameterEquals(c.getParameterList(), argumentList, generics.javaGenerics)).findFirst();
     }
 
-    boolean parameterEquals(ParameterList parameterList, List<TargetType> arguments) {
+    static boolean parameterEquals(ParameterList parameterList, List<TargetType> arguments, GenerateGenerics generics) {
         var pars = parameterList.getFormalparalist();
         if (pars.size() != arguments.size())
             return false;
 
         for (var i = 0; i < pars.size(); i++) {
-            var type1 = convert(pars.get(i).getType(), generics.javaGenerics);
+            var type1 = generics.getTargetType(pars.get(i).getType());
             var type2 = arguments.get(i);
             if (type1 instanceof TargetGenericType)
                 return true;
@@ -350,19 +355,14 @@ public class ASTToTargetAST {
         Set<TargetGeneric> javaGenerics = new HashSet<>();
         Set<TargetGeneric> txGenerics = new HashSet<>();
 
-        var genericsIter = input.getGenerics().iterator();
-        if (genericsIter.hasNext()) {
+        var userDefinedGenerics = input.getUserDefinedGenerics();
+        if (!userDefinedGenerics.isEmpty()) {
             // Add empty set of generics to cache so that it doesn't try to calculate it later
-            var userDefinedGenerics = new HashSet<GenericTypeVar>();
-            this.userDefinedGenerics.put(input, userDefinedGenerics);
-            while (genericsIter.hasNext()) {
-                var next = genericsIter.next();
-                userDefinedGenerics.add(next);
-                // TODO Support multiple bounds
-                javaGenerics.add(new TargetGeneric(next.getName(), convert(next.getBounds().get(0))));
+            for (var generic : userDefinedGenerics) {
+                // TODO Support multiple bouds
+                javaGenerics.add(new TargetGeneric(generic.getName(), convert(generic.getBounds().getFirst())));
             }
         } else {
-            this.userDefinedGenerics.put(input, new HashSet<>());
             // Generate generics only if there are no user defined ones
             javaGenerics = convert(generics.javaGenerics.generics(input), generics.javaGenerics);
             txGenerics = convert(generics.txGenerics.generics(input), generics.txGenerics);
@@ -424,7 +424,7 @@ public class ASTToTargetAST {
     }
 
     private List<TargetConstructor> convert(ClassOrInterface currentClass, Constructor input, TargetBlock fieldInitializer) {
-        generics = all.get(0);
+        generics = all.getFirst();
         List<TargetConstructor> result = new ArrayList<>();
         Set<List<MethodParameter>> parameterSet = new HashSet<>();
         this.currentMethod = input;
@@ -468,13 +468,6 @@ public class ASTToTargetAST {
         }
     }
 
-    private TargetType unwrap(TargetType type) {
-        if (type instanceof TargetRefType ref) {
-            if (!ref.params().isEmpty()) return new TargetRefType(ref.name());
-        }
-        return type;
-    }
-
     private TargetExpression generatePatternOverloadsRec(int offset, TargetExpression switchExpr, List<TargetLocalVar> params, List<TargetPattern> patterns, List<TargetMethod> methods, TargetType classType) {
         if (methods.isEmpty()) throw new DebugException("Couldn't find a candidate for switch overloading");
         if (methods.size() == 1) {
@@ -745,11 +738,6 @@ public class ASTToTargetAST {
         return new TargetField(input.modifier, convert(input.getType(), generics.javaGenerics), input.getName());
     }
 
-    private final Map<String, FunNGenerator.GenericParameters> usedFunN = new HashMap<>();
-    private final Set<Integer> usedFunNSuperTypes = new HashSet<>();
-
-    public Map<String, byte[]> auxiliaries = new HashMap<>();
-
     public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input) {
         return convert(input, generics.javaGenerics);
     }
@@ -818,20 +806,24 @@ public class ASTToTargetAST {
     }
 
     public void generateFunNTypes() {
-        for (var entry : usedFunN.entrySet()) {
+        for (var entry : compiler.usedFunN.entrySet()) {
             var gep = entry.getValue();
-            var superInterfaces = usedFunN.values().stream()
+            var superInterfaces = compiler.usedFunN.values().stream()
                 .filter(g -> !g.equals(gep))
                 .filter(genericParameters -> isSubtype(gep, genericParameters))
                 .map(FunNGenerator::getSpecializedClassName)
                 .toList();
 
             var code = FunNGenerator.generateSpecializedBytecode(gep, superInterfaces);
-            auxiliaries.put(entry.getKey(), code);
+            compiler.auxiliaries.put(entry.getKey(), code);
         }
     }
 
-    protected TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
+    public TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics) {
+        return convert(input, generics, compiler);
+    }
+
+    public static TargetType convert(RefTypeOrTPHOrWildcardOrGeneric input, GenerateGenerics generics, JavaTXCompiler compiler) {
         return input.acceptTV(new TypeVisitor<>() {
             @Override
             public TargetType visit(RefType refType) {
@@ -843,31 +835,31 @@ public class ASTToTargetAST {
                 }
 
                 var params = refType.getParaList().stream().map(type -> {
-                    return convert(type, generics);
+                    return convert(type, generics, compiler);
                 }).toList();
 
                 if (name.matches("Fun\\d+\\$\\$")) { // TODO This seems like a bad idea
                     var returnType = FunNGenerator.getReturnType(params);
                     var className = FunNGenerator.getSpecializedClassName(FunNGenerator.getArguments(params), returnType);
-                    if (!usedFunNSuperTypes.contains(params.size())) {
-                        usedFunNSuperTypes.add(params.size());
+                    if (!compiler.usedFunNSuperTypes.contains(params.size())) {
+                        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 {
-                            classLoader.findClass(superClassName);
+                            compiler.classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
                             try {
-                                classLoader.loadClass(superClassName, code);
+                                compiler.classLoader.loadClass(superClassName, code);
                             } catch (LinkageError ignored) {}
                         }
-                        auxiliaries.put(superClassName, code);
+                        compiler.auxiliaries.put(superClassName, code);
                     }
                     FunNGenerator.GenericParameters gep = null;
-                    if (!usedFunN.containsKey(className)) {
+                    if (!compiler.usedFunN.containsKey(className)) {
                         gep = new FunNGenerator.GenericParameters(params, returnType != null ? 1 : 0);
-                        usedFunN.put(className, gep);
+                        compiler.usedFunN.put(className, gep);
                     } else {
-                        gep = usedFunN.get(className);
+                        gep = compiler.usedFunN.get(className);
                     }
                     return flattenFunNType(params, gep);
                 }
@@ -876,7 +868,7 @@ public class ASTToTargetAST {
 
             @Override
             public TargetType visit(SuperWildcardType superWildcardType) {
-                return new TargetSuperWildcard(convert(superWildcardType.getInnerType(), generics));
+                return new TargetSuperWildcard(convert(superWildcardType.getInnerType(), generics, compiler));
             }
 
             @Override
@@ -886,7 +878,7 @@ public class ASTToTargetAST {
 
             @Override
             public TargetType visit(ExtendsWildcardType extendsWildcardType) {
-                return new TargetExtendsWildcard(convert(extendsWildcardType.getInnerType(), generics));
+                return new TargetExtendsWildcard(convert(extendsWildcardType.getInnerType(), generics, compiler));
             }
 
             @Override

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

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.parser.JavaTXParser;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -18,7 +20,7 @@ import java.util.stream.Stream;
 
 public abstract class GenerateGenerics {
 
-    private final ASTToTargetAST astToTargetAST;
+    private final JavaTXCompiler compiler;
 
     public class TPH {
         private final TypePlaceholder wrap;
@@ -134,8 +136,8 @@ public abstract class GenerateGenerics {
     Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes = new HashMap<>();
     Map<TypePlaceholder, TypePlaceholder> equality = new HashMap<>();
 
-    GenerateGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
-        this.astToTargetAST = astToTargetAST;
+    GenerateGenerics(JavaTXCompiler compiler, ResultSet constraints) {
+        this.compiler = compiler;
         for (var constraint : constraints.results) {
             if (constraint instanceof PairTPHsmallerTPH p) {
                 System.out.println(p.left + " " + p.left.getVariance());
@@ -281,7 +283,7 @@ public abstract class GenerateGenerics {
             Set<TPH> typeVariablesOfClass,
             Set<Pair> result
     ) {
-        var userDefinedGenericsOfClass = astToTargetAST.userDefinedGenerics.get(owner);
+        var userDefinedGenericsOfClass = owner.getUserDefinedGenerics();
 
         // Type variables with bounds that are also type variables of the method
         for (var typeVariable : new HashSet<>(typeVariables)) {
@@ -329,7 +331,7 @@ public abstract class GenerateGenerics {
 
                     if (methodCall.receiver instanceof ExpressionReceiver expressionReceiver) {
                         if (expressionReceiver.expr instanceof This) {
-                            var optMethod = astToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(astToTargetAST::convert).toList());
+                            var optMethod = ASTToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(x -> getTargetType(x)).toList(), GenerateGenerics.this, compiler);
                             if (optMethod.isEmpty()) return;
                             var method2 = optMethod.get();
                             System.out.println("In: " + method.getName() + " Method: " + method2.getName());
@@ -1005,8 +1007,8 @@ public abstract class GenerateGenerics {
             }
             var type = concreteTypes.get(new TPH(tph));
             if (type == null) return new TargetGenericType(tph.getName());
-            return astToTargetAST.convert(type, this);
+            return ASTToTargetAST.convert(type, this, compiler);
         }
-        return astToTargetAST.convert(in, this);
+        return ASTToTargetAST.convert(in, this, compiler);
     }
 }

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

@@ -69,8 +69,4 @@ public class GenericsResult {
             return this.generics.getType(tph);
         return type;
     }
-
-    public TargetType resolveTarget(RefTypeOrTPHOrWildcardOrGeneric type) {
-        return this.generics.getTargetType(type);
-    }
 }

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -7,8 +8,8 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import java.util.Set;
 
 final class JavaGenerics extends GenerateGenerics {
-    JavaGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
-        super(astToTargetAST, constraints);
+    JavaGenerics(JavaTXCompiler compiler, ResultSet constraints) {
+        super(compiler, constraints);
     }
 
     @Override

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -7,8 +8,8 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import java.util.Set;
 
 final class TxGenerics extends GenerateGenerics {
-    TxGenerics(ASTToTargetAST astToTargetAST, ResultSet constraints) {
-        super(astToTargetAST, constraints);
+    TxGenerics(JavaTXCompiler compiler, ResultSet constraints) {
+        super(compiler, constraints);
     }
 
     @Override

src/main/java/de/dhbwstuttgart/target/tree/TargetMethod.java

@@ -36,30 +36,30 @@ public record TargetMethod(int access, String name, TargetBlock block, Signature
     public static String getDescriptor(TargetType returnType, TargetType... parameters) {
         String ret = "(";
         for (var parameterType : parameters) {
-            ret += parameterType.toSignature();
+            ret += parameterType.toDescriptor();
         }
         ret += ")";
         if (returnType == null) ret += "V";
-        else ret += returnType.toSignature();
+        else ret += returnType.toDescriptor();
         return ret;
     }
 
     public static String getSignature(Set<TargetGeneric> generics, List<MethodParameter> parameters, TargetType returnType) {
         String ret = "";
-        if (generics.size() > 0) {
+        if (!generics.isEmpty()) {
             ret += "<";
             for (var generic : generics) {
-                ret += generic.name() + ":" + generic.bound().toDescriptor();
+                ret += generic.name() + ":" + generic.bound().toSignature();
             }
             ret += ">";
         }
         ret += "(";
         for (var param : parameters) {
-            ret += param.pattern().type().toDescriptor();
+            ret += param.pattern().type().toSignature();
         }
         ret += ")";
         if (returnType == null) ret += "V";
-        else ret += returnType.toDescriptor();
+        else ret += returnType.toSignature();
         return ret;
     }
 

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

@@ -3,12 +3,12 @@ package de.dhbwstuttgart.target.tree.type;
 public record TargetExtendsWildcard(TargetType innerType) implements TargetType {
     @Override
     public String toSignature() {
-        return innerType.toSignature();
+        return "+" + innerType.toSignature();
     }
 
     @Override
     public String toDescriptor() {
-        return "+" + innerType.toDescriptor();
+        return innerType.toDescriptor();
     }
 
     @Override

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

@@ -33,9 +33,4 @@ public record TargetFunNType(String name, List<TargetType> funNParams, List<Targ
     public String getInternalName() {
         return name;
     }
-
-    @Override
-    public String toSignature() {
-        return "L" + getInternalName() + ";";
-    }
 }

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

@@ -2,12 +2,12 @@ package de.dhbwstuttgart.target.tree.type;
 
 public record TargetGenericType(String name) implements TargetType {
     @Override
-    public String toSignature() {
+    public String toDescriptor() {
         return "Ljava/lang/Object;"; // TODO Use bounds for this?
     }
 
     @Override
-    public String toDescriptor() {
+    public String toSignature() {
         return "T" + getInternalName() + ";";
     }
 

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

@@ -12,11 +12,6 @@ public record TargetRefType(String name, List<TargetType> params) implements Tar
         return this.name.replaceAll("\\.", "/");
     }
 
-    @Override
-    public String toSignature() {
-        return "L" + getInternalName() + ";";
-    }
-
     // Type erasure means we need to override hashCode and equals to only consider the name
     @Override
     public int hashCode() {

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

@@ -6,16 +6,21 @@ public sealed interface TargetSpecializedType extends TargetType permits TargetF
     List<TargetType> params();
 
     @Override
-    default String toDescriptor() {
+    default String toSignature() {
         String ret = "L" + getInternalName();
-        if (params().size() > 0) {
+        if (!params().isEmpty()) {
             ret += "<";
             for (var param : params()) {
-                ret += param.toDescriptor();
+                ret += param.toSignature();
             }
             ret += ">";
         }
         ret += ";";
         return ret;
     }
+
+    @Override
+    default String toDescriptor() {
+        return "L" + getInternalName() + ";";
+    }
 }

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

@@ -3,12 +3,12 @@ package de.dhbwstuttgart.target.tree.type;
 public record TargetSuperWildcard(TargetType innerType) implements TargetType {
     @Override
     public String toSignature() {
-        return innerType.toSignature();
+        return "-" + innerType.toSignature();
     }
 
     @Override
     public String toDescriptor() {
-        return "-" + innerType.toDescriptor();
+        return innerType.toDescriptor();
     }
 
     @Override

src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.parser.antlr.Java17Parser;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
@@ -9,15 +10,18 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.util.BiRelation;
 import org.antlr.v4.runtime.Token;
 
+import java.lang.reflect.Modifier;
 import java.util.*;
 
 public class TYPE {
@@ -87,12 +91,25 @@ public class TYPE {
         TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
         TYPEStmt methodScope = new TYPEStmt(blockInfo);
         ConstraintSet constraintSet = new ConstraintSet();
-        m.getParameterList().getFormalparalist().forEach(el -> {
-            if(el instanceof RecordPattern){
-                constraintSet.addAll(addRecursiveParameterConstraints((RecordPattern) el, blockInfo));
 
-            }
-        });
+        if (m.name.equals("main") && Modifier.isStatic(m.modifier) && m.getParameterList().getFormalparalist().size() == 1) {
+            // Add constraint for main method
+            var firstParam = m.getParameterList().getParameterAt(0);
+
+            constraintSet.addUndConstraint(new Pair(firstParam.getType(),
+                new RefType(new JavaClassName("java.util.List"),
+                    List.of(new RefType(new JavaClassName("java.lang.String"), new NullToken())),
+                    new NullToken()),
+                PairOperator.EQUALSDOT));
+        } else {
+            m.getParameterList().getFormalparalist().forEach(el -> {
+                if (el instanceof RecordPattern rp){
+                    constraintSet.addAll(addRecursiveParameterConstraints(rp, blockInfo));
+                }
+            });
+        }
+
+
         m.block.accept(methodScope);
         constraintSet.addAll(methodScope.getConstraints());
         return constraintSet;

src/test/java/AllgemeinTest.java

@@ -63,11 +63,13 @@ 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

@@ -0,0 +1,97 @@
+
+
+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

@@ -1196,6 +1196,15 @@ public class TestComplete {
         assertEquals(20, m.invoke(instance));
     }
 
+    @Test
+    public void testMain() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Main.jav");
+        var clazz = classFiles.get("Main");
+        var m = clazz.getDeclaredMethod("main", List.class);
+        m.setAccessible(true);
+        m.invoke(null, List.of("foo", "bar", "baz"));
+    }
+
     @Test
     public void testBug122() throws Exception {
         var classFiles = generateClassFiles(createClassLoader(), "Bug122.jav");
@@ -1459,4 +1468,12 @@ public class TestComplete {
         var m = clazz.getDeclaredMethod("test");
         assertEquals(true, m.invoke(null));
     }
+
+    @Test
+    public void testBug373() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Bug373.jav");
+        var clazz = classFiles.get("Bug373");
+        var m = clazz.getDeclaredMethod("main");
+        m.invoke(null);
+    }
 }

src/test/java/targetast/TestCodegen.java

@@ -66,7 +66,7 @@ public class TestCodegen {
 
             converter.generateFunNTypes();
 
-            for (var entry : converter.auxiliaries.entrySet()) {
+            for (var entry : compiler.auxiliaries.entrySet()) {
                 writeClassFile(entry.getKey(), entry.getValue());
             }
         }
@@ -112,7 +112,7 @@ public class TestCodegen {
 
         converter.generateFunNTypes();
 
-        for (var entry : converter.auxiliaries.entrySet()) {
+        for (var entry : compiler.auxiliaries.entrySet()) {
             writeClassFile(entry.getKey(), entry.getValue());
         }