Cases that this doesn't handle:

• Anonymous classes. However, while anonymous classes can have constructors, those constructors are synthetic and do not appear in the decompiled source. More importantly, annotations do not appear to be copied from the superclass (even if marked as @Inherited), so the ProGuard issue cannot happen here. Also, being anonymous, they cannot be referenced from outside the class, so the "bad class file" issue shouldn't be possible for them.

• Named classes declared inside methods. This could actually be an issue, since these can have constructors. They also can have a reference to the enclosing class if the method isn't static. These should be detectable via the EnclosingMethod attribute, but actually figuring out what parameters are synthetic doesn't seem possible to me (at least not without looking at the code for the method as well). This is the code responsible for adding those parameters.

  void foo(String s) {
      class Test {
          @Override
          public String toString() { return s; }
      }
      System.out.println(new Test());
  }

  The Minecraft codebase does not appear to use any of these, so investing time into implementing it doesn't seem necessary right now. Also, as with before, these can't be referenced from outside, so no bad class file issues can happen.

• A really weird edge case: this generates an anonymous class that has 2 synthetic parameters, one for the Something.this and one for ExtremelyStupidEdgeCase.this. Fun.

  public class ExtremelyStupidEdgeCase {
      public static class Something {
          public class Inner {
              @Override
              public String toString() {
                  return "inner of " + Something.this.toString();
              }
          }
      }
      public void method() {
          Something something = new Something();
          Something.Inner inner = something.new Inner() {
              @Override
              public String toString() {
                  return "annon, of " + ExtremelyStupidEdgeCase.this.toString() + " and " + super.toString();
              }
          };
          System.out.println(inner);
      }
  }

  Interestingly, when compiling with javac -parameters, the second synthetic parameter is not marked as such.

  Since this is an anonymous class, we don't have to deal with it for this purpose. I don't think a named class could be created like this.