many changes

- make deobfuscator logs more readable
- show all test results using 'mvn test'
- inlining static fields now also inlines default field type value

Author: EpicPlayerA10

deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/helper/AsmHelper.java

@@ -123,6 +123,25 @@ public static AbstractInsnNode toConstantInsn(Object value) {
     throw new IllegalArgumentException("Not a constant");
   }
 
+  /**
+   * Get default value for the given type (https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.12.5)
+   *
+   * @param type The type
+   * @return Default value for the type
+   */
+  public static Object getDefaultTypeValue(Type type) {
+    return switch (type.getSort()) {
+      case Type.BOOLEAN -> false;
+      case Type.CHAR -> '\u0000';
+      case Type.BYTE, Type.SHORT, Type.INT -> 0;
+      case Type.LONG -> 0L;
+      case Type.FLOAT -> 0.0f;
+      case Type.DOUBLE -> 0.0d;
+      case Type.ARRAY, Type.OBJECT -> null;
+      default -> throw new IllegalArgumentException("Unsupported type: " + type);
+    };
+  }
+
   public static Type getTypeFromPrimitiveCast(MethodInsnNode insn) {
     if (insn.getOpcode() != INVOKEVIRTUAL) throw new IllegalArgumentException("Instruction is not an INVOKEVIRTUAL");
 

deobfuscator-api/src/main/java/uwu/narumi/deobfuscator/api/transformer/Transformer.java

@@ -2,6 +2,7 @@
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.ThreadContext;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnmodifiableView;
@@ -23,6 +24,9 @@
 public abstract class Transformer extends AsmHelper implements Opcodes {
   protected static final Logger LOGGER = LogManager.getLogger();
 
+  // ThreadLocal to track transformer nesting depth for log indentation
+  private static final ThreadLocal<Integer> NESTING_DEPTH = ThreadLocal.withInitial(() -> 0);
+
   private Context context = null;
   private ClassWrapper scope = null;
 
@@ -33,6 +37,38 @@ public abstract class Transformer extends AsmHelper implements Opcodes {
   // Config
   protected boolean rerunOnChange = false;
 
+  /**
+   * Increases the nesting depth and updates ThreadContext for automatic log indentation
+   */
+  private static void increaseDepth() {
+    int newDepth = NESTING_DEPTH.get() + 1;
+    NESTING_DEPTH.set(newDepth);
+    updateIndentContext(newDepth);
+  }
+
+  /**
+   * Decreases the nesting depth and updates ThreadContext for automatic log indentation
+   */
+  private static void decreaseDepth() {
+    int depth = NESTING_DEPTH.get();
+    if (depth > 0) {
+      int newDepth = depth - 1;
+      NESTING_DEPTH.set(newDepth);
+      updateIndentContext(newDepth);
+    }
+  }
+
+  /**
+   * Updates ThreadContext with the indentation string (2 spaces per level)
+   */
+  private static void updateIndentContext(int depth) {
+    if (depth > 0) {
+      ThreadContext.put("indent", "  ".repeat(depth));
+    } else {
+      ThreadContext.remove("indent");
+    }
+  }
+
   /**
    * Should the transformer rerun if it changed something
    */
@@ -109,14 +145,14 @@ private void init(Context context, ClassWrapper scope) {
    * @return Changes count
    */
   public static int transform(Supplier<@Nullable Transformer> transformerSupplier, @Nullable ClassWrapper scope, Context context) {
-    return transform(transformerSupplier, scope, context, false);
+    return transform(transformerSupplier, scope, context, 0);
   }
 
   private static int transform(
       Supplier<@Nullable Transformer> transformerSupplier,
       @Nullable ClassWrapper scope,
       Context context,
-      boolean reran
+      int rerunsCount
   ) {
     Transformer transformer = transformerSupplier.get();
     if (transformer == null) {
@@ -131,39 +167,46 @@ private static int transform(
     // Initialize transformer
     transformer.init(context, scope);
 
-    LOGGER.info("-------------------------------------");
-    LOGGER.info("Running {} transformer", transformer.name());
+    LOGGER.info("▶ {} started", transformer.name());
     long start = System.currentTimeMillis();
 
-    // Run the transformer!
+    // Increase nesting depth for automatic log indentation
+    increaseDepth();
+
     try {
-      transformer.transform();
-    } catch (TransformerException e) {
-      LOGGER.error("! {}: {}", transformer.name(), e.getMessage());
-      return 0;
-    } catch (Exception e) {
-      LOGGER.error("Error occurred when transforming {}", transformer.name(), e);
-      if (!context.getOptions().continueOnError()) {
-        throw new RuntimeException(e);
+      // Run the transformer!
+      try {
+        transformer.transform();
+      } catch (TransformerException e) {
+        LOGGER.error("! {}: {}", transformer.name(), e.getMessage());
+        return 0;
+      } catch (Exception e) {
+        LOGGER.error("Error occurred when transforming {}", transformer.name(), e);
+        if (!context.getOptions().continueOnError()) {
+          throw new RuntimeException(e);
+        }
+        return 0;
+      } finally {
+        // Mark transformer that it was already used
+        transformer.hasRan = true;
       }
-      return 0;
+
+      LOGGER.info("Made {} changes", transformer.getChangesCount());
     } finally {
-      // Mark transformer that it was already used
-      transformer.hasRan = true;
+      // Decrease nesting depth when leaving this transformer
+      decreaseDepth();
+      LOGGER.info("◀ {} ended in {} ms", transformer.name(), (System.currentTimeMillis() - start));
     }
 
     int changesCount = transformer.getChangesCount();
 
-    LOGGER.info("Made {} changes", changesCount);
-    LOGGER.info("Ended {} transformer in {} ms", transformer.name(), (System.currentTimeMillis() - start));
-
     if (transformer.isChanged() && transformer.shouldRerunOnChange()) {
-      LOGGER.info("\uD83D\uDD04 Changes detected. Rerunning {} transformer", transformer.name());
-      changesCount += Transformer.transform(transformerSupplier, scope, context, true);
+      LOGGER.info("\uD83D\uDD04 Changes detected. Rerunning {} transformer (rerun {})", transformer.name(), rerunsCount + 1);
+      changesCount += Transformer.transform(transformerSupplier, scope, context, ++rerunsCount);
     }
 
     // Bytecode verification
-    if (context.getOptions().verifyBytecode() && !reran && transformer.isChanged()) {
+    if (context.getOptions().verifyBytecode() && rerunsCount == 0 && transformer.isChanged()) {
       // Verify if bytecode is valid
       try {
         verifyBytecode(scope, context);

deobfuscator-impl/pom.xml

@@ -24,10 +24,24 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>3.4.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>me.fabriciorby</groupId>
+                        <artifactId>maven-surefire-junit5-tree-reporter</artifactId>
+                        <version>1.5.1</version>
+                    </dependency>
+                </dependencies>
 
                 <configuration>
                     <junitArtifactName>org.junit.jupiter:junit-jupiter</junitArtifactName>
                     <trimStackTrace>false</trimStackTrace>
+                    <reportFormat>plain</reportFormat>
+                    <consoleOutputReporter>
+                        <disable>true</disable>
+                    </consoleOutputReporter>
+                    <statelessTestsetInfoReporter
+                            implementation="org.apache.maven.plugin.surefire.extensions.junit5.JUnit5StatelessTestsetInfoTreeReporter">
+                    </statelessTestsetInfoReporter>
                 </configuration>
             </plugin>
         </plugins>

deobfuscator-impl/src/main/resources/log4j2.xml

@@ -2,10 +2,10 @@
 <Configuration status="WARN">
     <Appenders>
         <Console name="Console" target="SYSTEM_OUT">
-            <PatternLayout pattern="%highlight{[%d{HH:mm:ss}] [%level]: %msg%n%throwable}{INFO=normal}" disableAnsi="false"/>
+            <PatternLayout pattern="%highlight{[%d{HH:mm:ss}] [%level]: %X{indent}%msg%n%throwable}{INFO=normal}" disableAnsi="false"/>
         </Console>
         <File name="File" fileName="deobfuscator.log" immediateFlush="false" append="false">
-            <PatternLayout pattern="[%d{HH:mm:ss}] [%level]: %msg%n%throwable"/>
+            <PatternLayout pattern="[%d{HH:mm:ss}] [%level]: %X{indent}%msg%n%throwable"/>
         </File>
     </Appenders>
     <Loggers>

deobfuscator-impl/src/test/java/uwu/narumi/deobfuscator/TestDeobfuscation.java

@@ -37,7 +37,6 @@ protected void registerAll() {
         .transformers(StringBuilderTransformer::new)
         .inputClass(InputType.JAVA_CODE, "TestStringBuilderTransformer.class")
         .register();
-    // TODO: Uninitialized static fields should replace with 0?
     test("Inline static fields")
         .transformers(InlineStaticFieldTransformer::new, UselessPopCleanTransformer::new)
         .inputClass(InputType.JAVA_CODE, "TestInlineStaticFields.class")

deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/pool/InlineStaticFieldTransformer.java

@@ -1,5 +1,6 @@
 package uwu.narumi.deobfuscator.core.other.impl.pool;
 
+import org.objectweb.asm.Type;
 import org.objectweb.asm.tree.AbstractInsnNode;
 import org.objectweb.asm.tree.FieldInsnNode;
 import org.objectweb.asm.tree.analysis.BasicValue;
@@ -24,7 +25,7 @@ public class InlineStaticFieldTransformer extends Transformer {
   @Override
   protected void transform() throws Exception {
     Set<FieldRef> notConstantFields = new HashSet<>();
-    Map<FieldRef, AbstractInsnNode> staticConstantFields = new HashMap<>();
+    Map<FieldRef, AbstractInsnNode> staticConstantFields = new HashMap<>(); // field -> constant insn
 
     // Find all static constant fields
     scopedClasses().forEach(classWrapper -> findClInit(classWrapper.classNode()).ifPresent(clInit -> {
@@ -61,16 +62,23 @@ protected void transform() throws Exception {
           });
     }));
 
-    // Also account for FieldNode#value
+    // Also account for FieldNode#value and default field type value
     scopedClasses().forEach(classWrapper -> {
       classWrapper.classNode().fields.forEach(fieldNode -> {
-        if (fieldNode.value != null) {
-          FieldRef fieldRef = FieldRef.of(classWrapper.classNode(), fieldNode);
+        FieldRef fieldRef = FieldRef.of(classWrapper.classNode(), fieldNode);
 
-          if (!staticConstantFields.containsKey(fieldRef)) {
-            // Add it to static constant fields
-            staticConstantFields.put(fieldRef, AsmHelper.toConstantInsn(fieldNode.value));
-          }
+        if (notConstantFields.contains(fieldRef)) return;
+
+        Object value = fieldNode.value;
+        // If value is null, get the default value for type
+        if (value == null) {
+          Type fieldType = Type.getType(fieldNode.desc);
+          value = AsmHelper.getDefaultTypeValue(fieldType);
+        }
+
+        if (!staticConstantFields.containsKey(fieldRef)) {
+          // Add it to static constant fields
+          staticConstantFields.put(fieldRef, AsmHelper.toConstantInsn(value));
         }
       });
     });

testData/results/java/TestInlineStaticFields.dec

@@ -1,13 +1,12 @@
 public class TestInlineStaticFields {
     public static int TEST1 = 123;
-    public static int TEST4;
     public static String TEST5;
 
     public static void test() {
         System.out.println(TEST1);
         System.out.println("placki");
         System.out.println(true);
-        System.out.println(TEST4);
+        System.out.println(0);
         System.out.println(TEST5.toUpperCase());
     }