Start work on IR and IR tests

Author: jaskarth

src/org/jetbrains/java/decompiler/modules/decompiler/StatEdge.java

@@ -92,6 +92,41 @@ public int getType() {
     return type;
   }
 
+  public String makeEdgeTypeString() {
+    switch (type) {
+      case TYPE_REGULAR:
+        return "Regular";
+      case TYPE_EXCEPTION:
+        return "Except";
+      case TYPE_BREAK:
+        return destination.type == Statement.StatementType.DUMMY_EXIT ? "BreakExit" : "Break";
+      case TYPE_CONTINUE:
+        return "Continue";
+      case TYPE_FINALLYEXIT:
+        return "FinExit";
+      default:
+        throw new RuntimeException("Invalid edge type");
+    }
+  }
+
+  public static int fromEdgeTypeString(String s) {
+    switch (s) {
+      case "Regular":
+        return TYPE_REGULAR;
+      case "Except":
+        return TYPE_EXCEPTION;
+      case "Break":
+      case "BreakExit":
+        return TYPE_BREAK;
+      case "Continue":
+        return TYPE_CONTINUE;
+      case "FinExit":
+        return TYPE_FINALLYEXIT;
+      default:
+        throw new RuntimeException("Invalid edge type");
+    }
+  }
+
   public void setType(int type) {
     this.type = type;
   }

src/org/jetbrains/java/decompiler/modules/decompiler/exps/ArrayExprent.java

@@ -3,6 +3,7 @@
 
 import org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.CheckTypesResult;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.struct.gen.VarType;
 import org.jetbrains.java.decompiler.util.InterpreterUtil;
 import org.jetbrains.java.decompiler.util.TextBuffer;
@@ -51,6 +52,21 @@ public VarType getInferredExprType(VarType upperBound) {
     }
   }
 
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    sb.append(hardType.toTapestryString());
+    sb.append(" ");
+    array.toTapestry(sb);
+    index.toTapestry(sb);
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    VarType hardType = VarType.fromTapestryString(arg.getNextString());
+    Exprent array = arg.getNextExprent();
+    Exprent index = arg.getNextExprent();
+    return new ArrayExprent(array, index, hardType, null);
+  }
+
   @Override
   public int getExprentUse() {
     return array.getExprentUse() & index.getExprentUse() & Exprent.MULTIPLE_USES;

src/org/jetbrains/java/decompiler/modules/decompiler/exps/AssignmentExprent.java

@@ -13,6 +13,7 @@
 import org.jetbrains.java.decompiler.modules.decompiler.sforms.VarMapHolder;
 import org.jetbrains.java.decompiler.modules.decompiler.stats.Statement;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.CheckTypesResult;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair;
 import org.jetbrains.java.decompiler.struct.StructField;
 import org.jetbrains.java.decompiler.struct.StructMethod;
@@ -258,6 +259,31 @@ private void optimizeCastForAssign() {
     }
   }
 
+
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    if (condType != null) {
+      sb.append(condType.name());
+    }
+
+    sb.append(" ");
+    left.toTapestry(sb);
+    sb.append(" ");
+    right.toTapestry(sb);
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    FunctionExprent.FunctionType condType = null;
+    if (arg.peekNext() == ExprParser.Type.STRING) {
+      condType = FunctionExprent.FunctionType.valueOf(arg.getNextString());
+    }
+
+    Exprent left = arg.getNextExprent();
+    Exprent right = arg.getNextExprent();
+
+    return new AssignmentExprent(left, right, condType, null);
+  }
+
   @Override
   public void replaceExprent(Exprent oldExpr, Exprent newExpr) {
     if (oldExpr == left) {

src/org/jetbrains/java/decompiler/modules/decompiler/exps/ConstExprent.java

@@ -5,6 +5,7 @@
 import org.jetbrains.java.decompiler.main.DecompilerContext;
 import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences;
 import org.jetbrains.java.decompiler.struct.gen.CodeType;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.struct.gen.FieldDescriptor;
 import org.jetbrains.java.decompiler.struct.gen.TypeFamily;
 import org.jetbrains.java.decompiler.struct.gen.VarType;
@@ -603,6 +604,35 @@ public VarType getConstType() {
     return constType;
   }
 
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    sb.append(constType.toTapestryString()).append(" ").append(value);
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    VarType type = VarType.fromTapestryString(arg.getNextString());
+    String rawVal = arg.getNextString();
+    Object val = rawVal;
+
+    if (type.typeFamily == TypeFamily.INTEGER) {
+      val = Integer.parseInt(rawVal);
+    } else if (type == VarType.VARTYPE_LONG) {
+      val = Long.parseLong(rawVal);
+    } else if (type == VarType.VARTYPE_FLOAT) {
+      val = Float.parseFloat(rawVal);
+    } else if (type == VarType.VARTYPE_DOUBLE) {
+      val = Double.parseDouble(rawVal);
+    } else if (type == VarType.VARTYPE_BOOLEAN) {
+      val = Boolean.parseBoolean(rawVal);
+    } else if (type == VarType.VARTYPE_CHAR) {
+      val = rawVal.charAt(0);
+    } else if (type == VarType.VARTYPE_NULL) {
+      val = null;
+    }
+
+    return new ConstExprent(type, val, null);
+  }
+
   public void setConstType(VarType constType) {
     this.constType = constType;
   }

src/org/jetbrains/java/decompiler/modules/decompiler/exps/ExitExprent.java

@@ -8,6 +8,7 @@
 import org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor;
 import org.jetbrains.java.decompiler.modules.decompiler.ValidationHelper;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.CheckTypesResult;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.struct.attr.StructExceptionsAttribute;
 import org.jetbrains.java.decompiler.struct.attr.StructGeneralAttribute;
 import org.jetbrains.java.decompiler.struct.gen.CodeType;
@@ -122,6 +123,30 @@ else if ("java/lang/Exception".equals(exClassName)) {
     }
   }
 
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    sb.append(this.exitType.name());
+    sb.append(" ");
+    sb.append(this.retType.toTapestryString());
+
+    if (this.value != null) {
+      sb.append(" ");
+      this.value.toTapestry(sb);
+    }
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    Type type = Type.valueOf(arg.getNextString());
+    VarType varType = VarType.fromTapestryString(arg.getNextString());
+
+    Exprent value = null;
+    if (arg.peekNext() == ExprParser.Type.EXPRENT) {
+      value = arg.getNextExprent();
+    }
+
+    return new ExitExprent(type, value, varType, null, null);
+  }
+
   @Override
   public void replaceExprent(Exprent oldExpr, Exprent newExpr) {
     if (oldExpr == value) {

src/org/jetbrains/java/decompiler/modules/decompiler/exps/Exprent.java

@@ -23,33 +23,45 @@
 import org.jetbrains.java.decompiler.util.TextBuffer;
 
 import java.util.*;
+import java.util.Map.Entry;
+import java.util.function.Consumer;
 
 public abstract class Exprent implements IMatchable {
   public static final int MULTIPLE_USES = 1;
   public static final int SIDE_EFFECTS_FREE = 2;
   public static final int BOTH_FLAGS = 3;
 
   public enum Type {
-    ANNOTATION,
-    ARRAY,
-    ASSERT,
-    ASSIGNMENT,
-    CONST,
-    EXIT,
-    FIELD,
-    FUNCTION,
-    IF,
-    INVOCATION,
-    MONITOR,
-    NEW,
-    PATTERN,
-    SWITCH,
-    SWITCH_HEAD,
-    VAR,
-    YIELD,
+    ANNOTATION("Anno"),
+    ARRAY("Array"),
+    ASSERT("Assert"),
+    ASSIGNMENT("Assign"),
+    CONST("Const"),
+    EXIT("Return"),
+    FIELD("Field"),
+    FUNCTION("Func"),
+    IF("If"),
+    INVOCATION("Invoke"),
+    MONITOR("Monitor"),
+    NEW("New"),
+    PATTERN("Pattern"),
+    SWITCH("SwitchExpr"),
+    SWITCH_HEAD("SwitchHead"),
+    VAR("Var"),
+    YIELD("Yield"),
 
     // Catch all for plugins
-    OTHER
+    OTHER("Other");
+
+    private final String prettyId;
+
+    Type(String prettyId) {
+      this.prettyId = prettyId;
+    }
+
+    public String getPrettyId() {
+      return prettyId;
+    }
   }
 
   protected static ThreadLocal<Map<String, VarType>> inferredLambdaTypes = ThreadLocal.withInitial(HashMap::new);
@@ -309,6 +321,22 @@ public boolean allowNewlineAfterQualifier() {
     return true;
   }
 
+  public final void toTapestry(StringBuilder sb) {
+    sb.append("[");
+    sb.append(type.prettyId);
+    StringBuilder child = new StringBuilder();
+    addToTapestry(child);
+    if (child.length() > 0) {
+      sb.append(" ");
+      sb.append(child);
+    }
+    sb.append("]");
+  }
+
+  protected void addToTapestry(StringBuilder sb) {
+
+  }
+
   // processes exprents, much like section 16.1. of the java language specifications
   // (Definite Assignment and Expressions).
   public void processSforms(SFormsConstructor sFormsConstructor, VarMapHolder varMaps, Statement stat, boolean calcLiveVars) {

src/org/jetbrains/java/decompiler/modules/decompiler/exps/FieldExprent.java

@@ -12,6 +12,7 @@
 import org.jetbrains.java.decompiler.modules.decompiler.sforms.VarMapHolder;
 import org.jetbrains.java.decompiler.modules.decompiler.stats.Statement;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.struct.StructClass;
 import org.jetbrains.java.decompiler.struct.StructField;
 import org.jetbrains.java.decompiler.struct.attr.StructLocalVariableTableAttribute;
@@ -114,6 +115,34 @@ public VarType getInferredExprType(VarType upperBound) {
     return getExprType();
   }
 
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    sb.append(name);
+    sb.append(" ");
+    sb.append(classname);
+    sb.append(" ");
+
+    sb.append(descriptor.descriptorString);
+
+    if (instance != null) {
+      sb.append(" ");
+      instance.toTapestry(sb);
+    }
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    String name = arg.getNextString();
+    String classname = arg.getNextString();
+    String descString = arg.getNextString();
+
+    Exprent value = null;
+    if (arg.peekNext() == ExprParser.Type.EXPRENT) {
+      value = arg.getNextExprent();
+    }
+
+    return new FieldExprent(name, classname, value == null, value, FieldDescriptor.parseDescriptor(descString), null);
+  }
+
   @Override
   public int getExprentUse() {
     //Revert the following line it produces messy code as follows:

src/org/jetbrains/java/decompiler/modules/decompiler/exps/FunctionExprent.java

@@ -11,6 +11,7 @@
 import org.jetbrains.java.decompiler.modules.decompiler.stats.Statement;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.CheckTypesResult;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.struct.gen.CodeType;
 import org.jetbrains.java.decompiler.struct.gen.VarType;
 import org.jetbrains.java.decompiler.struct.gen.generics.GenericType;
@@ -457,6 +458,42 @@ else if (type2.type == CodeType.BOOLEAN) {
     return result;
   }
 
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    sb.append(this.funcType.name());
+
+    if (implicitType != null) {
+      sb.append(" ");
+      sb.append(this.implicitType.toTapestryString());
+    }
+
+    List<Exprent> operands = this.getLstOperands();
+
+    for (Exprent operand : operands) {
+      sb.append(" ");
+      operand.toTapestry(sb);
+    }
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    FunctionType type = FunctionType.valueOf(arg.getNextString());
+
+    VarType implicitType = null;
+    if (arg.peekNext() == ExprParser.Type.STRING) {
+      implicitType = VarType.fromTapestryString(arg.getNextString());
+    }
+
+    List<Exprent> exprents = new ArrayList<>();
+    while (arg.peekNext() == ExprParser.Type.EXPRENT) {
+      exprents.add(arg.getNextExprent());
+    }
+
+    FunctionExprent func =  new FunctionExprent(type, exprents, null);
+    func.setImplicitType(implicitType);
+
+    return func;
+  }
+
   @Override
   public List<Exprent> getAllExprents(List<Exprent> lst) {
     lst.addAll(this.lstOperands);

src/org/jetbrains/java/decompiler/modules/decompiler/exps/IfExprent.java

@@ -4,6 +4,7 @@
 package org.jetbrains.java.decompiler.modules.decompiler.exps;
 
 import org.jetbrains.java.decompiler.modules.decompiler.exps.FunctionExprent.FunctionType;
+import org.jetbrains.java.decompiler.modules.serializer.ExprParser;
 import org.jetbrains.java.decompiler.modules.decompiler.sforms.SFormsConstructor;
 import org.jetbrains.java.decompiler.modules.decompiler.sforms.VarMapHolder;
 import org.jetbrains.java.decompiler.modules.decompiler.stats.Statement;
@@ -122,6 +123,15 @@ public IfExprent negateIf() {
     return this;
   }
 
+  @Override
+  protected void addToTapestry(StringBuilder sb) {
+    condition.toTapestry(sb);
+  }
+
+  public static Exprent fromTapestry(ExprParser.Arg arg) {
+    return new IfExprent(arg.getNextExprent(), null);
+  }
+
   public Exprent getCondition() {
     return condition;
   }