}

    if (closeExchange) {
      exchange?.detachWithViolence()
    }

    interceptorScopedExchange = null
  }

  fun retryAfterFailure(): Boolean {
    return exchange?.hasFailure == true &&
      exchangeFinder!!.routePlanner.hasNext(exchange?.connection)
  }

  /**
   * Returns a string that describes this call. Doesn't include a full URL as that might contain
   * sensitive information.

        DependencySubstitutionApplicator.SubstitutionResult substitutionResult = dependencySubstitutionApplicator.apply(dependencyState.getDependency());
        if (substitutionResult.hasFailure()) {
            dependencyState.failure = new ModuleVersionResolveException(dependencyState.getRequested(), substitutionResult.getFailure());
            return dependencyState;
        }

  // Returns true iff the current test has a non-fatal failure.
  static bool HasNonfatalFailure();

  // Returns true iff the current test has a (either fatal or
  // non-fatal) failure.
  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }

  // Logs a property for the current test, test case, or for the entire
  // invocation of the test program when used outside of the context of a

class FakeQuantRewrite : public OpRewritePattern<FakeQuantOp> {
 public:
  using OpRewritePattern<FakeQuantOp>::OpRewritePattern;

  FakeQuantRewrite(MLIRContext *ctx, bool *hadFailure)
      : OpRewritePattern<FakeQuantOp>(ctx), hadFailure(hadFailure) {}

  LogicalResult matchAndRewrite(FakeQuantOp op,
                                PatternRewriter &rewriter) const override {

import org.gradle.internal.instrumentation.model.ImplementationInfo;
import org.gradle.internal.instrumentation.processor.codegen.GradleLazyType;
import org.gradle.internal.instrumentation.processor.codegen.HasFailures;
import org.gradle.internal.instrumentation.processor.codegen.RequestGroupingInstrumentationClassSourceGenerator;
import org.gradle.internal.instrumentation.processor.codegen.TypeUtils;

    }

    private static void validateRequests(List<CallInterceptionRequest> requests, Consumer<? super HasFailures.FailureInfo> onFailure) {
        for (CallInterceptionRequest request : requests) {
            if (SignatureUtils.hasInjectVisitorContext(request.getInterceptedCallable())) {
                onFailure.accept(new HasFailures.FailureInfo(request, "Parameter with @InjectVisitorContext annotation is not supported for Groovy interception."));

            void buildType(String className, TypeSpec.Builder builder);
            Collection<CallInterceptionRequest> getCoveredRequests();
        }

        class CodeFailures implements GenerationResult, HasFailures {
            private final List<FailureInfo> failures;

            public CodeFailures(List<FailureInfo> failures) {
                this.failures = failures;
            }

            @Override

            String message = "No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories." +
                (hasFailures() ? " " + failureMessage() : "");

            String[] resolutions = {
                "Learn more about toolchain auto-detection at " + Documentation.userManual("toolchains", "sec:auto_detection").getUrl() + ".",

            void write(OutputStream outputStream);
        }

        class NoResourceToGenerate implements GenerationResult {
        }

        class ResourceFailures implements GenerationResult, HasFailures {
            private final List<FailureInfo> failures;

            public ResourceFailures(List<FailureInfo> failures) {
                this.failures = failures;
            }

            @Override

            }
        }

        final BulkResponse response = bulkRequestBuilder.execute().actionGet(settings.getBulkTimeout());
        final SuggestWriterResult result = new SuggestWriterResult();
        if (response.hasFailures()) {
            for (final BulkItemResponse bulkItemResponses : response.getItems()) {
                if (bulkItemResponses.isFailed()) {