if (deleteFaults.contains(fileOrDirectory)) throw IOException("boom!")
    super.deleteRecursively(fileOrDirectory, mustExist)
  }

  override fun appendingSink(
    file: Path,
    mustExist: Boolean,
  ): Sink = FaultySink(super.appendingSink(file, mustExist), file)

  override fun sink(
    file: Path,
    mustCreate: Boolean,
  ): Sink = FaultySink(super.sink(file, mustCreate), file)

            if (declaration.matchesNameAndIsSince(classSimpleName, version)) true
            else super.visit(declaration, arg)

        override fun visit(declaration: AnnotationDeclaration, arg: Unit?): Boolean? =
            if (declaration.matchesNameAndIsSince(classSimpleName, version)) true
            else super.visit(declaration, arg)

        override fun visit(declaration: EnumDeclaration, arg: Unit?): Boolean? =

        override fun visitFunction(function: FirFunction) {
            firFunctionDeclarations.add(function)
            super.visitFunction(function)
        }

        override fun visitLoop(loop: FirLoop) {
            firLoopStatements.add(loop)
            super.visitLoop(loop)
        }

        override fun visitReturnExpression(returnExpression: FirReturnExpression) {

        // Enable ALPN.
        val names = alpnProtocolNames(protocols)
        sslParameters.applicationProtocols = names.toTypedArray()

        sslSocket.sslParameters = sslParameters
      }
    } else {
      super.configureTlsExtensions(sslSocket, hostname, protocols)
    }
  }

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    if (sslSocket is org.openjsse.javax.net.ssl.SSLSocket) {

    add(FirErrors.ABSTRACT_SUPER_CALL) { firDiagnostic ->
        AbstractSuperCallImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.ABSTRACT_SUPER_CALL_WARNING) { firDiagnostic ->
        AbstractSuperCallWarningImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.INSTANCE_ACCESS_BEFORE_SUPER_CALL) { firDiagnostic ->

        var first = true

        override fun createSocket(): Socket {
          if (first) {
            first = false
            firstConnectLatch.await()
          }
          return super.createSocket()
        }
      }

    client =
      client.newBuilder()
        .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE))
        .socketFactory(socketFactory)
        .addNetworkInterceptor(

Most of the code is actually the same.

So, we are going to focus only on the differences.

## File structure

Let's say you have a directory named `my_super_project` that contains a sub-directory called `sql_app` with a structure like this:

```
.
└── sql_app
    ├── __init__.py
    ├── crud.py
    ├── database.py
    ├── main.py
    └── schemas.py
```

- [`KT-46465`](https://youtrack.jetbrains.com/issue/KT-46465) Deprecate and make open Number.toChar()
- [`KT-49017`](https://youtrack.jetbrains.com/issue/KT-49017) Forbid usages of super or super<Some> if in fact it accesses an abstract member
- [`KT-56119`](https://youtrack.jetbrains.com/issue/KT-56119) BinaryVersion.isCompatible binary compatibility is broken

    ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS, SynchronousQueue()) {
    private val exceptions: BlockingQueue<Exception> = LinkedBlockingQueue()

    override fun execute(runnable: Runnable) {
      super.execute {
        try {
          runnable.run()
        } catch (e: Exception) {
          exceptions.add(e)
        }
      }
    }

    fun takeException(): Exception {

---

"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"