],
)

cc_library(
    name = "tf2xla_rewriter",
    srcs = [
        "tf2xla_rewriter.cc",
    ],
    hdrs = [
        "tf2xla_rewriter.h",
    ],
    visibility = ["//visibility:private"],
    deps = [
        ":legalize_tf",
        "//tensorflow/compiler/mlir:op_or_arg_name_mapper",
        "//tensorflow/compiler/mlir/tensorflow",

import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.EffectiveVisibility
import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.diagnostics.Severity
import org.jetbrains.kotlin.diagnostics.WhenMissingCase
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.*

			expect:   false,
		},
		{
			name:     "public visibility, spec change",
			prevConv: newService(visibility.Public, []int{80}),
			currConv: newService(visibility.Public, []int{80, 443}),
			expect:   true,
		},
		{
			name:     "none visibility, spec change",
			prevConv: newService(visibility.None, []int{80}),
			currConv: newService(visibility.None, []int{80, 443}),
			expect:   false,
		},
	}

 */
@NonNullApi
@ServiceScope(Scope.BuildSession.class)
public final class JvmInstallationProblemReporter {
    @NonNullApi
    private static final class ProblemReport {
        // Include auto-detection as it affects visibility of the problem. We do want to report twice if a location was auto-detected and then explicitly configured.
        private final boolean autoDetected;
        private final String problem;

        val functionsClaimedByProperties = preIndex.getClaimedFunctions(kClass)
        return kClass.memberFunctions.filter {
            it.visibility == KVisibility.PUBLIC &&
                includeFilter.shouldIncludeMember(it) &&
                it !in functionsClaimedByProperties
        }.map { function -> memberFunction(kClass, function, preIndex, configureLambdas) }

            (includeMemberFilter.shouldIncludeMember(property) ||
                kClass.primaryConstructor?.parameters.orEmpty().any { it.name == property.name && it.type == property.returnType })
                && property.visibility == KVisibility.PUBLIC
                && propertyNamePredicate(property.name)
        }.map { property -> kPropertyInformation(property) }

    private

        "//tensorflow/compiler/mlir/...",
        "//tensorflow/lite/python/...",
        "//waymo/accelerator/alpine/tools/...",
        "//waymo/ml/compiler/mlir/...",
        # Allow visibility from the mlir language server.
        "//learning/brain/mlir/mlir_lsp_server/...",
        "//research/language_modeling/sentence_explorer/ondevice/...",

            (includeMemberFilter.shouldIncludeMember(property) ||
                kClass.primaryConstructor?.parameters.orEmpty().any { it.name == property.name && it.type == property.returnType }) &&
                property.visibility == KVisibility.PUBLIC &&
                isGradlePropertyType(property.returnType)
        }.map { property ->
            val isHidden = property.annotationsWithGetters.any { it is HiddenInDeclarativeDsl }

        """

        and:
        succeeds "echo"

        then:
        output.contains "hello again"
    }

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor) // In embedded testing mode, the visibility constraints are not enforced
    def "build src plugin cannot access Gradle implementation dependencies"() {
        when:
        file("buildSrc/src/main/groovy/pkg/BuildSrcPlugin.groovy") << """
            package pkg

			}

			ps.exportToDefaults = exportToDefaults{
				virtualService:  sets.New(visibility.Public),
				service:         sets.New(visibility.Public),
				destinationRule: sets.New(visibility.Public),
			}

			sidecarConfig := tt.sidecarConfig
			configuredListeneres := 1
			if sidecarConfig != nil {