// `KaType.abbreviatedType`, we should return `null` in such cases. The user can then fall back to the expanded type.
        typeBuilder.buildKtType(abbreviatedConeType) as? KaUsualClassType
    }

        return when (substitutors.size) {
            0 -> KaSubstitutor.Empty(token)
            else -> {
                val chained = substitutors.reduce { left, right -> left.chain(right) }
                firSymbolBuilder.typeBuilder.buildSubstitutor(chained)
            }
        }
    }


    private fun collectInheritancePath(
        baseSymbol: FirClassSymbol<*>,
        superSymbol: FirClassSymbol<*>,

        class DefaultUnmanagedComponent extends BaseComponentSpec implements UnmanagedComponent {}
        class MyRules extends RuleSource {
            @ComponentType
            public void register(TypeBuilder<UnmanagedComponent> builder) {
                builder.defaultImplementation(DefaultUnmanagedComponent)
            }
        }
        apply plugin: MyRules
        model {
            components {

    override val nullableNothing: KaType by cachedBuiltin(builtinTypes.nullableNothingType)

    private fun cachedBuiltin(builtinTypeRef: FirImplicitBuiltinTypeRef): ValidityAwareCachedValue<KaType> = cached {
        builder.typeBuilder.buildKtType(builtinTypeRef)
    }

}

private fun convertArgument(argument: ConeKotlinType, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.typeBuilder.buildKtType(argument)
}

private fun convertArgument(argument: FirTypeRef, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.typeBuilder.buildKtType(argument)
}

private fun convertArgument(argument: KtSourceElement, firSymbolBuilder: KaSymbolByFirBuilder): Any? {

                if (coneType is ConeClassLikeType && coneType !is ConeErrorType) {
                    val classId = coneType.lookupTag.classId
                    val type = builder.typeBuilder.buildKtType(coneType)
                    KaKClassAnnotationValue(type, classId, sourcePsi, token)
                } else {
                    val classId = computeErrorCallClassId(this)

            void apply(final Project project) {}

            static class Rules extends RuleSource {
                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                }

                @Mutate
                void createSampleBinary(BinaryContainer binaries) {
                    binaries.create("sampleBinary", SampleBinary)

                else -> possiblyRawVisibility
            }
        }

    override val typeParameters by cached { firSymbol.createKtTypeParameters(builder) }

    override val expandedType: KaType by cached { builder.typeBuilder.buildKtType(firSymbol.resolvedExpandedTypeRef) }

    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

                        }
                    };
                }
            }

            class MySamplePlugin extends RuleSource {
                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                    builder.defaultImplementation(DefaultSampleBinary)
                }
            }

            apply plugin:MySamplePlugin
        """
    }

        ConeKotlinType::class to HLFunctionCallConversion(
            "firSymbolBuilder.typeBuilder.buildKtType({0})",
            KaType::class.createType()
        ),
        FirTypeRef::class to HLFunctionCallConversion(
            "firSymbolBuilder.typeBuilder.buildKtType({0})",
            KaType::class.createType()
        ),
        KtSourceElement::class to HLFunctionCallConversion(