require(second is KtFe10Type)
        return analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.fe10Type, second.fe10Type)
    }

    override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean {
        require(subType is KtFe10Type)
        require(superType is KtFe10Type)
        val typeChecker = analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule

            val constructorDescriptor = createSamConstructorFunction(
                descriptor.containingDeclaration,
                descriptor,
                analysisContext.resolveSession.samConversionResolver,
                JvmSamConversionOracle(analysisContext.resolveSession.languageVersionSettings)
            )

            return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisContext)
        }

        return null

@Singleton
public class DefaultModelResolver implements ModelResolver {

    @Override
    public ModelSource resolveModel(
            Session session, String groupId, String artifactId, String version, Consumer<String> resolvedVersion)
            throws ModelResolverException {
        try {
            ArtifactCoordinate coord = session.createArtifactCoordinate(groupId, artifactId, version, "pom");

        val classDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()

        val inheritorsProvider = analysisContext.resolveSession.sealedClassInheritorsProvider
        val allowInDifferentFiles = analysisContext.resolveSession.languageVersionSettings
            .supportsFeature(LanguageFeature.AllowSealedInheritorsInDifferentFilesOfSamePackage)

    override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {
        val packageFragmentProvider = analysisContext.resolveSession.packageFragmentProvider
        return packageFragmentProvider.getSubPackagesOf(owner.fqName, nameFilter)
            .asSequence()
            .map { KtFe10PackageSymbol(it, analysisContext) }
    }

    }

    override fun getPackageScope(packageSymbol: KtPackageSymbol): KtScope {
        require(packageSymbol is KtFe10PackageSymbol)
        val packageFragments = analysisContext.resolveSession.packageFragmentProvider.packageFragments(packageSymbol.fqName)
        val scopeDescription = "Compound scope for package \"${packageSymbol.fqName}\""

        check(analysisSession is KtFe10AnalysisSession)
        val analysisContext = analysisSession.analysisContext

        val entryDescriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
            ?.unsubstitutedMemberScope
            ?.getContributedClassifier(entryName, NoLookupLocation.FROM_IDE)

        check(analysisSession is KtFe10AnalysisSession)
        val analysisContext = analysisSession.analysisContext

        val descriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
        return KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisContext)
    }

) : KtJvmTypeMapper(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisContext.resolveSession) }

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

        get() = withValidityAssertion {
            (source as? PsiSourceElement)?.psi
                ?: KtFe10ReferenceResolutionHelper.getInstance()
                    ?.findDecompiledDeclaration(analysisContext.resolveSession.project, descriptor, null)
        }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { descriptor.getSymbolOrigin(analysisContext) }