fun getSamConstructor(firClass: FirRegularClass): FirSimpleFunction? {
            val samConstructor = bodyResolveComponents.samResolver.getSamConstructor(firClass) ?: return null
            if (samConstructor.origin != FirDeclarationOrigin.SamConstructor) return null
            return samConstructor
        }
    }

            }
        }


        fun buildFieldSymbol(firSymbol: FirFieldSymbol): KtFirJavaFieldSymbol {
            if (firSymbol.origin == FirDeclarationOrigin.ImportedFromObjectOrStatic) {
                return buildFieldSymbol(firSymbol.fir.importedFromObjectOrStaticData!!.original.symbol)
            }

        get() = withValidityAssertion { file }

    override val annotationsObject: Annotations
        get() = withValidityAssertion { analysisContext.resolveSession.getFileAnnotations(file) }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { if (file.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }

    override fun createPointer(): KtSymbolPointer<KtFileSymbol> = withValidityAssertion {

    }

    override fun createPointer(): KtSymbolPointer<KtPackageSymbol> = withValidityAssertion {
        KtFe10PackageSymbolPointer(fqName)
    }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion {
            val virtualFile = PsiUtilCore.getVirtualFile(psi)
            return if (virtualFile != null) {
                analysisContext.getOrigin(virtualFile)

    override val returnType: KtType
        get() = withValidityAssertion { propertyDescriptor.type.toKtType(analysisContext) }

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

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

        return super.getCallableSymbols(nameFilter).filter { it.origin == KtSymbolOrigin.DELEGATED }
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KtCallableSymbol> = withValidityAssertion {
        return super.getCallableSymbols(names).filter { it.origin == KtSymbolOrigin.DELEGATED }
    }

class KtFe10PsiClassInitializerSymbol(
    override val psi: KtClassInitializer,
    override val analysisContext: Fe10AnalysisContext
) : KtClassInitializerSymbol(), KtFe10Symbol {
    override val origin: KtSymbolOrigin
        get() = withValidityAssertion {
            return if (psi.containingKtFile.isCompiled) {
                KtSymbolOrigin.LIBRARY
            } else {
                KtSymbolOrigin.SOURCE

        val bindingContext = analysisContext.analyze(psi, Fe10AnalysisFacade.AnalysisMode.PARTIAL)
        bindingContext[BindingContext.SCRIPT, psi]
    }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { if (script.containingKtFile.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }

    override val psi: KtScript
        get() = withValidityAssertion { script }

        // Collect original declarations from the context files
        val collectingVisitor = IrDeclarationMappingCollectingVisitor()
        irOrdinaryFiles.forEach { it.acceptVoid(collectingVisitor) }

        // Replace duplicate symbols with the original ones
        val patchingVisitor = IrDeclarationPatchingVisitor(collectingVisitor.mappings)

    //TODO Check thread safety
    session.jvmTypeMapper.mapType(this, mode, signatureWriter) {
        val containingFile = useSitePosition.containingKtFile
        // parameters for default setters does not have kotlin origin, but setter has
            ?: (useSitePosition as? KtLightParameter)?.parent?.parent?.containingKtFile
            ?: return@mapType null