analyze(mainFile) {
            val diagnostics = targetDeclaration.getDiagnostics(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS)

            val actualText = buildString {
                if (diagnostics.isNotEmpty()) {
                    for (diagnostic in diagnostics) {
                        append(diagnostic.factoryName).append(": ")
                        diagnostic.textRanges.joinTo(this)

    ASSERT_TRUE(tensorflow::errors::IsInternal(
        StatusScopedDiagnosticHandler(&context).Combine(err)));
  }

  // Verify diagnostic reported are append to passed in error.
  {
    auto function = [&]() {
      emitError(loc) << "Diagnostic message reported";
      emitError(loc) << "Second diagnostic message reported";
      return tensorflow::errors::Internal("Passed in error");
    };
    StatusScopedDiagnosticHandler ssdh(&context);

    override val defaultMessage: String
        get() = withValidityAssertion {
            val diagnostic = firDiagnostic as KtDiagnostic

            val firDiagnosticRenderer = RootDiagnosticRendererFactory(diagnostic)
            return firDiagnosticRenderer.render(diagnostic)
        }

    override val textRanges: Collection<TextRange>
        get() = withValidityAssertion { firDiagnostic.textRanges }

                target.closeEntry()
            }
            target.close()
            return result.toByteArray()
        } else {
            for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
                println(diagnostic.source)
                println(diagnostic.getMessage(null))
            }
            throw new RuntimeException('Failure compiling test fixture')
        }
    }

    }

    protected fun collectImports(diagnosticList: HLDiagnosticList): Collection<String> = buildSet {
        addAll(defaultImports)
        for (diagnostic in diagnosticList.diagnostics) {
            diagnostic.original.psiType.collectClassNamesTo(this)
            diagnostic.parameters.forEach { diagnosticParameter ->
                addAll(collectImportsForDiagnosticParameter(diagnosticParameter))
            }
        }
    }

package analysisflags

import (
	"fmt"
	"net/url"

	"golang.org/x/tools/go/analysis"
)

// ResolveURL resolves the URL field for a Diagnostic from an Analyzer
// and returns the URL. See Diagnostic.URL for details.
func ResolveURL(a *analysis.Analyzer, d analysis.Diagnostic) (string, error) {
	if d.URL == "" && d.Category == "" && a.URL == "" {
		return "", nil // do nothing
	}
	raw := d.URL

        }
        List<Diagnostic<? extends JavaFileObject>> diagnostics = ds.getDiagnostics().stream()
            .filter(d -> d.getKind() == Diagnostic.Kind.ERROR)
            .collect(Collectors.toList());
        if (!diagnostics.isEmpty()) {
            throwCompilationError(diagnostics);
        }
    }

    private static void throwCompilationError(List<Diagnostic<? extends JavaFileObject>> diagnostics) {

/**
 * Call that contains errors.
 */
public class KaErrorCallInfo(
    candidateCalls: List<KaCall>,
    diagnostic: KaDiagnostic,
    override val token: KaLifetimeToken,
) : KaCallInfo() {
    public val candidateCalls: List<KaCall> by validityAsserted(candidateCalls)
    public val diagnostic: KaDiagnostic by validityAsserted(diagnostic)
}

public val KaCallInfo.calls: List<KaCall>
    get() = when (this) {

  // Returns Status corresponding to the diagnostics reported. This consumes
  // the diagnostics reported and returns a Status of type Unknown. It is
  // required to consume the error status, if there is one, before destroying
  // the object.
  Status ConsumeStatus();

  // Returns the combination of the passed in status and consumed diagnostics.
  // This consumes the diagnostics reported and either appends the diagnostics

    candidate: KaCall,
    isInBestCandidates: Boolean,
    diagnostic: KaDiagnostic,
) : KaCallCandidateInfo(candidate, isInBestCandidates) {
    /**
     * The reason the [candidate] was not applicable for the call (e.g., argument type mismatch, or no value for parameter).
     */
    public val diagnostic: KaDiagnostic by validityAsserted(diagnostic)