Adding a field to an anonymous class in a method produces invalid Java code

import org.eclipse.emf.common.util.AbstractTreeIterator

class Test {
  def test() {
    new AbstractTreeIterator(new Object()) {
      val thing = newLinkedHashSet
      override protected getChildren(Object object) {
        throw new UnsupportedOperationException("TODO: auto-generated method stub")
      }
    }
  }
}

The 2.26.0.v20220228-0901 compiler produced invalid Java for this by defining a constructor with a final ? object argument:

  public AbstractTreeIterator test() {
    abstract class __Test_1 extends AbstractTreeIterator {
      __Test_1(final ? object) {
        super(object);
      }
      
      LinkedHashSet<Object> thing;
    }
    
    Object _object = new Object();
    return new __Test_1(_object) {
      {
        thing = CollectionLiterals.<Object>newLinkedHashSet();
      }
      @Override
      protected Iterator getChildren(final Object object) {
        throw new UnsupportedOperationException("TODO: auto-generated method stub");
      }
    };
  }

It's also a bit odd that it's creating a local named class inside the method only to leave all of the initialisation and override logic in an anonymous subclass of that class it has just defined anyway. Maybe this is related, but I can live with it if it's not.

I'm sure that I've defined a field inside an anonymous class elsewhere, so I can only assume that there's something specific about AbstractTreeIterator that breaks it. new AbstractTreeIterator<Object>(new Object()) { ... } doesn't avoid the issue.

It's easy enough to define the field as a local variable outside the anonymous class, but that's a bit naff.

Start with the supplied Test reproducer and compare its generated Java with the expected valid output, focusing on the anonymous class created inside test(). Trace the compiler path that handles the AbstractTreeIterator constructor and the field initialization. Done means the reproducer compiles to valid Java while preserving the anonymous-class field and override behavior.