Quiltflower is a fork of Fernflower adding additional features for use with the Quilt toolchain.

Hi, Your product has performed very well among the available options, but there are some problems when using it, which I request you to check and fix. like the: INFO: Decompiling class com/adventnet/client/components/table/pdf/PropertySheetRenderer WARN: Method getDollarReqParams (Ljava/lang/String;Lcom/adventnet/client/view/web/ViewContext;)Ljava/lang/String; in class com/adventnet/client/components/table/template/FillTable couldn't be written. java.lang.RuntimeException: invalid constant type: Ljava/lang/Object; at org.jetbrains.java.decompiler.modules.decompiler.exps.ConstExprent.toJava(ConstExprent.java:347) at org.jetbrains.java.decompiler.modules.decompiler.exps.AssignmentExprent.toJava(AssignmentExprent.java:146) at org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor.listToJava(ExprProcessor.java:858) at org.jetbrains.java.decompiler.modules.decompiler.stats.BasicBlockStatement.toJava(BasicBlockStatement.java:65) at org.jetbrains.java.decompiler.modules.decompiler.stats.IfStatement.toJava(IfStatement.java:199) at org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor.jmpWrapper(ExprProcessor.java:796) at org.jetbrains.java.decompiler.modules.decompiler.stats.SequenceStatement.toJava(SequenceStatement.java:111) at org.jetbrains.java.decompiler.modules.decompiler.ExprProcessor.jmpWrapper(ExprProcessor.java:796) at org.jetbrains.java.decompiler.modules.decompiler.stats.CatchStatement.toJava(CatchStatement.java:178) at org.jetbrains.java.decompiler.modules.decompiler.stats.RootStatement.toJava(RootStatement.java:37) at org.jetbrains.java.decompiler.main.ClassWriter.methodToJava(ClassWriter.java:1084) at org.jetbrains.java.decompiler.main.ClassWriter.classToJava(ClassWriter.java:334) at org.jetbrains.java.decompiler.main.ClassesProcessor.writeClass(ClassesProcessor.java:480) at org.jetbrains.java.decompiler.main.Fernflower.getClassContent(Fernflower.java:156) at org.jetbrains.java.decompiler.struct.ContextUnit.lambda$save$0(ContextUnit.java:179) at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source) at java.util.concurrent.FutureTask.run(Unknown Source) at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source) at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source) at java.lang.Thread.run(Unknown Source)

With https://github.com/openjdk/jdk/commit/cfee4512f7048e9cf440078e9eb87d37c7ebcdd9 extra String::valueOf calls are inserted for objects passed to makeConcatWithConstants. Quiltflower should remove these for better readability.

Adds java 19 preview tests with record patterns. Most of these decompile fairly straightforwardly.

The decompiled code is invalid as the proxy methods aren't shown, but still called. TestRecordPattern4.test2 is also wrong at the end, reusing var21 where it should not (should be the value of c, runs correctly).

Previously, it would not detect classes like a$a or aaa$aaa which caused some issues. I am not sure if a cache would be needed since I am using regex now. As an additional thought, the regex could be a cli paramater since names could be obfuscated differently.

Fixes point 3 & possibly 2 of #112

Here are some of the stacktraces Cannot read field "nested" because "parent_class" is null Three in a row

I haven't managed to reproduce any of these I was using Quiltflower 1.4.1 with fabric-loom 0.7 with this

buildscript {
    repositories {
        mavenCentral()
        maven {
            name 'Fabric'
            url 'https://maven.fabricmc.net/'
        }
        mavenLocal()
    }
    dependencies {
        classpath (group: 'fabric-loom', name: 'fabric-loom.gradle.plugin', version: '0.7-SNAPSHOT') { // From Fabric
            exclude group: 'net.fabricmc', module: 'fabric-fernflower'
        }
        classpath 'org.quiltmc:quiltflower:1.4.1+local' // From mavenLocal
    }
}

Env

IntelliJ IDEA 2022.3 RC (Ultimate Edition)
Build #IU-223.7571.123, built on November 23, 2022
macOS 12.5
net.earthcomputer.quiltflowerintellij (1.0.4)
Kotlin: 223-1.7.20-release-201-IJ7571.123

Getting the following error

java.lang.Throwable: Failed to download quiltflower 1.8.1 from https://maven.quiltmc.org/repository/snapshot/org/quiltmc/quiltflower/1.8.1-SNAPSHOT/quiltflower-1.8.1.jar: 404
	at com.intellij.openapi.diagnostic.Logger.error(Logger.java:202)
	at net.earthcomputer.quiltflowerintellij.QuiltflowerState$downloadQuiltflower$1$future$1$1.invoke(QuiltflowerState.kt:162)
	at net.earthcomputer.quiltflowerintellij.QuiltflowerState$downloadQuiltflower$1$future$1$1.invoke(QuiltflowerState.kt:122
)

The bug

After updating LQF to Quiltflower 1.9.0 (and fixing a compilation error due to a rename), the LQF tests are failing with FileSystemExceptions on Windows.

This only happens with the decompilation path using Loom's current decompilation API (Loom 0.11+), so the relevant code can be found in LQF's impl.modern.QuiltflowerDecompiler

More specifically, when Loom tries to apply line mappings to the jar, it fails due to the compiled Minecraft jar "being in use by another process". This didn't happen in the previous commit where all tests succeeded.

    Caused by: java.io.UncheckedIOException: Failed to remap line numbers
    	at net.fabricmc.loom.task.GenerateSourcesTask$DecompileAction.doDecompile(GenerateSourcesTask.java:281)
    	at net.fabricmc.loom.task.GenerateSourcesTask$DecompileAction.execute(GenerateSourcesTask.java:224)
    	... 22 more
    Caused by: java.nio.file.FileSystemException: D:\a\LoomQuiltflower\LoomQuiltflower\build\tmp\test\work\.gradle-test-kit\caches\fabric-loom\1.16.5\net.fabricmc.yarn.1_16_5.1.16.5+build.10-v2\minecraft-merged-named.jar: The process cannot access the file because it is being used by another process
    	at net.fabricmc.loom.task.GenerateSourcesTask$DecompileAction.doDecompile(GenerateSourcesTask.java:278)
    	... 23 more

Note that since this has happened before in some specific setups, I try to force-close any file systems pointing to the input jar, but that doesn't seem to help with this crash.

Replacing deprecations?

Avoiding using my own bytecode provider and the deprecated Fernflower constructor via reflection still didn't solve the issue: https://github.com/Juuxel/LoomQuiltflower/commit/85aa26b578e13785b4988b5d2d04187a02c6d1c1

https://github.com/QuiltMC/quiltflower/blob/2124e6e0062c1ce266981c4c5aa47e40acef08a8/src/org/jetbrains/java/decompiler/main/Fernflower.java#L31-L36

Even though the code should now run the upper constructor that doesn't use any of my code for reading the inputs, the tests still fail. This leads me to believe it's a QF regression.

This PR uses SSAU to resolve differences in variable indices between finally duplicated blocks. Also marks semaphore variables more clearly in the code.

Source

  public void test(Object a) {
    switch (10000) {
      default: {
        Object vvv26 = null;
        while (vvv26 == null) {
        }
      }
      case -79:
        long vvv36 = -5851592879203823622L;
      case 320:
        if (a != null) {
          return;
        }
    }
    System.out.println("Hi");
  }

Result:

   public void test(Object a) {
     long var4 = switch(10000) {
        case 320 -> {
        }
        default -> {
           Object vvv26 = null;

           while(vvv26 == null) {
           }
        }
        case -79 -> -5851592879203823622L;
     };
     if (a == null) {
        System.out.println("Hi");
     }
  }

This PR fixes the longstanding bug where too many loops would get created due to an issue with postdominance not discovering all possible nodes to extend a new general statement over. It also adds new tracing over DomHelper to better trace it's logic and find problems. This PR also eliminates entirely the "baby shark" issue.

Future work before this PR can be undrafted:

• Find out why adding the loop body to the header's postdom set causes strange issues
• Add comments explaining what everything is doing
• Test on nested loops with switches. There are some weird regressions there (not in the test suite yet)
• Remove debug code left in the classes

Resolves: #151 Tests: attempted to test, IntelliJ kept skipping the test for some reason. Output: WARN: Invalid signature: SourceFile. Not sure what's up with that, but in any case I did my best with the code and hopefully it works. It's literally one line and while I saw something more fancy being done with the other String.valueOf() remover that seemed to depend on index and hopefully would be unnecessary for removing from parameters.

@SuperCoder7979 let me know if this was what you wanted! Sorry, bit new to this 😅

Method references referring to super methods seem to decompile weirdly. An easy-to-find example of this can be found in the gradle class org.gradle.api.internal.artifacts.DefaultArtifactRepositoryContainer. The source code in question can be found here: https://github.com/gradle/gradle/blob/3200a204ba96f503f1171b3584258a53ecd91bd2/subprojects/dependency-management/src/main/java/org/gradle/api/internal/artifacts/DefaultArtifactRepositoryContainer.java#L38

This initializer looks like this:

private final Action<ArtifactRepository> addLastAction = DefaultArtifactRepositoryContainer.super::add;

But is decompiled by quiltflower (I believe I have the most recent version; I am using the intellij plugin) as this:

private final Action<ArtifactRepository> addLastAction = x$0 -> access$101(this, x$0);

(access$101 is the name of the synthetic lambda method generated for the method reference)

This also may allow for easier work on combination flags, like perhaps a --no-removal which would apply --no-remove-bridge --no-remove-synthetic --no-remove-getclass --no-remove-empty-try-catch --no-remove-imports or something like that

QF version: 1.9.0

Some examples from Adorn code:

   // $QF: Could not properly define all variable types!
   // Please report this to the Quiltflower issue tracker, at https://github.com/QuiltMC/quiltflower/issues with a copy of the class file (if you have the rights to distribute it!)
   private final void addIngredients(ItemGroupBuildContext $this$addIngredients) {
      if ($this$addIngredients instanceof ItemGroupModifyContext var10000) {
         Item var10001 = Items.STICK;
         Intrinsics.checkNotNullExpressionValue(Items.STICK, "STICK");
         var10000.addAfter((ItemConvertible)var10001, CollectionsKt.listOf(AdornItems.INSTANCE.getSTONE_ROD()));
      } else {
         $this$addIngredients.add((ItemConvertible)AdornItems.INSTANCE.getSTONE_ROD());
      }
   }

   // $QF: Could not properly define all variable types!
   // Please report this to the Quiltflower issue tracker, at https://github.com/QuiltMC/quiltflower/issues with a copy of the class file (if you have the rights to distribute it!)
   private static final void addItems$lambda_1/* $QF was: addItems$lambda-1*/(Function1 $configurator, final FabricItemGroupEntries entries) {
      Intrinsics.checkNotNullParameter($configurator, "$configurator");
      <undefinedtype> context = new ItemGroupModifyContext() {
         @Override
         public void add(@NotNull ItemConvertible item) {
            Intrinsics.checkNotNullParameter(item, "item");
            entries.add(item);
         }

         @Override
         public void addAfter(@NotNull ItemConvertible after, @NotNull List<? extends ItemConvertible> items) {
            Intrinsics.checkNotNullParameter(after, "after");
            Intrinsics.checkNotNullParameter(items, "items");
            FabricItemGroupEntries var10000 = entries;
            Collection $this$toTypedArray$iv = items;
            int $i$f$toTypedArray = 0;
            Object[] var10002 = $this$toTypedArray$iv.toArray(new ItemConvertible[0]);
            Intrinsics.checkNotNull(var10002, "null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.toTypedArray>");
            ItemConvertible[] var3 = (ItemConvertible[])var10002;
            var10000.addAfter(after, Arrays.copyOf((ItemConvertible[])var3, var3.length));
         }
      };
      $configurator.invoke(context);
   }

Full output: https://gist.github.com/Juuxel/8abad176be25114fe4518bbf1c467be0

Here are the class files: adorn-classes.zip

QF version: 1.9.0

Extract from decompiled code:

      int var3 = 1;           // an int variable...
      int var4 = 0;
      var1 = 1;
      var2 = 1;
      var4 = 26;
      if (var3 || 1 == 0) {   // ...used in an OR expression?

Relevant javap output:

        19: iload_3
        20: ifne          28
        23: ldc           #7                  // int 1
        25: ifne          41

The class file was created using a custom compiler for Advent of Code 2016's day 12 challenge and its "assembunny" language.

(It's the puzzle input compiled to JVM bytecode - if executed, the class will compute and print the answer to that day's part 2)

Hello all,

Recently, I was developing a project based on QuiltFlower, but because of some requirements, I had to use Java 8 to do it, so I was forced to downgrade to version 1.8.1 of QuiiltFlower. Will you provide a version that can run on Java 8 in the future?

Kind Regards