Merge branch 'master' of https://gitea.hb.dhbw-stuttgart.de/JavaTX/JavaCompilerCore

modified:   resources/bytecode/javFiles/Primzahlen.jav
	modified:   src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java
	modified:   src/main/java/de/dhbwstuttgart/syntaxtree/statement/Block.java
	modified:   src/main/java/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/distributeVariance.java
	modified:   src/test/java/TestComplete.java

resources/bytecode/javFiles/Bug409.jav

@@ -0,0 +1,13 @@
+import java.lang.Integer;
+
+public class Bug409 {
+    public static m() {
+        var n = 0;
+        for (var i = 0; i < 5; i++) {
+            n = n + 1;
+            if (n > 100) { return -1; }
+            if (i == 2) { continue; }
+        }
+        return n;
+    }
+}

resources/bytecode/javFiles/Bug411.jav

@@ -0,0 +1,7 @@
+import java.lang.Integer;
+
+public interface Bug411 {
+    default f() {
+        return 1;
+    }
+}

resources/bytecode/javFiles/Bug412.jav

@@ -0,0 +1,12 @@
+import java.lang.Integer;
+
+public class Bug412 {
+    public m(Integer i) {
+        var r = 0;
+        switch (i) {
+            case 1: r = 10; break;
+            default: r = 20;
+        }
+        return r;
+    }
+}

resources/bytecode/javFiles/Bug416.jav

@@ -0,0 +1,9 @@
+import java.lang.Integer;
+sealed interface L<T> permits Cons, Nil {}
+public record Cons<T>(T head, L<T> tail) implements L<T> {}
+public record Nil<T>() implements L<T> {}
+
+public class Bug416 {
+    public static <T> len(Cons(h, t)) { return 1 + len(t); }
+    public static <T> len(Nil()) { return 0; }
+}

resources/bytecode/javFiles/Bug417.jav

@@ -0,0 +1,11 @@
+import java.lang.Integer;
+import java.lang.String;
+
+public class Bug417 {
+    public name(Integer i) {
+        return switch (i) {
+            case 1 -> "one";
+            default -> "many";
+        };
+    }
+}

resources/bytecode/javFiles/Bug421.jav

@@ -0,0 +1,3 @@
+public class Bug421 {
+    public m() { return 1 } // Missing semicolon
+}

resources/bytecode/javFiles/Bug422.jav

@@ -0,0 +1,2 @@
+public class Bug422 {}
+public class Bug422 {}

resources/bytecode/javFiles/LazyList.jav

@@ -13,15 +13,15 @@ public sealed interface LazyList permits Empty, Cons {
     public Integer fst();
     public LazyList rest();
 }
-
+/*
 public class Filter {
-    /*public LazyList filter(Fun1$$<Integer, Boolean> p, LazyList l) {
+    public LazyList filter(Fun1$$<Integer, Boolean> p, LazyList l) {
         return switch(l) {
             case Empty e -> e;
             case Cons(Integer x, Supplier<LazyList> l1) ->
                 p.apply(x) ? new Cons(x, () -> filter(p, l1.get())) : filter(p, l1.get());
         };
-    }*/
+    }
     public LazyList filter(Fun1$$<Integer, Boolean> p, Empty()@l) {
         return l;
     }
@@ -31,6 +31,8 @@ public class Filter {
     }
 }
 
+*/
+
 //Der Konstruktor Cons muss lazy sein, deshalb hier Supplier<...>
 record Cons(Integer x, Fun0$$<LazyList> l) implements LazyList {
     public Integer fst() { return this.x; }
@@ -45,7 +47,7 @@ record Empty() implements LazyList {
     public LazyList rest() { return null; }
 }
 
-
+/*
 class Main {
     static LazyList Count(int i) { return new Cons(i, () -> Count(i+1)); }
 
@@ -54,3 +56,4 @@ class Main {
         System.out.println(Count(1).rest().fst());
     }
 }
+*/

resources/bytecode/javFiles/Literal.jav

@@ -5,4 +5,8 @@ public class Literal {
     public m2() { return 'C'; }
     public m3() { return 10L; }
     public m4() { return 10.5F; }
+    public m5() { return 10.5D; }
+    public m6() { return 0xFF; }
+    public m7() { return 0b101010; }
+    public m8() { return 010; }
 }

resources/bytecode/javFiles/Primzahlen.jav

@@ -7,9 +7,10 @@ import java.io.PrintStream;
 import LazyList;
 import Cons;
 import Empty;
-import Filter;
+//import Filter;
 
 public class Primzahlen {
+/*
     static LazyList from(Integer i) { return new Cons(i, () -> from(i+1)); }
 
     /*LazyList filter(Fun1$$<Integer, Boolean> p, LazyList l) {
@@ -18,7 +19,7 @@ public class Primzahlen {
             case Cons(Integer x, Fun0$$<LazyList> l1) ->
                 p.apply(x) ? new Cons(x, () -> filter(p, l1.apply())) : filter(p, l1.apply());
         };
-    }*/
+    }
 
     LazyList dropMul(Integer x, LazyList xs) {
 	    return new Filter().filter(y -> (y % x != 0), xs);
@@ -40,13 +41,13 @@ public class Primzahlen {
                 new Cons(x, () -> take(n-1, l1.apply()));
         };
 	};
-
+*/
     public static void main(args) {
-        System.out.println(new Cons(1, () -> new Cons(2, () -> new Empty())).fst());
+        //System.out.println(new Cons(1, () -> new Cons(2, () -> new Empty())).fst());
         var l = new Cons(1, () -> new Cons(2, () -> new Cons(2, () -> new Empty())));
-        System.out.println(l);
-        var filtered = new Filter().filter(x -> x == 2, l);
-        System.out.println(filtered);
+        //System.out.println(l);
+        //var filtered = new Filter().filter(x -> x == 2, l);
+        //ystem.out.println(filtered);
         //System.out.println(from(1).rest().fst());
         //Primzahlen pz = new Primzahlen();
         //System.out.println(pz.take(10, pz.from(2)));

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

@@ -1056,6 +1056,7 @@ public class Codegen {
             }
 
             Label start = new Label();
+            Label skip = new Label();
             Label end = new Label();
             mv.visitLabel(start);
             if (_for.termination() != null) {
@@ -1068,13 +1069,14 @@ public class Codegen {
             }
 
             var env = new BreakEnv();
-            env.startLabel = start;
+            env.startLabel = skip;
             env.endLabel = end;
 
             state.breakStack.push(env);
             generate(state, _for.body());
             state.breakStack.pop();
 
+            mv.visitLabel(skip);
             if (_for.increment() != null) {
                 _for.increment().forEach(e -> {
                     generate(state, e);
@@ -1435,13 +1437,16 @@ public class Codegen {
             if (label instanceof TargetTypePattern || label instanceof TargetComplexPattern) {
                 if (label.type() instanceof TargetGenericType) types.add(Type.getType(Object.class));
                 else types.add(Type.getObjectType(label.type().getInternalName()));
-            } else if (label instanceof TargetLiteral lit) {
-                types.add(lit.value());
+            } else if (label instanceof TargetExpressionPattern expr) {
+                if (expr.expression() instanceof TargetLiteral literal) {
+                    types.add(Type.getObjectType(TargetType.toWrapper(literal.type()).getInternalName()));
+                } else {
+                    throw new NotImplementedException();
+                }
             } else if (label instanceof TargetGuard guard) {
                 types.add(Type.getObjectType(guard.inner().type().getInternalName()));
                 // TODO Same here we need to evaluate constant;
             } else {
-                logger.info(label);
                 throw new NotImplementedException();
             }
         }
@@ -1775,7 +1780,7 @@ public class Codegen {
             if (parent != null) {
                 state.scope.parent = parent.scope;
             }
-            var offset = 1;
+            var offset = method.isStatic() ? 0 : 1;
             for (var param : method.signature().parameters()) {
                 state.createVariable(param.pattern().name(), param.pattern().type());
             }

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

@@ -5,6 +5,7 @@ import de.dhbwstuttgart.bytecode.Codegen;
 import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
+import de.dhbwstuttgart.exceptions.CompilerException;
 import de.dhbwstuttgart.exceptions.CompilerWarning;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.exceptions.WarningsException;
@@ -171,6 +172,8 @@ public class JavaTXCompiler {
 
 				var numberOfGenerics = decl == null ? 0 : decl.genericTypeVar().size();
 				var className = pkgName + (!pkgName.isEmpty() ? "." : "") + name;
+				if (classRegistry.contains(className))
+					throw new CompilerException("Duplicate class definition: " + className);
 				classRegistry.addName(className, numberOfGenerics);
 				input.add(classRegistry.getName(className));
 			}

src/main/java/de/dhbwstuttgart/exceptions/CompilerException.java

@@ -0,0 +1,7 @@
+package de.dhbwstuttgart.exceptions;
+
+public class CompilerException extends RuntimeException {
+    public CompilerException(String message) {
+        super(message);
+    }
+}

src/main/java/de/dhbwstuttgart/exceptions/ParserError.java

@@ -2,9 +2,8 @@ package de.dhbwstuttgart.exceptions;
 
 import org.antlr.v4.runtime.Token;
 
-public class ParserError extends TypeinferenceException{
-
-	public ParserError(Token offset){
-		super("Fehler beim Parsen", offset);
+public class ParserError extends RuntimeException{
+	public ParserError(String message) {
+		super(message);
 	}
 }

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

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.parser;
 
 import de.dhbwstuttgart.environment.CompilationEnvironment;
+import de.dhbwstuttgart.exceptions.ParserError;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java17Lexer;
 import de.dhbwstuttgart.parser.antlr.Java17Parser;
@@ -8,9 +9,7 @@ import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 
 import de.dhbwstuttgart.util.Logger;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.*;
 
 import java.io.*;
 import java.nio.charset.StandardCharsets;
@@ -21,13 +20,25 @@ public class JavaTXParser {
 
     public static Logger logger = new Logger("Parser");
 
+    public static class ThrowingErrorListener extends BaseErrorListener {
+
+        @Override
+        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol,
+                                int line, int charPositionInLine, String msg, RecognitionException e) {
+            throw new ParserError("Syntax error at line " + line +  ":" + charPositionInLine + " - " + msg);
+        }
+    }
+
     public static Java17Parser.SourceFileContext parse(File source) throws IOException, java.lang.ClassNotFoundException {
         InputStream stream = new FileInputStream(source);
         // DEPRECATED: ANTLRInputStream input = new ANTLRInputStream(stream);
+        var errorListener = new ThrowingErrorListener();
         CharStream input = CharStreams.fromStream(stream);
         Java17Lexer lexer = new Java17Lexer(input);
+        lexer.addErrorListener(errorListener);
         CommonTokenStream tokens = new CommonTokenStream(lexer);
         Java17Parser parser = new Java17Parser(tokens);
+        parser.addErrorListener(errorListener);
         return parser.sourceFile();
         /*
          * SyntaxTreeGenerator generator = new SyntaxTreeGenerator(environment.getRegistry(source)); return generator.convert(tree);

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

@@ -15,6 +15,7 @@ import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 
+import java.lang.reflect.Modifier;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -54,7 +55,8 @@ public class FCGenerator {
     
     
     private static Boolean isFunctionalInterface(ClassOrInterface cly)	{
-    	return (cly.isInterface() && (cly.isFunctionalInterface() || cly.getMethods().size() == 1)); 
+        // TODO isFunctionalInterface should be set properly, we shouldn't need to check it again
+        return (cly.isInterface() && (cly.isFunctionalInterface() || cly.getMethods().size() == 1 && Modifier.isAbstract(cly.getMethods().getFirst().modifier)));
     }
     
     private static Pair genImplFunType(ClassOrInterface cly, RefTypeOrTPHOrWildcardOrGeneric fIType, HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs) {

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

@@ -405,14 +405,16 @@ public class StatementGenerator {
 
     private SwitchBlock convert(Java17Parser.SwitchBlockStatementGroupContext stmt) {
         List<SwitchLabel> labels = new ArrayList<>();
-        stmt.switchLabel().forEach((label) -> {
+        var isDefault = false;
+        for (var label : stmt.switchLabel()) {
+            if (label instanceof SwitchLabelDefaultContext) isDefault = true;
             labels.add(convert(label));
-        });
+        }
         List<Statement> block = new ArrayList<>();
         stmt.blockStatement().stream().forEach((blockStmt) -> {
             block.addAll(convert(blockStmt));
         });
-        return new SwitchBlock(labels, new Block(block, stmt.blockStatement(0).getStart()), false, stmt.getStart());
+        return new SwitchBlock(labels, new Block(block, stmt.blockStatement(0).getStart()), isDefault,false, stmt.getStart());
     }
 
     private SwitchLabel convert(SwitchLabelContext switchLabel) {
@@ -1033,10 +1035,22 @@ public class StatementGenerator {
     private Expression convert(Java17Parser.LiteralContext literal) {
         switch (literal) {
         case IntLiteralContext intliteral:
+            var text = intliteral.getText();
+            var radix = 10;
+            if (text.startsWith("0x") || text.startsWith("0X")) {
+                radix = 16;
+                text = text.substring(2);
+            } else if (text.startsWith("0b") || text.startsWith("0B")) {
+                radix = 2;
+                text = text.substring(2);
+            } else if (text.startsWith("0") && text.length() > 1) {
+                radix = 8;
+                text = text.substring(1);
+            }
             Number value;
-            if (intliteral.getText().endsWith("l") || intliteral.getText().endsWith("L"))
-                value = Long.parseLong(intliteral.getText().substring(0, intliteral.getText().length() - 1));
-            else value = Integer.parseInt(intliteral.getText());
+            if (text.endsWith("l") || text.endsWith("L"))
+                value = Long.parseLong(text.substring(0, text.length() - 1), radix);
+            else value = Integer.parseInt(text, radix);
             return new Literal(TypePlaceholder.fresh(literal.getStart()), value, intliteral.getStart());
         case FltLiteralContext floatliteral:
             if (floatliteral.getText().endsWith("f") || floatliteral.getText().endsWith("F"))
@@ -1097,7 +1111,7 @@ public class StatementGenerator {
         if (expression.lambdaBody().expression() != null) {
             List<Statement> statements = new ArrayList<>();
             statements.add(new Return(lambdaGenerator.convert(expression.lambdaBody().expression()), expression.lambdaBody().expression().getStart()));
-            block = new Block(statements, expression.lambdaBody().getStart());
+            block = new Block(statements, expression.lambdaBody().getStart(), -1);
         } else {
             block = lambdaGenerator.convert(expression.lambdaBody().block(), true);
         }

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

@@ -409,8 +409,9 @@ public class SyntaxTreeGenerator {
       }
     }
 
+    boolean isFunctonalInterfce = methods.size() == 1 && Modifier.isAbstract(methods.getFirst().modifier);
     var staticCtor = Optional.of(this.generateStaticConstructor(ctx.identifier().getText(), staticFieldInitializations, genericParams, ctx.getStart()));
-    return new ClassOrInterface(modifiers, name, fields, Optional.empty(), staticCtor, methods, new ArrayList<>(), genericParams, superClass, true, methods.size() == 1 ? true : false, extendedInterfaces, permittedSubtypes, ctx.getStart(), fileName);
+    return new ClassOrInterface(modifiers, name, fields, Optional.empty(), staticCtor, methods, new ArrayList<>(), genericParams, superClass, true, isFunctonalInterfce, extendedInterfaces, permittedSubtypes, ctx.getStart(), fileName);
   }
 
   private GenericDeclarationList createEmptyGenericDeclarationList(Token classNameIdentifier) {

src/main/java/de/dhbwstuttgart/syntaxtree/statement/Block.java

@@ -14,6 +14,11 @@ public class Block extends Statement {
         this.statements = statements;
     }
 
+    public Block(List<Statement> statements, Token offset, int variance) {
+        super(TypePlaceholder.fresh(offset, variance, true), offset);
+        this.statements = statements;
+    }
+    
     public List<Statement> statements = new ArrayList<>();
 
     public List<Statement> getStatements() {

src/main/java/de/dhbwstuttgart/syntaxtree/visual/OutputGenerator.java

@@ -188,8 +188,10 @@ public class OutputGenerator implements ASTVisitor {
 
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        lambdaExpression.params.accept(this);
+    	out.append("(");
+    	lambdaExpression.params.accept(this);
         out.append(" -> ");
+        out.append("(");
         lambdaExpression.methodBody.accept(this);
     }
 

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

@@ -29,6 +29,7 @@ import org.objectweb.asm.Opcodes;
 
 import java.lang.classfile.Opcode;
 import java.lang.reflect.AccessFlag;
+import java.lang.reflect.Modifier;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -630,7 +631,7 @@ public class ASTToTargetAST {
                 mParams,
                 classType,
                 method.name(),
-                false, false, method.isPrivate()
+                method.isStatic(), false, method.isPrivate()
         );
         if (method.signature().returnType() != null) {
             caseBody = new TargetReturn(caseBody);

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

@@ -476,7 +476,7 @@ public class StatementToTargetExpression implements ASTVisitor {
                     .map(this::extractAllPatterns)
                     .flatMap(List::stream).toList();
             case FormalParameter param -> List.of(new TypeVariants(param.getType(), converter.findAllVariants(param.getType())));
-            default -> List.of();
+            case null, default -> List.of();
         };
     }
 

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

@@ -875,8 +875,8 @@ public class TYPEStmt implements StatementVisitor {
         if (caseExpressionType == null) {
             for (var child : switchStmt.getBlocks()) {
                 for (var label : child.getLabels()) {
-                    if (label.getPattern() == null) {
-                        constraintsSet.addUndConstraint(new Pair(new RefType(new JavaClassName("java.lang.Object"), new NullToken()), switchStmt.getSwitch().getType(), PairOperator.SMALLERDOT, loc(label.getOffset())));
+                    if (label.getPattern() == null && switchStmt.getSwitch().getType() instanceof TypePlaceholder) {
+                        constraintsSet.addUndConstraint(new Pair(new RefType(new JavaClassName("java.lang.Object"), new NullToken()), switchStmt.getSwitch().getType(), PairOperator.EQUALSDOT, loc(label.getOffset())));
                     }
                     if (label.getPattern() instanceof RecordPattern) {
                         RecordPattern recordPattern = (RecordPattern) label.getPattern();

src/main/java/de/dhbwstuttgart/typeinference/unify/distributeVariance.java

@@ -39,6 +39,7 @@ public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
 		List<UnifyType> param = new ArrayList<>(funnty.getTypeParams().get().length);
 		param.addAll(Arrays.asList(funnty.getTypeParams().get()));
 		UnifyType resultType = param.remove(param.size()-1);
+		ht = (ht == 0)? 1 : 0; //bei ht = 0 wird ht auf die Standardwerte für Functionstypes gesetzt 
 		int htInverse = inverseVariance(ht);
 		param = param.stream()
 				     .map(x -> x.accept(this, htInverse))

src/test/java/TestComplete.java

@@ -1,6 +1,8 @@
 
 import de.dhbwstuttgart.bytecode.CodeGenException;
 import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.exceptions.CompilerException;
+import de.dhbwstuttgart.exceptions.ParserError;
 import de.dhbwstuttgart.exceptions.WarningsException;
 import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Logger.LogLevel;
@@ -255,6 +257,7 @@ public class TestComplete {
     @Test
     //@Disabled("This is too complex")
     public void matrixTest() throws Exception {
+    	//ConsoleInterface.logLevel = LogLevel.DEBUG;
         var classFiles = generateClassFiles(createClassLoader(), "Matrix.jav");
         var matrix = classFiles.get("Matrix");
 
@@ -1081,9 +1084,9 @@ public class TestComplete {
         assertEquals(40.0, m.invoke(instance, d, 0));
     }
 
+    @Disabled("Waiting for #407, skipping for now")
     @Test
     public void testPatternMatchingInterface() throws Exception {
-        ConsoleInterface.logLevel = LogLevel.INFO;
         var classFiles = generateClassFiles(createClassLoader(), false, "Matcher.jav", "PatternMatchingInterface.jav");
         var Intf = classFiles.get("Interface");
         var clazz = classFiles.get("PatternMatchingInterface");
@@ -1228,6 +1231,10 @@ public class TestComplete {
         assertEquals('C', clazz.getDeclaredMethod("m2").invoke(instance));
         assertEquals(10L, clazz.getDeclaredMethod("m3").invoke(instance));
         assertEquals(10.5F, clazz.getDeclaredMethod("m4").invoke(instance));
+        assertEquals(10.5D, clazz.getDeclaredMethod("m5").invoke(instance));
+        assertEquals(0xFF, clazz.getDeclaredMethod("m6").invoke(instance));
+        assertEquals(0b101010, clazz.getDeclaredMethod("m7").invoke(instance));
+        assertEquals(010, clazz.getDeclaredMethod("m8").invoke(instance));
     }
 
     @Test
@@ -1353,6 +1360,7 @@ public class TestComplete {
     @Disabled("See #405")
     @Test
     public void testLazy() throws Exception {
+        ConsoleInterface.logLevel = LogLevel.DEBUG;
         var classFiles = generateClassFiles(createClassLoader(), false, "LazyList.jav", "Primzahlen.jav");
         var clazz = classFiles.get("Primzahlen");
         var main = clazz.getDeclaredMethod("main", List.class);
@@ -1714,4 +1722,76 @@ public class TestComplete {
             assertEquals("Class Bug423 does not implement method f from interface Bug423I", e.getMessage());
         }
     }
+
+    @Test
+    public void testBug422() throws Exception {
+        try {
+            var classFiles = generateClassFiles(createClassLoader(), "Bug422.jav");
+            fail("Shouldn't compile!");
+        } catch (CompilerException e) {
+            assertEquals("Duplicate class definition: Bug422", e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBug421() throws Exception {
+        try {
+            var classFiles = generateClassFiles(createClassLoader(), "Bug421.jav");
+            fail("Shouldn't compile!");
+        } catch (ParserError e) {
+            assertEquals("Syntax error at line 2:26 - no viable alternative at input 'm() { return 1 }'", e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBug409() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Bug409.jav");
+        var clazz = classFiles.get("Bug409");
+        var instance = clazz.getDeclaredConstructor().newInstance();
+        var m = clazz.getDeclaredMethod("m");
+        assertEquals(5, m.invoke(instance));
+    }
+
+    @Test
+    public void testBug417() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Bug417.jav");
+        var clazz = classFiles.get("Bug417");
+        var instance = clazz.getDeclaredConstructor().newInstance();
+        var name = clazz.getDeclaredMethod("name", Integer.class);
+        assertEquals("one", name.invoke(instance, 1));
+        assertEquals("many", name.invoke(instance, 2));
+    }
+
+    @Test
+    public void testBug411() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Bug411.jav");
+        var clazz = classFiles.get("Bug411");
+    }
+
+    @Test
+    public void testBug412() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Bug412.jav");
+        var clazz = classFiles.get("Bug412");
+        var instance = clazz.getDeclaredConstructor().newInstance();
+        var m = clazz.getDeclaredMethod("m", Integer.class);
+        assertEquals(10, m.invoke(instance, 1));
+        assertEquals(20, m.invoke(instance, 2));
+    }
+
+    @Test
+    public void testBug416() throws Exception {
+        var classFiles = generateClassFiles(createClassLoader(), "Bug416.jav");
+        var clazz = classFiles.get("Bug416");
+        var L = classFiles.get("L");
+        var Cons = classFiles.get("Cons");
+        var Nil = classFiles.get("Nil");
+
+        var consCtor = Cons.getDeclaredConstructor(Object.class, L);
+        var nilCtor = Nil.getDeclaredConstructor();
+
+        var list = consCtor.newInstance(1, consCtor.newInstance(2, consCtor.newInstance(3, nilCtor.newInstance())));
+
+        var len = clazz.getDeclaredMethod("len", L);
+        assertEquals(3, len.invoke(null, list));
+    }
 }

src/test/java/targetast/TestCodegen.java

@@ -202,9 +202,20 @@ public class TestCodegen {
     @Test
     public void testFor() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("For"));
-        targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "forLoop", List.of(), TargetType.Integer, new TargetBlock(List.of(new TargetVarDecl(TargetType.Integer, "sum", new TargetLiteral.IntLiteral(0)), new TargetFor(List.of(new TargetVarDecl(TargetType.Integer, "i", new TargetLiteral.IntLiteral(0))), new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(10)), List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(1)))), new TargetBlock(List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"), new TargetLocalVar(TargetType.Integer, "i")))))), new TargetReturn(new TargetLocalVar(TargetType.Integer, "sum")))));
+        targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "forLoop", List.of(), TargetType.Integer,
+                new TargetBlock(List.of(new TargetVarDecl(TargetType.Integer, "sum", new TargetLiteral.IntLiteral(0)),
+                        new TargetFor(List.of(new TargetVarDecl(TargetType.Integer, "i", new TargetLiteral.IntLiteral(0))),
+                                new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"),
+                                        new TargetLiteral.IntLiteral(10)), List.of(new TargetAssign(TargetType.Integer,
+                                new TargetLocalVar(TargetType.Integer, "i"),
+                                new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(1)))),
+                                new TargetBlock(List.of(
+                                        new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"),
+                                                new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"),
+                                                        new TargetLocalVar(TargetType.Integer, "i")))))),
+                        new TargetReturn(new TargetLocalVar(TargetType.Integer, "sum")))));
         var clazz = generateClass(targetClass, createClassLoader());
-        assertEquals(clazz.getDeclaredMethod("forLoop").invoke(null), 45);
+        assertEquals(45, clazz.getDeclaredMethod("forLoop").invoke(null));
     }
 
     @Test