wasm gc: fix case when non-split block breaks from split block

Author: konsoletyper

core/src/main/java/org/teavm/ast/Expr.java

@@ -63,6 +63,26 @@ public static Expr binary(BinaryOperation op, OperationType type, Expr first, Ex
         return expr;
     }
 
+    public static Expr and(Expr first, Expr second) {
+        return binary(BinaryOperation.AND, null, first, second);
+    }
+
+    public static Expr or(Expr first, Expr second) {
+        return binary(BinaryOperation.OR, null, first, second);
+    }
+
+    public static Expr addInt(Expr first, Expr second) {
+        return binary(BinaryOperation.ADD, OperationType.INT, first, second);
+    }
+
+    public static Expr divInt(Expr first, Expr second) {
+        return binary(BinaryOperation.DIVIDE, OperationType.INT, first, second);
+    }
+
+    public static Expr less(Expr first, Expr second) {
+        return binary(BinaryOperation.LESS, OperationType.INT, first, second);
+    }
+
     public static Expr binary(BinaryOperation op, OperationType type, Expr first, Expr second, TextLocation loc) {
         Expr expr = binary(op, type, first, second);
         expr.setLocation(loc);
@@ -146,7 +166,7 @@ public static InvocationExpr invokeSpecial(MethodReference method, Expr target,
         return expr;
     }
 
-    public static InvocationExpr invokeStatic(MethodReference method, Expr[] arguments) {
+    public static InvocationExpr invokeStatic(MethodReference method, Expr... arguments) {
         InvocationExpr expr = new InvocationExpr();
         expr.setMethod(method);
         expr.setType(InvocationType.STATIC);

core/src/main/java/org/teavm/ast/Statement.java

@@ -15,8 +15,11 @@
  */
 package org.teavm.ast;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Function;
 
 public abstract class Statement {
     public abstract void acceptVisitor(StatementVisitor visitor);
@@ -26,26 +29,61 @@ public static Statement empty() {
     }
 
     public static AssignmentStatement assign(Expr left, Expr right) {
-        AssignmentStatement stmt = new AssignmentStatement();
+        var stmt = new AssignmentStatement();
         stmt.setLeftValue(left);
         stmt.setRightValue(right);
         return stmt;
     }
 
+    public static AssignmentStatement statementExpr(Expr expr) {
+        var stmt = new AssignmentStatement();
+        stmt.setRightValue(expr);
+        return stmt;
+    }
+
+    public static ReturnStatement exitFunction() {
+        return exitFunction(null);
+    }
+
     public static ReturnStatement exitFunction(Expr result) {
-        ReturnStatement stmt = new ReturnStatement();
+        var stmt = new ReturnStatement();
         stmt.setResult(result);
         return stmt;
     }
 
+    public static SequentialStatement sequence(Statement... statements) {
+        var seq = new SequentialStatement();
+        seq.getSequence().addAll(Arrays.asList(statements));
+        return seq;
+    }
+
+    public static BlockStatement block(Function<BlockStatement, Collection<Statement>> body) {
+        var statement = new BlockStatement();
+        statement.getBody().addAll(body.apply(statement));
+        return statement;
+    }
+
+    public static BreakStatement exitBlock(IdentifiedStatement identifiedStatement) {
+        var statement = new BreakStatement();
+        statement.setTarget(identifiedStatement);
+        return statement;
+    }
+
+    public static WhileStatement loopWhile(Expr condition, Function<WhileStatement, Collection<Statement>> body) {
+        var statement = new WhileStatement();
+        statement.setCondition(condition);
+        statement.getBody().addAll(body.apply(statement));
+        return statement;
+    }
+
     public static ThrowStatement raiseException(Expr exception) {
-        ThrowStatement stmt = new ThrowStatement();
+        var stmt = new ThrowStatement();
         stmt.setException(exception);
         return stmt;
     }
 
     public static Statement cond(Expr predicate, List<Statement> consequent, List<Statement> alternative) {
-        ConditionalStatement statement = new ConditionalStatement();
+        var statement = new ConditionalStatement();
         statement.setCondition(predicate);
         statement.getConsequent().addAll(consequent);
         statement.getAlternative().addAll(alternative);
@@ -57,8 +95,61 @@ public static Statement cond(Expr predicate, List<Statement> consequent) {
     }
 
     public static InitClassStatement initClass(String className) {
-        InitClassStatement stmt = new InitClassStatement();
+        var stmt = new InitClassStatement();
         stmt.setClassName(className);
         return stmt;
     }
+
+    public static SwitchStatement switchStatement(Expr condition, List<Statement> defaultClause,
+            SwitchClause... clauses) {
+        var statement = new SwitchStatement();
+        statement.setValue(condition);
+        statement.getDefaultClause().addAll(defaultClause);
+        statement.getClauses().addAll(List.of(clauses));
+        return statement;
+    }
+
+    public static SwitchClause switchClause(int[] conditions, Statement... statements) {
+        var clause = new SwitchClause();
+        clause.setConditions(conditions);
+        clause.getBody().addAll(List.of(statements));
+        return clause;
+    }
+
+    public static SwitchClause switchClause(int condition, Statement... statements) {
+        return switchClause(new int[] { condition }, statements);
+    }
+
+    public static TryCatchStatementBuilder doTry(Statement... statements) {
+        return new TryCatchStatementBuilder(statements);
+    }
+
+    public static class TryCatchStatementBuilder {
+        Statement[] protectedBody;
+
+        TryCatchStatementBuilder(Statement[] protectedBody) {
+            this.protectedBody = protectedBody;
+        }
+
+        public TryCatchStatementBuilder2 doCatch(String type, Integer variable) {
+            var result = new TryCatchStatement();
+            result.getProtectedBody().addAll(Arrays.asList(protectedBody));
+            result.setExceptionType(type);
+            result.setExceptionVariable(variable);
+            return new TryCatchStatementBuilder2(result);
+        }
+    }
+
+    public static class TryCatchStatementBuilder2 {
+        TryCatchStatement statement;
+
+        TryCatchStatementBuilder2(TryCatchStatement statement) {
+            this.statement = statement;
+        }
+
+        public TryCatchStatement with(Statement... statements) {
+            statement.getHandler().addAll(Arrays.asList(statements));
+            return statement;
+        }
+    }
 }

core/src/main/java/org/teavm/backend/wasm/generate/gc/methods/WasmGCMethodGenerator.java

@@ -289,6 +289,13 @@ private void generateMethodBody(MethodHolder method, WasmFunction function) {
     private void generateCustomMethodBody(WasmGCCustomGenerator customGenerator, MethodReference method,
             WasmFunction function) {
         customGenerator.apply(method, function, customGeneratorContext);
+        var isSuspend = asyncMethods.contains(method);
+        if (isSuspend) {
+            if (coroutineTransformation == null) {
+                coroutineTransformation = new CoroutineTransformation(functionTypes, this, classInfoProvider);
+            }
+            coroutineTransformation.transform(function);
+        }
     }
 
     private void generateRegularMethodBody(MethodHolder method, WasmFunction function) {