while (!funcs_to_visit.empty()) {
    SmallVector<func::FuncOp, 4> new_funcs_to_visit;
    for (func::FuncOp func_to_visit : funcs_to_visit) {
      if (!func_to_visit.getCallableRegion()) continue;
      collect_reachable_funcs(*func_to_visit.getCallableRegion(),
                              new_funcs_to_visit);
    }
    funcs_to_visit.swap(new_funcs_to_visit);
  }

  return llvm::to_vector<4>(reachable_funcs);
}

      if (node_to_cluster[node].getOperation() != tpu_cluster) {
        node->getCallableRegion()->getParentOp()->emitOpError(
            "The same function is reachable from multiple TPU Clusters.");
      }
    } else {
      node_to_cluster[node] = tpu_cluster;
      auto result = node->getCallableRegion()->walk([&](Operation* op) {
        insert_pending_op(op, tpu_cluster);
        return callback(op, tpu_cluster,

                    "one use for all functions. Functions in the "
                    "recursive cycle are: ";
      llvm::interleaveComma(*scci, err, [&](CallGraphNode *node) {
        err << node->getCallableRegion()->getLoc();
      });
      return err;
    }
  }
  return success();
}

#define GEN_PASS_DEF_GUARANTEEALLFUNCSONEUSEPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

    if (failed(inlineCall(inliner, call_interface,
                          cast<CallableOpInterface>(called_func.getOperation()),
                          called_func.getCallableRegion(),
                          /* shouldCloneInlinedRegion = */ false))) {
      call_op.emitOpError() << "Failed to inline\n";
      return WalkResult::interrupt();
    }
    called_func.erase();
    call_op.erase();

  module->walk([&](SymbolOpInterface op) {
    if (!op.isPrivate()) return;

    auto call = llvm::dyn_cast<CallableOpInterface>(op.getOperation());
    if (!call) return;
    Region* region = call.getCallableRegion();
    if (!region) return;  // happens e.g. for external functions

    auto func = llvm::dyn_cast<FunctionOpInterface>(op.getOperation());
    if (!func || do_not_touch.count(func)) return;

    if (failed(inlineCall(inliner,
                          cast<CallOpInterface>(call_op.getOperation()),
                          cast<CallableOpInterface>(callee.getOperation()),
                          callee.getCallableRegion(),
                          /**shouldCloneInLinedRegion=*/true))) {
      // This failure is usually because the decompose function is not defined.
      // This call will be raised to TF ops.

      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
  ];

  let extraClassDeclaration = [{
    LogicalResult verifyType() { return success(); }

    mlir::Region *getCallableRegion();

    /// Returns the argument types of this function.
    ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }

    /// Returns the result types of this function.

    // backtrack through that function call (our analysis will be correct but
    // pessimistic).
    for (CallGraphNode* node : scc) {
      if (node->isExternal()) continue;
      Region* region = node->getCallableRegion();
      GetOrCreateAnalysis(*region);
    }
  }

  // This above call graph analysis will cover all regions attached to functions
  // but we also need to analyze regions attached to other ops.

  (void)operands;
  assert(operands.empty() && "constant has no operands");

  // Return the held attribute value.
  return getValue();
}

// CallableOpInterface
Region *TFRFuncOp::getCallableRegion() {
  return isExternal() ? nullptr : &getBody().front();
}

//===----------------------------------------------------------------------===//
// Dialect type definitions