RewritePatternSet &patterns);

// Decompose ops.
std::unique_ptr<OperationPass<func::FuncOp>> CreateDecomposeTFOpsPass(
    std::optional<ModuleOp> tfr_module = std::nullopt);

// Rewrites quantized operands and results with their storage types.
// This pass should be run at module level after decomposition, if there are
// quantized operands or results.

        "  ).call,\n",
        "    with_gradient=False,\n",
        "    native_serialization=True,\n",
        "    native_serialization_platforms=('cpu',))\n",
        "\n",
        "tf_module = tf.Module()\n",
        "tf_module.f = tf.function(\n",
        "    jax_callable,\n",
        "    autograph=False,\n",
        "    input_signature=[\n",
        "        tf.TensorSpec(input_shape, jnp.float32, 'lhs_operand')\n",

  mlir::MLIRContext context(registry);
  context.loadAllAvailableDialects();

  auto tf_module = mlir::parseSourceString<ModuleOp>(module_op_str, &context);
  if (!tf_module) {
    return absl::UnknownError("Failed to parse MLIR module");
  }

  auto mlir_file_path = ExportModule(*tf_module);
  if (!mlir_file_path.ok()) {
    return absl::UnknownError(

    }

    private static void buildDependencies(DefaultIdeaModule tapiModule, IdeaModule ideaModule, boolean offlineDependencyResolution) {
        ideaModule.setOffline(offlineDependencyResolution);
        Set<Dependency> resolved = ideaModule.resolveDependencies();
        List<DefaultIdeaDependency> dependencies = IdeaModuleBuilderSupport.buildDependencies(resolved);
        tapiModule.setDependencies(dependencies);
    }

  explicit TargetAnnotationPass(llvm::ArrayRef<std::string> device_specs)
      : TacFunctionPass(nullptr) {
    device_specs_flag_ = device_specs;
  }

  explicit TargetAnnotationPass(const TacModule* module)
      : TacFunctionPass(module) {}

 private:
  void runOnFunction() override;
  void SetTargetAnnotation(Operation* op,
                           llvm::ArrayRef<std::string> device_specs,

        !expiry2.mustCheck
        expiry2.keepFor == Duration.ofMillis(SECOND)
    }

    def "provides details of cached module"() {
        expect:
        cachePolicy.eachModule(new Action<ModuleResolutionControl>() {
            void execute(ModuleResolutionControl t) {
                assertId(t.request, 'g', 'n', 'v')
                assertId(t.cachedResult.id, 'group', 'name', 'version')

// module itself without inserting into the tf module.
FailureOr<StringAttr> RenameStablehloFunctions(
    MLIRContext *context, SymbolTableCollection &symbol_tables,
    ModuleOp tf_module, ModuleOp stablehlo_module) {
  SymbolTable &tf_symbol_table = symbol_tables.getSymbolTable(tf_module);
  // `stablehlo_module` is deleted right after the deserialization, so no need
  // to store its `SymbolTable` to `SymbolTableCollection`.

                    arith::ArithDialect, func::FuncDialect>();
  }

  explicit RaiseToTFOpsPass(std::optional<ModuleOp> tfr_module,
                            bool materialize_derived_attrs)
      : external_tfr_module_(tfr_module),
        materialize_derived_attrs_(materialize_derived_attrs) {}

  StringRef getArgument() const final { return "tfr-raise-to-tf"; }

  }
  return absl::OkStatus();
}

// Constructor of the decompose context.
TFRDecomposeContext::TFRDecomposeContext(mlir::ModuleOp tfr_module)
    : tfr_module_(tfr_module), pm_(tfr_module_.getContext()) {
  mlir::OpPassManager& func_pm = pm_.nest<mlir::func::FuncOp>();

  // Prepare the imported graph.

            }
        });
    }

    public void cacheChangingModulesFor(final int value, final TimeUnit units) {
        keepChangingModulesFor = units.toMillis(value);
        eachModule(moduleResolutionControl -> {
            if (moduleResolutionControl.isChanging()) {
                moduleResolutionControl.cacheFor(value, units);
            }
        });