private final String callableName;
        private final String callerClassName;
        private final CallKind kind;
        private boolean isMatchedAtDispatchSite = false;

        public EntryPointCallSiteImpl(String callableName, String callerClassName, CallKind kind) {
            this.callableName = callableName;
            this.callerClassName = callerClassName;

                .getCallableSymbols(callableId.callableName).toList()

            if (declaredSymbols.isNotEmpty()) {
                return declaredSymbols
            }

            // Fake overrides are absent in the declared member scope
            return classSymbol.getCombinedMemberScope()
                .getCallableSymbols(callableId.callableName)
                .filter { it.getContainingSymbol() == classSymbol }

                    .map { functionProto -> nameResolver.getName(functionProto.name) }

                val callableNames = (propertyNames + functionNames).distinct()
                callableNames.forEach { callableName ->
                    getTopLevelCallableSymbols(packageFqName, callableName).forEach { symbol ->

            val enumClassId = enumDescriptor.classId ?: return null
            CallableId(
                packageName = enumClassId.packageFqName,
                className = enumClassId.relativeClassName,
                callableName = descriptor.name
            )
        }

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

    override val name: Name

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        imports.flatMapTo(hashSetOf()) { listOfNotNull(it.callableName, it.aliasName) }
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        imports.flatMapTo((hashSetOf())) { listOfNotNull(it.relativeClassName?.shortName(), it.aliasName) }
    }

}

private fun KaFirSession.getCallableSymbols(callableId: CallableId) =

                            for (function in functions) {
                                val signature = function.substitute(substitutor)
                                append(signature.callableId!!.callableName.asString())
                                printCollection(signature.valueParameters, prefix = "(", postfix = ")") {
                                    append(it.returnType.render(typeRenderer, position = Variance.IN_VARIANCE))

        }

        @Suppress("UNCHECKED_CAST")
        return memberScope
            .getContributedDescriptors(DescriptorKindFilter.CALLABLES) { it == callableId.callableName }
            .filterIsInstance<CallableMemberDescriptor>()
            .firstOrNull { it.getSymbolPointerSignature() == signature }
            ?.toKtCallableSymbol(analysisContext) as? T
    }

    }

    return CallableId(
        packageName = containingFile.packageFqName,
        className = if (className.isNotEmpty()) FqName.fromSegments(className.asReversed()) else null,
        callableName = Name.identifier(selfName),
        pathToLocal = if (localName.isNotEmpty()) FqName.fromSegments(localName.asReversed()) else null
    )
}

        val callableId = firSymbol.callableId
        return KaFirSamConstructorSymbolPointer(ClassId(callableId.packageName, callableId.callableName))
    }