Handle Kotlin's statements and their frequent sugar (#472)

* [Kotlin] Add support for downTo, fix non-KExprent instances in other "do" statements

# Conflicts:
#	plugins/kotlin/src/main/java/org/vineflower/kotlin/stat/KDoStatement.java
#	plugins/kotlin/testData/results/pkg/TestForRange.dec
#	plugins/kotlin/testData/results/pkg/TestFunVarargs.dec
#	plugins/kotlin/testData/results/pkg/TestNonInlineLambda.dec

* [Kotlin] Improve for-loop resugaring

* [Kotlin] Fix objects, companion object members, and whitespace

* [Kotlin] Update tests

* Subclass statement types instead of a custom one in its entirety

* Add tests for compiling a `when` statement to switch blocks

* Modify exprent replacement logic

* Add accessibility to some private members

* `switch` statement decompilation to `when`

* Update test results and statement stuff after merge

* Fix jmpWrapper calls, add `if` statement support

* Update tests

* Fix some instances of odd spacing in `when` blocks

I should look into this more and see why it's seemingly quite inconsistent

* Add test cases to `TestWhen`

* Even more `when` tests

* Fix additional `when` issues

* Update test case

* Reconfigure Kotlin variable references for more versatility in the many ways they're used

* Add replace stats pass

This existed prior to the rebase, but something went amiss and I'm not quite sure what

* Be more lenient on allowed loops

This also fixes a potential issue where `repeat` would be generated despite counting down

Author: sschr15

plugins/kotlin/src/main/java/org/vineflower/kotlin/KotlinPlugin.java

@@ -79,6 +79,7 @@ private static Pass makePass() {
       .addPass("RedundantReturns", ctx -> ExitHelper.removeRedundantReturns(ctx.getRoot()))
       .addPass("IdentifySecondary", ctx -> SecondaryFunctionsHelper.identifySecondaryFunctions(ctx.getRoot(), ctx.getVarProc(), FORCE_TERNARY_SIMPLIFY))
       .addPass("SetVarDefinitions", WrappedPass.of(ctx -> ctx.getVarProc().setVarDefinitions(ctx.getRoot())))
+      .addPass("ReplaceStats", new ReplaceStatsPass())
       .addPass("ReplaceExprs", new ReplaceExprentsPass())
       // TODO: preference for this pass
       .addPass("ResugarMethods", new ResugarKotlinMethodsPass())

plugins/kotlin/src/main/java/org/vineflower/kotlin/expr/KSwitchHeadExprent.java

@@ -0,0 +1,22 @@
+package org.vineflower.kotlin.expr;
+
+import org.jetbrains.java.decompiler.modules.decompiler.exps.Exprent;
+import org.jetbrains.java.decompiler.modules.decompiler.exps.SwitchHeadExprent;
+import org.jetbrains.java.decompiler.util.TextBuffer;
+
+public class KSwitchHeadExprent extends SwitchHeadExprent implements KExprent {
+  public KSwitchHeadExprent(SwitchHeadExprent ex) {
+    super(ex.getValue(), ex.bytecode);
+    setCaseValues(ex.getCaseValues());
+  }
+
+  @Override
+  public TextBuffer toJava(int indent) {
+    TextBuffer buf = new TextBuffer();
+
+    buf.append(getValue().toJava(indent)).enclose("when (", ")");
+    buf.addStartBytecodeMapping(bytecode);
+
+    return buf;
+  }
+}

plugins/kotlin/src/main/java/org/vineflower/kotlin/expr/KVarExprent.java

@@ -12,7 +12,14 @@
 import java.util.BitSet;
 
 public class KVarExprent extends VarExprent implements KExprent {
-  private boolean isExceptionType;
+  public enum DeclarationType {
+    DEFINITION,
+    USAGE,
+    FOR_LOOP_VARIABLE,
+    EXCEPTION_TYPE,
+  }
+
+  private DeclarationType declarationType;
 
   public KVarExprent(int index, VarType varType, VarProcessor processor, BitSet bytecode) {
     super(index, varType, processor, bytecode);
@@ -27,6 +34,11 @@ public KVarExprent(VarExprent ex) {
 //    this.setLVT(ex.getLVT());
     this.setEffectivelyFinal(ex.isEffectivelyFinal());
     this.setDefinition(ex.isDefinition());
+    if (ex instanceof KVarExprent kVarExprent) {
+      declarationType = kVarExprent.declarationType;
+    } else {
+      declarationType = ex.isDefinition() ? DeclarationType.DEFINITION : DeclarationType.USAGE;
+    }
   }
 
   @Override
@@ -46,8 +58,7 @@ public TextBuffer toJava(int indent) {
 
     buffer.addBytecodeMapping(bytecode);
 
-    boolean definition = isDefinition();
-    if (definition && !isExceptionType) {
+    if (declarationType == DeclarationType.DEFINITION) {
       VarProcessor processor = getProcessor();
 
       boolean isFinal = isEffectivelyFinal() ||
@@ -58,16 +69,16 @@ public TextBuffer toJava(int indent) {
 
     buffer.append(getName());
 
-    if (definition || isExceptionType) {
+    if (declarationType == DeclarationType.DEFINITION || declarationType == DeclarationType.EXCEPTION_TYPE) {
       buffer.append(": ");
       buffer.append(KTypes.getKotlinType(getDefinitionVarType()));
     }
 
     return buffer;
   }
 
-  public void setExceptionType(boolean isExceptionType) {
-    this.isExceptionType = isExceptionType;
+  public void setDeclarationType(DeclarationType declarationType) {
+    this.declarationType = declarationType;
   }
 
   @Override

plugins/kotlin/src/main/java/org/vineflower/kotlin/pass/ReplaceExprentsPass.java

@@ -8,6 +8,7 @@
 import org.vineflower.kotlin.expr.KVarExprent;
 import org.vineflower.kotlin.util.KUtils;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class ReplaceExprentsPass implements Pass {
@@ -23,22 +24,52 @@ private static boolean replace(Statement stat) {
       res |= replace(st);
     }
 
-    List<Exprent> exprs = List.of();
-    if (stat instanceof BasicBlockStatement) {
-      exprs = stat.getExprents();
-    } else if (stat instanceof IfStatement) {
-      exprs = ((IfStatement)stat).getHeadexprentList();
+    List<List<Exprent>> exprLists = new ArrayList<>();
+    exprLists.add(stat.getExprents());
+    exprLists.add(stat.getVarDefinitions());
+
+    if (stat instanceof CatchAllStatement || stat instanceof CatchStatement) {
+      // Special handling for catch declarations
+      List<VarExprent> vars = stat instanceof CatchAllStatement ? ((CatchAllStatement)stat).getVars() : ((CatchStatement)stat).getVars();
+      for (int i = 0; i < vars.size(); i++) {
+        VarExprent expr = vars.get(i);
+        KVarExprent map = new KVarExprent(expr);
+        map.setDeclarationType(KVarExprent.DeclarationType.EXCEPTION_TYPE);
+        vars.set(i, map);
+      }
+
+      if (stat instanceof CatchAllStatement catchAll && catchAll.getMonitor() != null) {
+        catchAll.setMonitor(new KVarExprent(catchAll.getMonitor()));
+      } else if (stat instanceof CatchStatement catchStat) {
+        exprLists.add(catchStat.getResources());
+      }
+    } else if (stat instanceof DoStatement doStat) {
+      exprLists.add(doStat.getInitExprentList());
+      exprLists.add(doStat.getConditionExprentList());
+      exprLists.add(doStat.getIncExprentList());
+    } else if (stat instanceof IfStatement ifStat) {
+      exprLists.add(ifStat.getHeadexprentList());
+    } else if (stat instanceof SwitchStatement switchStat) {
+      exprLists.addAll(switchStat.getCaseValues());
+      exprLists.add(switchStat.getCaseGuards());
+      exprLists.add(switchStat.getHeadexprentList());
+    } else if (stat instanceof SynchronizedStatement syncStat) {
+      exprLists.add(syncStat.getHeadexprentList());
     } else if (stat instanceof CatchAllStatement || stat instanceof CatchStatement) {
       List<VarExprent> vars = stat instanceof CatchAllStatement ? ((CatchAllStatement)stat).getVars() : ((CatchStatement)stat).getVars();
       for (int i = 0; i < vars.size(); i++) {
         VarExprent expr = vars.get(i);
         KVarExprent map = new KVarExprent(expr);
-        map.setExceptionType(true);
+        map.setDeclarationType(KVarExprent.DeclarationType.EXCEPTION_TYPE);
         vars.set(i, map);
       }
     }
 
-    if (!exprs.isEmpty()) {
+    for (List<Exprent> exprs : exprLists) {
+      if (exprs == null) {
+        continue;
+      }
+
       for(int i = 0; i < exprs.size(); i++){
         Exprent expr = exprs.get(i);
         Exprent map = KUtils.replaceExprent(expr);
@@ -50,18 +81,11 @@ private static boolean replace(Statement stat) {
       }
 
       for (Exprent ex : exprs) {
-        res |= replace(ex);
-      }
-    }
-
-    for (int i = 0; i < stat.getVarDefinitions().size(); i++) {
-      Exprent expr = stat.getVarDefinitions().get(i);
-
-      Exprent map = KUtils.replaceExprent(expr);
-      if (map != null) {
-        stat.getVarDefinitions().set(i, map);
+        if (ex == null) {
+          continue;
+        }
 
-        res = true;
+        res |= replace(ex);
       }
     }
 

plugins/kotlin/src/main/java/org/vineflower/kotlin/pass/ReplaceStatsPass.java

@@ -0,0 +1,37 @@
+package org.vineflower.kotlin.pass;
+
+import org.jetbrains.java.decompiler.api.plugin.pass.Pass;
+import org.jetbrains.java.decompiler.api.plugin.pass.PassContext;
+import org.jetbrains.java.decompiler.modules.decompiler.stats.*;
+import org.vineflower.kotlin.stat.*;
+
+public class ReplaceStatsPass implements Pass {
+  @Override
+  public boolean run(PassContext ctx) {
+    return replace(ctx.getRoot());
+  }
+  
+  private static boolean replace(Statement stat) {
+    boolean res = false;
+
+    for (int i = 0; i < stat.getStats().size(); i++) {
+      Statement st = stat.getStats().get(i);
+      res |= replace(st);
+      if (st instanceof SequenceStatement) {
+        st.replaceWith(new KSequenceStatement((SequenceStatement) st));
+        res = true;
+      } else if (st instanceof DoStatement) {
+        st.replaceWith(new KDoStatement((DoStatement) st));
+        res = true;
+      } else if (st instanceof SwitchStatement) {
+        st.replaceWith(new KSwitchStatement((SwitchStatement) st));
+        res = true;
+      } else if (st instanceof IfStatement) {
+        st.replaceWith(new KIfStatement((IfStatement) st));
+        res = true;
+      }
+    }
+
+    return res;
+  }
+}