}
      return new SuppressingSuppressor(addSuppressed);
    }

    private final Method addSuppressed;

    private SuppressingSuppressor(Method addSuppressed) {
      this.addSuppressed = addSuppressed;
    }

    @Override
    public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
      // ensure no exceptions from addSuppressed
      if (thrown == suppressed) {
        return;

          }
        }
        return plan.handleSuccess()
      } catch (e: IOException) {
        if (firstException == null) {
          firstException = e
        } else {
          firstException.addSuppressed(e)
        }
        if (!routePlanner.hasNext()) {
          throw firstException
        }
      }
    }
  }

        openKotlinCompilationUnitsByRoot.clear()
        if (errors.isNotEmpty()) {
            throw Exception("Sources repository did not close cleanly").apply {
                errors.forEach(this::addSuppressed)
            }
        }
    }

    /**
     * @return the source file and it's source root
     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =

        if (allAddresses.isEmpty()) {
          val first = allExceptions.firstOrNull() ?: UnknownHostException("No results for $hostname")

          allExceptions.drop(1).forEach {
            first.addSuppressed(it)
          }

          throw first
        }

        allAddresses
      }
  }

        if (throwable != null) {
          if (throwable !is IOException) throw throwable
          if (firstException == null) {
            firstException = throwable
          } else {
            firstException.addSuppressed(throwable)
          }
        }

        val nextPlan = connectResult.nextPlan
        if (nextPlan != null) {
          // Try this plan's successor before deferred plans because it won the race!

      throw failure
    }

    val unknownHostException = UnknownHostException(hostname)
    unknownHostException.initCause(failure)

    for (i in 1 until failures.size) {
      unknownHostException.addSuppressed(failures[i])
    }

    throw unknownHostException
  }

  private fun getCacheOnlyResponse(request: Request): Response? {
    if (client.cache != null) {
      try {

                try {
                    th.send(new Smb2CloseRequest(th.getConfig(), cr.getFileId()));
                }
                catch ( SmbException e2 ) {
                    e.addSuppressed(e2);
                }
            }

            Smb2QueryDirectoryResponse qr = query.getResponse();

            if ( qr != null && qr.isReceived() && qr.getStatus() == NtStatus.NT_STATUS_NO_SUCH_FILE ) {

        )
      }
      return response
    } catch (e: IOException) {
      if (sendRequestException != null) {
        sendRequestException.addSuppressed(e)
        throw sendRequestException
      }
      throw e
    }
  }

  private fun shouldIgnoreAndWaitForRealResponse(
    code: Int,
    exchange: Exchange,
  ): Boolean =
    when {

                    exceptions.add(e);
                }
            }
            try {
                return doRead(request);
            } catch (IOException e) {
                exceptions.forEach(e::addSuppressed);
                throw e;
            }
        } else {
            return doRead(request);
        }
    }

    private Path doLocateExistingPom(Path project) {
        if (project == null) {

        catch ( IOException ioe ) {
            log.warn("sendrecv failed", ioe);
            try {
                disconnect(true);
            }
            catch ( IOException ioe2 ) {
                ioe.addSuppressed(ioe2);
                log.info("disconnect failed", ioe2);
            }
            throw ioe;
        }
        catch ( InterruptedException ie ) {
            throw new TransportException(ie);
        }