}
    }

    override fun TypeConstructorMarker.defaultType(): KotlinTypeMarker {
        require(this is TypeConstructor)
        val declaration = declarationDescriptor
            ?: return ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_DECLARATION, this.toString())
        return declaration.defaultType
    }

    override fun TypeConstructorMarker.isScript(): Boolean {

import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope
import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.FirTypeScope
import org.jetbrains.kotlin.fir.scopes.getProperties
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol

        val classifier = type.classifierDescriptor
        val defaultType = classifier.defaultType
        val parameters = classifier.declaredTypeParameters
        val arguments = type.arguments

        if ((defaultType.isFunctionType && arguments.size > BuiltInFunctionArity.BIG_ARITY) || defaultType.isKFunctionType) {
            writeGenericArguments(sw, arguments.take(1), parameters.take(1), mode)

            ?: testServices.expressionMarkerProvider.getSelectedElementOfTypeByDirective(
                ktFile = mainFile,
                module = mainModule,
                defaultType = KtElement::class,
            ) as KtElement

        val elementToResolve = expression.elementToResolve
        return listOf(ResolveTestCaseContext(element = elementToResolve, context = elementToResolve, marker = null))

                callableName = descriptor.name
            )
        }

    override val returnType: KaType
        get() = withValidityAssertion { enumDescriptor.defaultType.toKtType(analysisContext) }

    override val name: Name
        get() = withValidityAssertion { descriptor.name }

                }
            }

            TypeUtils.substituteProjectionsForParameters(descriptor, projections)
        } else {
            descriptor.defaultType
        }

        val typeWithNullability = TypeUtils.makeNullableAsSpecified(type, builder.nullability == KaTypeNullability.NULLABLE)

    }

    private fun ExplicitSmartCasts.getKtType(): KaType? {
        if (this is MultipleSmartCasts) {
            return intersectWrappedTypes(map.values).toKtType(analysisContext)
        }
        return defaultType?.toKtType(analysisContext)
    }

    private fun smartCastedImplicitReceiver(type: KotlinType?, kind: KaImplicitReceiverSmartCastKind): KaImplicitReceiverSmartCast? {
        if (type == null) return null

            val containingDescriptor = descriptor?.containingDeclaration
            if (containingDescriptor is ClassDescriptor && containingDescriptor.kind == ClassKind.ENUM_CLASS) {
                return containingDescriptor.defaultType.toKtType(analysisContext)
            } else {
                createErrorType()
            }
        }

    override val name: Name
        get() = withValidityAssertion { psi.nameAsSafeName }

        return enhancement?.toKtType(analysisContext)
    }

    override fun buildSelfClassType(symbol: KaNamedClassOrObjectSymbol): KaType {
        val kotlinType = (getSymbolDescriptor(symbol) as? ClassDescriptor)?.defaultType
            ?: ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_CLASS_TYPE, symbol.nameOrAnonymous.toString())
        return kotlinType.toKtType(analysisContext)
    }

        if (smartCasts is MultipleSmartCasts) {
            if (smartCasts.map.values.all { !it.isMarkedNullable }) {
                return true
            }
        }

        val smartCastType = smartCasts?.defaultType
        if (smartCastType != null && !smartCastType.isMarkedNullable) {
            return true
        }

        val expressionType = expression.getType(bindingContext) ?: return false