return registry;
        }()) {
    context_.loadAllAvailableDialects();

    mlir::OpBuilder builder(&context_);
    module_ = builder.create<mlir::ModuleOp>(builder.getUnknownLoc());

    builder.setInsertionPointToStart(module_->getBody());
    auto func = builder.create<mlir::func::FuncOp>(  //
        builder.getUnknownLoc(), "main", builder.getFunctionType({}, {}));

  }

 protected:
  MLIRContext context_;
  OwningOpRef<ModuleOp> module_;
  llvm::SourceMgr source_manager_;
};

TEST_F(Tf2XlaRewriterTest, LegalizesOpWithTf2xlaHloImporter) {
  TF_EXPECT_OK(LegalizeModule());

  int num_tuple_ops = 0;
  module_->walk([&num_tuple_ops](TupleOp tuple_op) { num_tuple_ops += 1; });

  EXPECT_EQ(num_tuple_ops, 0);
}

    }
    return main;
  }

 protected:
  MLIRContext context_;
  OwningOpRef<ModuleOp> module_;
};

TEST_F(LegalizationOpConfigTest, FailsWithExpectsLegalizationWithMlir) {
  TF_EXPECT_OK(CreateMlirModule());
  EXPECT_FALSE(IsOpLegalizedWithMlir(*module_->getOperation()));
}

TEST_F(LegalizationOpConfigTest, ExpectsFalseForNonMlirOps) {
  TF_EXPECT_OK(CreateMlirModule());
  TF_ASSERT_OK_AND_ASSIGN(FuncOp main, GetMain());

class MlirFunction : public AbstractFunction {
 public:
  explicit MlirFunction(std::unique_ptr<MLIRContext> context,
                        OwningOpRef<mlir::ModuleOp> module, func::FuncOp func)
      : AbstractFunction(kMlir),
        context_(std::move(context)),
        module_(std::move(module)),
        func_(func) {}

  Status GetFunctionDef(const tensorflow::FunctionDef** f) override;

 public:
  explicit QuantizationSummary(ModuleOp module)
      : module_(module), symbol_table_(module) {}

  void Print() {
    llvm::StringMap<OpCountItem> func_count_map;
    int32_t total_quantized_func_count = 0, float_output_func_count = 0,
            quantize_func_count = 0, dequantize_func_count = 0,
            weight_only_count = 0;

    module_.walk([&](Operation* op) {

      const GraphImportConfig& specs, mlir::ModuleOp module,
      std::unordered_map<std::string, std::string>* tf_name_to_mlir_name,
      NameUniquifier* function_name_uniquifier,
      llvm::StringRef function_name_for_debug_info = "")
      : builder_(module.getContext()),
        module_(module),
        context_(module.getContext()),
        tf_name_to_mlir_name_(tf_name_to_mlir_name),

  explicit Translator(ModuleOp module, const toco::TocoFlags& toco_flags,
                      const std::unordered_set<std::string>& saved_model_tags,
                      OpOrArgNameMapper* op_or_arg_name_mapper,
                      const std::map<std::string, std::string>& metadata,
                      std::optional<size_t> custom_option_alignment)
      : module_(module),
        name_mapper_(*op_or_arg_name_mapper),

  ModuleOp module = entry_func->getParentOfType<ModuleOp>();
  SymbolTable entry_module_table(module);
  llvm::SmallVector<func::FuncOp, 4> referenced({entry_func});

  // Create a new module to hold func and all referenced functions.
  OwningOpRef<mlir::ModuleOp> module_for_func =
      ModuleOp::create(mlir::UnknownLoc::get(entry_func.getContext()),

	<target name="install.module">
		<get dest="${target.dir}">
			<url url="${repo.url}/${module.groupId}/${module.name.prefix}${module.name}/${module.version}/${module.name.prefix}${module.name}-${module.zip.version}.zip" />
		</get>
		<unzip dest="${modules.dir}/${module.name}" src="${target.dir}/${module.name.prefix}${module.name}-${module.zip.version}.zip">
			<patternset>
				<include name="**" />
			</patternset>
			<cutdirsmapper dirs="1" />

    /**
     * Returns the modules required by this module.
     */
    Set<Module> getRequiredModules();

    /**
     * Returns the transitive closure of all modules required by this module, including the module itself.
     */
    Set<Module> getAllRequiredModules();

    /**
     * Returns the implementation + runtime classpath of the transitive closure of all modules required by this module, including the module itself.