}
    }
    Builder stablehlo_builder(stablehlo_module_op.get().getContext());
    // Rename XlaCallModuleOp's functions to avoid naming conflicts.
    for (auto func_op : stablehlo_module_op.get().getOps<func::FuncOp>()) {
      const std::string new_func_name =
          CreateNewFuncName(func_op.getSymName(), parent_module_symbol_table);
      if (failed(stablehlo_module_symbol_table.replaceAllSymbolUses(

import java.util.Map;

public interface IvyModule extends Module {
    String getOrganisation();
    @Override
    String getModule();
    String getRevision();

    ModuleArtifact getIvy();

    ModuleArtifact getJar();

    TestFile getIvyFile();

    TestFile getJarFile();

    TestFile getModuleMetadataFile();

    /**
     * Don't publish an ivy.xml / .module for this module.
     */

  // to store its `SymbolTable` to `SymbolTableCollection`.
  SymbolTable stablehlo_symbol_table(stablehlo_module);

  Builder builder(context);
  StringAttr main_func_name;
  for (auto func : stablehlo_module.getOps<func::FuncOp>()) {
    const bool is_main_func = func.getSymName() == kStablehloMainFunctionName;
    if (tf_symbol_table.lookup(func.getSymName())) {
      if (failed(stablehlo_symbol_table.renameToUnique(

    builder.create<YieldOp>(island_op.getLoc(), yield_operands);
  }

  // Outline all the transitively called functions by moving them in the
  // outlined module.
  for (func::FuncOp func : outlined_module.getOps<func::FuncOp>()) {
    func.walk([&](Operation *op) {
      for (NamedAttribute attr : op->getAttrs()) {
        if (auto symbol_ref =
                mlir::dyn_cast<FlatSymbolRefAttr>(attr.getValue())) {

void FreezeAssetsPass::runOnOperation() {
  auto module = getOperation();
  if (!tf_saved_model::HasTfSavedModelSemantics(module)) {
    return;
  }
  SymbolTable symbol_table(module);

  for (auto func : module.getOps<func::FuncOp>()) {
    llvm::BitVector args_to_erase(func.getNumArguments());
    OpBuilder builder(func.getBody());

    for (int i = 0, e = func.getNumArguments(); i < e; ++i) {

    }

    @Override
    ModuleArtifact getIvy() {
        backingModule.ivy
    }

    @Override
    ModuleArtifact getJar() {
        backingModule.jar
    }

    @Override
    ModuleArtifact getModuleMetadata() {
        backingModule.moduleMetadata
    }

    @Override

                            op->getName().getDialectNamespace();
}

void OrderByDialectPass::runOnOperation() {
  ModuleOp module = getOperation();
  for (func::FuncOp func : module.getOps<func::FuncOp>()) {
    std::vector<std::pair<Operation*, Operation*>> side_effect_data;
    const detail::SideEffectAnalysisInfo* info = nullptr;
    auto extra_dependencies =
        [&](Operation* op,

  LogicalResult UnifyReplicationInfo(func::FuncOp func) {
    auto new_repl_info =
        builder.getStringAttr(func.getSymName().str() + "_repl_info");
    for (auto& op : func.getRegion().getOps()) {
      if (auto compile_op = llvm::dyn_cast<TF::TPUCompilationResultOp>(op)) {
        UpdateReplicationAttr(compile_op, new_repl_info);
      } else {
        UpdateReplicationAttr(&op, new_repl_info);
      }

    }

    @Managed
    interface Thing {
        void setName(String name)

        String getName()
    }

    @Managed
    interface Foo {
        ModelSet<Thing> getBar()
    }

    interface Unmanaged {}

    def "can create via DSL"() {
        when:
        modelDsl.configure {
            foo(Foo)
        }

        then:

  FailureOr<OpT> FindFirstOpFromMainFunc(ModuleOp module_op) {
    func::FuncOp main_func_op = FindMainFuncOp(module_op);
    if (main_func_op == nullptr) return failure();

    auto ops = main_func_op.getOps<OpT>();
    if (ops.empty()) return failure();

    return *ops.begin();
  }

  std::unique_ptr<MLIRContext> ctx_;
  OpBuilder builder_;
};

}  // namespace mlir::quant