}

    def parse(TestFile sourceFile) {
        _ * includesParser.parseIncludes(sourceFile) >> {
            def deps = graph[sourceFile]
            return includes(deps)
        }
    }

    private static IncludeDirectives includes(Collection<File> deps) {
        return TestIncludeParser.systemIncludes(deps.collect { it.name })
    }

    def added(TestFile sourceFile) {
        virtualFileSystem.invalidateAll()

    ]),
)

tf_cc_binary(
    name = "tfcompile",
    visibility = ["//visibility:public"],
    deps = [":tfcompile_main"],
)

cc_library(
    name = "llvm_targets",
    visibility = ["//tensorflow/python:__pkg__"],
    deps = [
    ] + if_llvm_aarch32_available([
        "@llvm-project//llvm:ARMAsmParser",  # fixdeps: keep

        publishArtifact.type == 'zip'
        publishArtifact.extension == 'zip'
        publishArtifact.classifier == null

        when:
        def deps = publishArtifact.buildDependencies

        then:
        deps.getDependencies(null).empty
    }

    def "creates artifact from extension-less file"() {
        def file = new File("someFile")

        when:

    tblgen = "@llvm-project//mlir:mlir-tblgen",
    td_file = "runtime_passes.td",
    deps = [
        "@llvm-project//mlir:PassBaseTdFiles",
    ],
)

cc_library(
    name = "runtime_passes",
    hdrs = [
        "runtime_passes.h",
    ],
    textual_hdrs = [
        "runtime_passes.h.inc",
    ],
    deps = [
        ":runtime_passes_inc_gen",
        ":tpu_merge_variable_with_execute",

    }

    /** Represents a component */
    class Component {
        String name
        String type
        List<Dependency> deps

        Component(String name, String type, List<Dependency> deps) {
            this.name = name
            this.type = type
            this.deps = deps
        }
    }

    /**
     * Number of components to generate per project
     */
    @Input
    int numberOfComponents = 4

    ],
)

cc_library(
    name = "compile_mlir_util_no_tf_dialect_passes",
    srcs = ["compile_mlir_util.cc"],
    hdrs = ["compile_mlir_util.h"],
    visibility = ["//visibility:public"],
    deps = [
        "//tensorflow/compiler/mlir/quantization/stablehlo:bridge_passes",
        "//tensorflow/compiler/mlir/tensorflow",
        "//tensorflow/compiler/mlir/tensorflow:bridge_logger",

        use a tfcompile built with extra dependencies.
      include_standard_runtime_deps: If True, the standard list of
        kernel/runtime deps is added to deps.  If False, deps must contain the
        full set of deps needed by the generated library.
      enable_xla_hlo_profiling: Enable XLA HLO profiling in the generated
        program, and emit metadata that lets us pretty-print the gathered

	return pkgs
}

// collectDeps populates p.Deps by iterating over p.Internal.Imports.
// collectDeps must be called on all of p's Imports before being called on p.
func collectDeps(p *load.Package) {
	deps := make(map[string]bool)

	for _, p := range p.Internal.Imports {
		deps[p.ImportPath] = true
		for _, q := range p.Deps {
			deps[q] = true
		}
	}

	p.Deps = make([]string, 0, len(deps))

        "//learning/brain/mlir/bridge:__pkg__",
        "//tensorflow/compiler/mlir/quantization/stablehlo:__pkg__",
        "//tensorflow/compiler/mlir/tfrt/transforms/ifrt:__pkg__",
    ],
    deps = [
        ":device_type_proto_cc",
        "//tensorflow/compiler/jit:flags_headers",
        "//tensorflow/compiler/jit:shape_inference",
        "//tensorflow/compiler/mlir/tensorflow",

        !addAllDependenciesAsConstraints() || metadata == "gradle"
    }

    private ivyComponentMetadata(String[] deps) {
        def dependencies
        if (addAllDependenciesAsConstraints()) {
            dependencies = [] //not supported in Ivy metadata
        } else {
            dependencies = deps.collect { name ->