ClassFormatError when extending Kotlin interface with interior enum class

[SekoiaTree]

Title is not 100% accurate, but I'm not sure exactly what is broken with the interface.

Reproduction steps

The following class launches a ClassFormatError whenever loaded:

import org.intellij.markdown.parser.LookaheadText
import org.intellij.markdown.parser.constraints.MarkdownConstraints
import org.intellij.markdown.parser.markerblocks.MarkerBlock

object Main {
  def main(args: Array[String]): Unit = {
    println(new MyClass)
  }
}

class MyClass extends org.intellij.markdown.parser.markerblocks.MarkerBlock {
  override def acceptAction(closingAction: MarkerBlock.ClosingAction): Boolean = ???
  override def allowsSubBlocks(): Boolean = ???
  override def getBlockConstraints: MarkdownConstraints = ???
  override def getNextInterestingOffset(position: LookaheadText#Position): Int = ???
  override def isInterestingOffset(position: LookaheadText#Position): Boolean = ???
  override def processToken(position: LookaheadText#Position, markdownConstraints: MarkdownConstraints): MarkerBlock.ProcessingResult = ???
}

The class is https://github.com/JetBrains/markdown/blob/master/src/commonMain/kotlin/org/intellij/markdown/parser/markerblocks/MarkerBlock.kt, and the following build.sbt imports it:

ThisBuild / version := "0.1.0-SNAPSHOT"

ThisBuild / scalaVersion := "2.13.16"
//ThisBuild / scalaVersion := "3.7.1"

lazy val root = (project in file("."))
  .settings(
    name := "untitled358",
    libraryDependencies ++= Seq(
      "org.jetbrains" % "markdown-jvm" % "0.7.3"
    )
  )

Here is this reproduction project as a zip: InnerEnumBug.zip

And the error:

Exception in thread "sbt-bg-threads-1" java.lang.ClassFormatError: Illegal class modifiers in class MyClass: 0x4419
	at java.base/java.lang.ClassLoader.defineClass1(Native Method)
	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1027)
	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:150)
	at java.base/java.net.URLClassLoader.defineClass(URLClassLoader.java:524)
	at java.base/java.net.URLClassLoader$1.run(URLClassLoader.java:427)
	at java.base/java.net.URLClassLoader$1.run(URLClassLoader.java:421)
	at java.base/java.security.AccessController.doPrivileged(AccessController.java:714)
	at java.base/java.net.URLClassLoader.findClass(URLClassLoader.java:420)
	at sbt.internal.ManagedClassLoader.findClass(ManagedClassLoader.java:103)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:593)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:526)
	at Main$.main(Main.scala:8)
	at Main.main(Main.scala)
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
	at sbt.Run.invokeMain(Run.scala:135)
	at sbt.Run.execute$1(Run.scala:85)
	at sbt.Run.$anonfun$runWithLoader$5(Run.scala:112)
	at sbt.Run$.executeSuccess(Run.scala:178)
	at sbt.Run.runWithLoader(Run.scala:112)
	at sbt.Defaults$.$anonfun$bgRunTask$6(Defaults.scala:2091)
	at sbt.Defaults$.$anonfun$termWrapper$2(Defaults.scala:2030)
	at scala.runtime.java8.JFunction0$mcV$sp.apply(JFunction0$mcV$sp.java:23)
	at scala.util.Try$.apply(Try.scala:213)
	at sbt.internal.BackgroundThreadPool$BackgroundRunnable.run(DefaultBackgroundJobService.scala:378)
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1144)
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:642)
	at java.base/java.lang.Thread.run(Thread.java:1583)

Java can implement the interface fine, so it's some kind of interaction between Kotlin and Scala here. Best theory I have is that acceptAction(action: ClosingAction): Boolean breaks it somehow, because ClosingAction is a bit of a strange enum, with anonymous class values.

[unkarjedy]

Note, this works with Scala 3.3 and 3.7

[unkarjedy]

We noticed this issue while working on Scala3Doc support in IntelliJ.
We want to reuse some Kotlin library that leads to this issue.

[som-snytt]

Just started looking.

InnerClasses:
  public static final abstract #18= #17 of #6; // ClosingAction

MarkerBlock referring to ClosingAction

InnerClasses:
  public static final #39= #49 of #2;     // ClosingAction=class org/intellij/markdown/parser/markerblocks/MarkerBlock$ClosingAction of class org/intellij/markdown/parser/markerblocks/MarkerBlock

ClosingAction referring to itself, same for an element

InnerClasses:
  public static final #100= #2 of #99;    // ClosingAction=class org/intellij/markdown/parser/markerblocks/MarkerBlock$ClosingAction of class org/intellij/markdown/parser/markerblocks/MarkerBlock

Java is more obviously correct

NestHost: class J
PermittedSubclasses:
  J$E$1
InnerClasses:
  public static abstract #51= #1 of #47;  // E=class J$E of class J

Dotty drops final, which naively seems more correct than Kotlin.

InnerClasses:
  public static abstract #15= #14 of #6;  // ClosingAction=class org/intellij/markdown/parser/markerblocks/MarkerBlock$ClosingAction of class org/intellij/markdown/parser/markerblocks/MarkerBlock

(Scala 2 knows not to combine abstract final when constructing flags, but final is set on the symbol early, before reading the class file. Recall that scala/scala#10424) (That is, when the enclosing class is read, enterOwnInnerClasses using those flags; dotty is similar but possible it creates the A$B symbol when forcing the package with empty flags.)