licenses = ["notice"],
)

td_library(
    name = "mlrt_td_files",
    srcs = [
        "mlrt_dialect.td",
        "mlrt_ops.td",
    ],
    includes = ["."],
    visibility = [
        # copybara:uncomment "//learning/brain/tfrt/mlir:__subpackages__",
    ],
    deps = [
        "@llvm-project//mlir:OpBaseTdFiles",
        "@llvm-project//mlir:SideEffectInterfacesTdFiles",
    ],
)

        get() = withValidityAssertion {
            descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType()
        }

    override val visibility: Visibility
        get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }

    override val isActual: Boolean
        get() = withValidityAssertion { descriptor?.isActual ?: psi.hasActualModifier() }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion {
            firSymbol.fir.hasStableParameterNames
        }

    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }

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

    override val containingClassId: ClassId?

    licenses = ["notice"],
)

filegroup(
    name = "headers",
    srcs = [
        "stream_executor.h",
    ],
    visibility = ["//tensorflow:__subpackages__"],
)

cc_library(
    name = "stream_executor_hdrs",
    hdrs = ["stream_executor.h"],
    visibility = ["//tensorflow:internal"],
    deps = [
        "//tensorflow/c:c_api_macros_hdrs",
        "//tensorflow/c:tf_status_headers",
    ],
)

        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KaFe10DescTypeParameterSymbol(it, analysisContext) } }

    override val visibility: Visibility
        get() = withValidityAssertion { descriptor.ktVisibility }

    override val expandedType: KaType
        get() = withValidityAssertion { descriptor.expandedType.toKtType(analysisContext) }

    override val symbolKind: KaSymbolKind

    licenses = ["notice"],
)

filegroup(
    name = "headers",
    srcs = [
        "pluggable_profiler.h",
    ],
    visibility = ["//tensorflow:__subpackages__"],
)

cc_library(
    name = "pluggable_profiler_hdrs",
    hdrs = ["pluggable_profiler.h"],
    visibility = ["//tensorflow:internal"],
    deps = [
        "//tensorflow/c:c_api_macros",
        "//tensorflow/c:tf_status_headers",
    ],
)

            ?.let { property -> DeclarativeRuntimePropertyGetter { property.call(it) } }

    private
    fun findKotlinFunctionSetter(receiverClass: KClass<*>, name: String) =
        receiverClass.memberFunctions.find { it.name == setterName(name) && it.visibility == KVisibility.PUBLIC }

    )


val isPublic: MemberFilter = MemberFilter { member: KCallable<*> ->
    member.visibility == KVisibility.PUBLIC
}


val isPublicAndRestricted: MemberFilter = MemberFilter { member: KCallable<*> ->
    member.visibility == KVisibility.PUBLIC &&
        member.annotationsWithGetters.any {

        ":lib_headers",
    ],
    visibility = ["//tensorflow/python:__pkg__"],
)

filegroup(
    name = "sources",
    srcs = [
        ":device_sources",
        ":lib_sources",
    ],
    visibility = ["//tensorflow/python:__pkg__"],
)

cc_library(
    name = "parallel_device",
    srcs = [":device_sources"],
    hdrs = [":device_headers"],
    visibility = ["//visibility:private"],
    deps = [

    ],
    hdrs = [
        "modular_filesystem.h",
        "modular_filesystem_registration.h",
    ],
    # TODO(b/139060984): Visibility should be more restrictive once we
    # convert to modular filesystems everywhere
    visibility = ["//visibility:public"],
    deps = [
        ":filesystem_interface",
        "//tensorflow/c:tf_status_helper",
        "//tensorflow/c:tf_status_internal",