has_resources = true;
    }
  }

  if (!in_order) {
    // Functions do not get reused in practice, so skip the check for if the
    // callee has been updated.
    StringAttr callee_sym = cluster_func_op.getFuncAttr().getAttr();
    MoveResourceArgsToEnd(symtab.lookup<func::FuncOp>(callee_sym));
  }
  builder.setInsertionPoint(cluster_func_op);
  auto xla_launch_op = builder.create<TF::XlaLaunchOp>(

  return nullptr;
}

// Returns the function attribute for the given call op which is lifted for
// quantization.
inline FlatSymbolRefAttr GetFuncAttr(TF::PartitionedCallOp call_op) {
  return mlir::dyn_cast<FlatSymbolRefAttr>(call_op.getFAttr());
}

inline FlatSymbolRefAttr GetFuncAttr(TF::XlaCallModuleOp call_op) {
  return call_op->getAttrOfType<FlatSymbolRefAttr>(
      TF::kStablehloEntryFunctionAttrName);
}

    }

    Value result = op->getResult(0);
    for (auto user : result.getUsers()) {
      if (dyn_cast_or_null<TF::DumpTensorOp>(user)) return failure();
    }

    const FlatSymbolRefAttr f_attr = GetFuncAttr(op);
    if (!f_attr.getValue().starts_with(kCompositeFuncPrefix)) return failure();
    return success();
  }

  void rewrite(LiftedOpT op, PatternRewriter &rewriter) const override {

        }
      }
    }

    cluster_func_op->setAttr(TF::kDynamicArgIndexAttr,
                             builder.getI32ArrayAttr(dynamic_shape_arg_index));

    FlatSymbolRefAttr func_attr = cluster_func_op.getFuncAttr();
    func::FuncOp func =
        cluster_func_op->getParentOfType<ModuleOp>().lookupSymbol<func::FuncOp>(
            func_attr.getValue());

    // Update the marked argument with dynamic shapes.

    }
    // returns the function that this operation will launch.
    func::FuncOp getFuncOp() {
      return SymbolTable::lookupNearestSymbolFrom<func::FuncOp>(*this, getFuncAttr());
    }
    CallInterfaceCallable getCallableForCallee() {
      return getFuncAttr();
    }
    void setCalleeFromCallable(::mlir::CallInterfaceCallable callee);
  }];
}

def TfDevice_RemoteRunOp : TfDevice_Op<"remote_run",

    if (failed(BuildAliasingInfo(cluster_func, resource_alias_info_map)) ||
        resource_alias_info_map.empty()) {
      return;
    }

    FlatSymbolRefAttr func_attr = cluster_func.getFuncAttr();
    func::FuncOp device_func =
        module.lookupSymbol<func::FuncOp>(func_attr.getValue());
    AddAliasingAttributeToDeviceFunc(device_func, resource_alias_info_map);
  });
}

}  // namespace

  ASSERT_THAT(main_fn, NotNull());

  auto xla_call_module_op = FindOperationOfType<TF::XlaCallModuleOp>(main_fn);
  ASSERT_THAT(xla_call_module_op, NotNull());

  FlatSymbolRefAttr xla_call_op_attr = GetFuncAttr(xla_call_module_op);
  EXPECT_EQ(xla_call_op_attr.getValue(), "composite_fn_1");
}

TEST_F(AttrsAndConstraintsTest, PartitionedCallGetFuncAttr) {

        operand_and_idx.value());
    compile_op_operands.emplace_back(shape_op.getResult());
  }

  FlatSymbolRefAttr func_attr = cluster_func.getFuncAttr();
  func::FuncOp func =
      cluster_func->getParentOfType<ModuleOp>().lookupSymbol<func::FuncOp>(
          func_attr.getValue());

  std::string txt_module;
  if (failed(EncapsulateFuncAndSerialize(

//===----------------------------------------------------------------------===//

LogicalResult ClusterFuncOp::verifySymbolUses(
    mlir::SymbolTableCollection& symbolTable) {
  StringAttr func_attr = getFuncAttr().getRootReference();
  func::FuncOp func =
      symbolTable.lookupNearestSymbolFrom<func::FuncOp>(*this, func_attr);
  if (!func) {
    return emitError("'func' attribute refers to an undefined function: ")