*/
            String className = repo.getLayout().getClass().getSimpleName();
            if (className.endsWith("RepositoryLayout")) {
                String layout = className.substring(0, className.length() - "RepositoryLayout".length());
                if (!layout.isEmpty()) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@file:JvmName("GenerateIdnaMappingTableCode")

package okhttp3.internal.idn

import com.squareup.kotlinpoet.ClassName
import com.squareup.kotlinpoet.FileSpec
import com.squareup.kotlinpoet.KModifier
import com.squareup.kotlinpoet.PropertySpec
import java.io.File
import okio.FileSystem
import okio.Path.Companion.toPath

import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.DiagnosticParameter
import kotlin.reflect.KType

data class HLDiagnostic(
    val original: DiagnosticData,
    val severity: Severity?,
    val className: String,
    val implClassName: String,
    val parameters: List<HLDiagnosticParameter>,
)

data class HLDiagnosticList(val diagnostics: List<HLDiagnostic>)

data class HLDiagnosticParameter(

    }
}

data class PerformanceTestDuration(val scenario: Scenario, val durationInMs: Int) {
    fun toCsvLine() = "${scenario.className};${scenario.scenario}"
}

data class PerformanceScenario(val scenario: Scenario, val testProject: String)

interface PerformanceTestBucket {

                            .filter(s -> !s.isEmpty() && !s.startsWith("#"))
                            .toList();
                }
                for (String className : lines) {
                    try {
                        Class<?> clazz = classLoader.loadClass(className);
                        injector.bindImplicit(clazz);
                    } catch (ClassNotFoundException e) {
                        // ignore

        }
}


private
fun binaryNameOfBaseType(descriptor: Char) =
    Type.getType(descriptor.toString()).className


private
fun binaryNameOfInternalName(internalName: String): String =
    Type.getObjectType(internalName).className


fun sourceNameOfBinaryName(binaryName: String): String =
    when (binaryName) {
        "void" -> "Unit"
        "?" -> "*"

            mergeType(tr, model)
        }
    }

    def mergeType(Element typeTr, DslDocModel model) {
        String className = typeTr.td[0].text().trim()
        gradlebuild.docs.dsl.docbook.model.ClassDoc classDoc = model.getClassDoc(className)
        typeTr.children = {
            td {
                link(linkend: classDoc.id) { literal(classDoc.simpleName) }
            }

            }
        }
    }

    protected fun HLDiagnosticList.containsClashingBySimpleNameType(type: KType): Boolean {
        return diagnostics.any { it.className == type.simpleName }
    }

    protected abstract fun collectImportsForDiagnosticParameter(diagnosticParameter: HLDiagnosticParameter): Collection<String>

        return when (diagnostic){
            is RegularDiagnosticData -> listOf(
                HLDiagnostic(
                    original = diagnostic,
                    severity = null,
                    className = diagnostic.getHLDiagnosticClassName(),
                    implClassName = diagnostic.getHLDiagnosticImplClassName(),
                    parameters = diagnostic.parameters.mapIndexed(::convertParameter)
                )

        }
        print(") : KtAbstractFirDiagnostic<")
        printTypeWithShortNames(diagnostic.original.psiType)
        println(">(firDiagnostic, token), KtFirDiagnostic.${diagnostic.className}")
    }

    private fun SmartPrinter.printParameters(diagnostic: HLDiagnostic, diagnosticList: HLDiagnosticList) {
        for (parameter in diagnostic.parameters) {
            printParameter(parameter, diagnosticList)