commentNewline bool              // true if the comment group contains newlines
}

type printer struct {
	// Configuration (does not change after initialization)
	Config
	fset *token.FileSet

	// Current state
	output       []byte       // raw printer result
	indent       int          // current indentation

// that takes care of accounting and error handling.
func (p *printer) write(data []byte) {
	n, err := p.output.Write(data)
	p.written += n
	if err != nil {
		panic(writeError{err})
	}
}

var (
	tabBytes    = []byte("\t\t\t\t\t\t\t\t")
	newlineByte = []byte("\n")
	blankByte   = []byte(" ")
)

func (p *printer) writeBytes(data []byte) {
	if len(data) == 0 {

            is KaAnnotation -> renderAnnotationApplication(value, printer)
            is KaAnnotationList -> renderAnnotationsList(value, printer)
            is KtModule -> renderKtModule(value, printer)
            // Other custom values
            is Name -> printer.append(value.asString())
            is FqName -> printer.append(value.asString())
            is ClassId -> printer.append(value.asString())

            else -> return
        }

        printer.append(" /* = ")
        renderTypeAsIs(expandedType, printer)
        printer.append(" */")
    }

    private fun KaSession.renderExpandedType(type: KaType, printer: PrettyPrinter) {
        renderTypeAsIs(type.fullyExpandedType, printer)
    }

    private fun KaSession.renderAbbreviatedTypeComment(type: KaType, printer: PrettyPrinter) {

		In: `package main

import "go/printer"

func f() printer.Config {
	b := printer.Config{0, 8}
	c := &printer.Config{0}
	d := &printer.Config{Tabwidth: 8, Mode: 0}
	return printer.Config{0, 8}
}
`,
		Out: `package main

import "go/printer"

func f() printer.Config {
	b := printer.Config{Mode: 0, Tabwidth: 8}
	c := &printer.Config{Mode: 0}
	d := &printer.Config{Tabwidth: 8, Mode: 0}

                            if (it is KaFunctionalType) printer.append("(")
                            typeRenderer.renderType(analysisSession, it, printer)
                            if (it is KaFunctionalType) printer.append(")")
                            printer.append('.')
                        }
                        printCollection(type.parameterTypes, prefix = "(", postfix = ")") {

	switch outputFormat {
	case "json":
		printer = &printers.JSONPrinter{}
	case "yaml":
		printer = &printers.YAMLPrinter{}
	default:
		return nil, NoCompatiblePrinterError{OutputFormat: &outputFormat, AllowedFormats: f.AllowedFormats()}
	}

	if !f.ShowManagedFields {
		printer = &printers.OmitManagedFieldsPrinter{Delegate: printer}
	}
	return printer, nil
}

// AddFlags receives a *cobra.Command reference and binds

                    }
                }

                declarationRenderer.nameRenderer.renderName(analysisSession, symbol, declarationRenderer, printer)

                printer.printCollection(symbol.valueParameters, prefix = "(", postfix = ")") {
                    declarationRenderer.typeRenderer.renderType(analysisSession, it.returnType, printer)
                }

            qualifiers: List<KaClassTypeQualifier>,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                printCollection(qualifiers, separator = ".") { qualifier ->
                    qualifier.render(analysisSession, type, typeRenderer, printer)
                }
            }
        }
    }

            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                when (projection) {
                    is KaStarTypeProjection -> printer.append('*')
                    is KaTypeArgumentWithVariance -> {
                        " ".separated(
                            { printer.append(projection.variance.label) },