}

mlir::LogicalResult GetTopology(mlir::tf_device::ClusterOp cluster,
                                std::string& topology) {
  mlir::StringAttr topology_attr =
      cluster->getAttrOfType<mlir::StringAttr>(tensorflow::kTopologyAttr);
  if (topology_attr) {
    topology = topology_attr.getValue();
    return mlir::success();
  } else {
    return cluster.emitOpError(

}

Attribute GetPaddingValue(PatternRewriter& rewriter,
                          llvm::StringMap<Attribute>& identifier_to_attr) {
  llvm::StringRef padding =
      mlir::dyn_cast<StringAttr>(identifier_to_attr["padding"]).getValue();
  return rewriter.getStringAttr(padding);
}

Attribute GetExplicitPaddingValue(
    PatternRewriter& rewriter, llvm::StringMap<Attribute>& identifier_to_attr) {

// tf_device.cluster_func
//===----------------------------------------------------------------------===//

LogicalResult ClusterFuncOp::verifySymbolUses(
    mlir::SymbolTableCollection& symbolTable) {
  StringAttr func_attr = getFuncAttr().getRootReference();
  func::FuncOp func =
      symbolTable.lookupNearestSymbolFrom<func::FuncOp>(*this, func_attr);
  if (!func) {

    // Signature is not modified. We do not need to keep two copies.
    info.signature_change = false;
    if (lowered_callee != callee) {
      lowered_callee.setName(
          StringAttr::get(callee->getContext(), callee.getName()));
      callee.erase();
      SymbolTable(module).insert(lowered_callee);
    }
  } else {
    info.signature_change = true;
    for (auto& entry : callee_map) {

    for (auto var_name_and_index : llvm::enumerate(var_handle_shared_names))
      function.setArgAttr(var_name_and_index.index() + var_handle_args_offset,
                          kResourceNameArgAttr,
                          StringAttr::get(context, var_name_and_index.value()));
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreatePromoteResourcesToArgsPass(
    llvm::ArrayRef<std::string> functions) {

      for (auto& attr : (*this)->getAttrs()) {
        all_attrs.insert(attr.getName().strref());
      }
      for (const auto& operand : llvm::enumerate(getArgumentTypes())) {
        if (auto attr_name = getArgAttrOfType<StringAttr>(
            operand.index(), kAttrArgumentNameAttr)) {
          all_attrs.insert(attr_name.getValue());
        }
      }
      return all_attrs;
    }
  }];

  let hasVerifier = 1;

      // Signature is not modified. We do not need to keep two copies.
      lowered_callee.setName(
          StringAttr::get(callee->getContext(), callee.getName()));
      callee.erase();
    } else {
      // Add the clone with a new name.
      lowered_callee.setName(StringAttr::get(
          callee->getContext(),
          llvm::formatv("{0}_tensorarray_decomposed", callee.getName()).str()));
    }

    // Terminators, qcast and decast are not quantizable.
    return false;
  }

  const bool attr_enforced_quantizable =
      op->hasAttrOfType<StringAttr>(kQuantTraitAttrName) &&
      op->getAttrOfType<StringAttr>(kQuantTraitAttrName).getValue().str() ==
          QuantTraitValues[QuantizationTrait::FullyQuantizable];

  const bool trait_enforced_quantizable =

  if (!op.getResult().hasOneUse()) {
    return rewriter.notifyMatchFailure(
        op, "result for current op has more than 1 use");
  }
  // Make sure Conv2D has 'VALID' padding.
  if (op->template getAttrOfType<StringAttr>("padding").getValue() != "VALID") {
    return rewriter.notifyMatchFailure(op,
                                       "Conv2D op doesn't have valid padding");
  }
  // Make sure dilations are all ones if set.

  if (func_uses.has_value() && llvm::hasSingleElement(func_uses.value()))
    return func;
  func::FuncOp cloned = func.clone();
  cloned.setPrivate();
  cloned.setName(
      StringAttr::get(func.getContext(), func.getName().str() + "_lifted"));
  SymbolTable(module).insert(cloned);
  return cloned;
}

// Eliminates unused results for If/Case operations. Also patches up the