}

    override fun convertType(type: KType): KType {
        val first = type.arguments.getOrNull(0)?.type ?: return type
        val second = type.arguments.getOrNull(1)?.type ?: return type
        return Pair::class.createType(
            arguments = listOf(
                KTypeProjection(
                    variance = KVariance.INVARIANT,
                    type = mappingConversionFirst.convertType(first)

data class HLDiagnosticParameter(
    val original: DiagnosticParameter,
    val name: String,
    val type: KType,
    val originalParameterName: String,
    val conversion: HLParameterConversion,
    val importsToAdd: List<String>

                addAll(collectImportsForDiagnosticParameter(diagnosticParameter))
            }
        }
    }

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

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

        require(type is KtFe10Type)
        return TypeUtils.isNullableType(type.fe10Type)
    }

    override fun isDenotable(type: KtType): Boolean {
        require(type is KtFe10Type)
        val kotlinType = type.fe10Type
        return kotlinType.isDenotable()
    }

    override fun isArrayOrPrimitiveArray(type: KtType): Boolean {
        require(type is KtFe10Type)

        ) == null
    }

    override fun isArrayOrPrimitiveArray(type: KtType): Boolean {
        require(type is KtFirType)
        return type.coneType.isArrayOrPrimitiveArray
    }

    override fun isNestedArray(type: KtType): Boolean {
        if (!isArrayOrPrimitiveArray(type)) return false
        require(type is KtFirType)
        return type.coneType.arrayElementType()?.isArrayOrPrimitiveArray == true
    }

- [`KTIJ-26501`](https://youtrack.jetbrains.com/issue/KTIJ-26501) K2: IDE K2: False positive unused import when declaration used for vararg parameter type

    override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type {
        val kotlinType = (type as KtFe10Type).fe10Type
        return typeMapper.mapType(kotlinType, mode)
    }

    override fun isPrimitiveBacked(type: KtType): Boolean {
        val kotlinType = (type as KtFe10Type).fe10Type
        return typeMapper.isPrimitiveBacked(kotlinType)
    }

            token,
        )
    }
    add(FirErrors.ACTUAL_TYPE_ALIAS_TO_NULLABLE_TYPE) { firDiagnostic ->
        ActualTypeAliasToNullableTypeImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.ACTUAL_TYPE_ALIAS_TO_NOTHING) { firDiagnostic ->
        ActualTypeAliasToNothingImpl(
            firDiagnostic as KtPsiDiagnostic,

    }

    /**
     * Maps [typeArguments] to the type parameters of [partiallyAppliedSymbol].
     *
     * If too many type arguments are provided, a mapping is still created. Extra type arguments are simply ignored. If this wasn't the
     * case, the resulting [KtCall] would contain no type arguments at all, which can cause problems later. If too few type arguments are

        override val diagnosticClass get() = MissingDependencyClass::class
        val type: KtType
    }

    interface MissingDependencyClassInExpressionType : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = MissingDependencyClassInExpressionType::class
        val type: KtType
    }

    interface MissingDependencySuperclass : KtFirDiagnostic<PsiElement> {