name:           "operation and empty output still matches name printer",
			expectedOutput: "pod/foo patched",
			operation:      "patched",
		},
		{
			name:          "no printer is matched on an invalid outputFormat",
			outputFormat:  "invalid",
			expectNoMatch: true,
		},
		{
			name:          "printer should not match on any other format supported by another printer",
			outputFormat:  "go-template",
			expectNoMatch: true,
		},

            type: KaIntersectionType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                printCollection(type.conjuncts, separator = " & ") {
                    typeRenderer.renderType(analysisSession, it, printer)
                }
            }
        }
    }
}

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter

public interface KaSuperTypesCallArgumentsRenderer {
    public fun renderSuperTypeArguments(
        analysisSession: KaSession,
        type: KaType,
        symbol: KaClassOrObjectSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull

public interface KaPropertyAccessorsRenderer {
    public fun renderAccessors(
        analysisSession: KaSession,
        symbol: KaPropertySymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

            is DefinitelyNotNullType -> renderDefinitelyNotNullType(unwrappedType, printer)
            is ErrorType -> renderErrorType(printer)
            is CapturedType -> renderCapturedType(unwrappedType, printer)
            is NewCapturedType -> renderCapturedType(unwrappedType, printer)
            is AbbreviatedType -> renderType(unwrappedType.abbreviation, printer)
            is SimpleType -> {

            analysisSession: KaSession,
            type: KaErrorType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            type.presentableText?.let {
                printer.append(it)
                return
            }
            printer.append("ERROR")
        }
    }

    public object AS_ERROR_WORD : KaErrorTypeRenderer {
        override fun renderType(

            declarationRenderer: KaDeclarationRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                declarationRenderer.codeStyle.getSeparatorBetweenAnnotationAndOwner(analysisSession, symbol).separated(
                    { declarationRenderer.annotationRenderer.renderAnnotations(analysisSession, symbol, printer) },
                    {

// check to be inherently fragile.
package format

import (
	"bytes"
	"fmt"
	"go/ast"
	"go/parser"
	"go/printer"
	"go/token"
	"io"
)

// Keep these in sync with cmd/gofmt/gofmt.go.
const (
	tabWidth    = 8
	printerMode = printer.UseSpaces | printer.TabIndent | printerNormalizeNumbers

	// printerNormalizeNumbers means to canonicalize number literal prefixes

type ResourcePrinterWrapper struct {
	Printer printers.ResourcePrinter
}

// NewResourcePrinterWrapper creates new ResourcePrinter object
func NewResourcePrinterWrapper(resourcePrinter printers.ResourcePrinter, err error) (Printer, error) {
	if err != nil {
		return nil, err
	}
	return &ResourcePrinterWrapper{Printer: resourcePrinter}, nil
}

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.renderer.render

public interface KaAnnotationArgumentsRenderer {
    public fun renderAnnotationArguments(
        analysisSession: KaSession,
        annotation: KaAnnotation,
        owner: KaAnnotated,
        annotationRenderer: KaAnnotationRenderer,
        printer: PrettyPrinter,
    )