[XLA] Switch from tensorflow::str_util::Join to absl::StrJoin.

PiperOrigin-RevId: 210018843

1 files changed, 26 insertions, 23 deletions

diff --git a/tensorflow/compiler/xla/service/shape_inference.cc b/tensorflow/compiler/xla/service/shape_inference.cc
index 84918034fa..9784d915bf 100644
--- a/tensorflow/compiler/xla/service/shape_inference.cc
+++ b/tensorflow/compiler/xla/service/shape_inference.cc
@@ -23,6 +23,7 @@ limitations under the License.
 
 #include "absl/algorithm/container.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "tensorflow/compiler/xla/shape_util.h"
 #include "tensorflow/compiler/xla/status_macros.h"
@@ -38,7 +39,7 @@ limitations under the License.
 #include "tensorflow/core/platform/logging.h"
 #include "tensorflow/core/platform/protobuf.h"
 
-using tensorflow::str_util::Join;
+using absl::StrJoin;
 using tensorflow::strings::Printf;
 
 namespace xla {
@@ -914,7 +915,7 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
       "inferring shape for <%s>(%s, %s) with broadcast_dimensions={%s}",
       HloOpcodeString(opcode).c_str(), ShapeUtil::HumanString(lhs).c_str(),
       ShapeUtil::HumanString(rhs).c_str(),
-      Join(broadcast_dimensions, ", ").c_str());
+      StrJoin(broadcast_dimensions, ", ").c_str());
   TF_DCHECK_OK(ShapeUtil::ValidateShapeWithOptionalLayout(lhs));
   TF_DCHECK_OK(ShapeUtil::ValidateShapeWithOptionalLayout(rhs));
 
@@ -1092,7 +1093,7 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
     return InvalidArgument(
         "Map operation requires all operands to have the same shape; got: "
         "%s.",
-        Join(pieces, ", ").c_str());
+        StrJoin(pieces, ", ").c_str());
   }
 
   // Check that dimensions.size == arg_shape.dimensions_size() (we currently
@@ -1109,7 +1110,7 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
     if (dimensions[i] != i) {
       return InvalidArgument(
           "Map requires monotonically increasing dimension numbers; got: %s.",
-          Join(dimensions, ", ").c_str());
+          StrJoin(dimensions, ", ").c_str());
     }
   }
 
@@ -2010,14 +2011,14 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
         "%s in slice operation; argument shape: %s; starts: {%s}; limits: "
         "{%s}; strides: {%s}.",
         message.c_str(), ShapeUtil::HumanString(arg).c_str(),
-        Join(starts, ",").c_str(), Join(limits, ",").c_str(),
-        Join(strides, ",").c_str());
+        StrJoin(starts, ",").c_str(), StrJoin(limits, ",").c_str(),
+        StrJoin(strides, ",").c_str());
   };
   TF_RETURN_IF_ERROR(ExpectArray(arg, "operand of slice"));
   VLOG(2) << tensorflow::strings::Printf(
       "slicing shape %s starts={%s} limits={%s}",
-      ShapeUtil::HumanString(arg).c_str(), Join(starts, ", ").c_str(),
-      Join(limits, ", ").c_str());
+      ShapeUtil::HumanString(arg).c_str(), StrJoin(starts, ", ").c_str(),
+      StrJoin(limits, ", ").c_str());
 
   if (starts.size() != limits.size()) {
     return error(Printf("slice start and limit sizes differ: %zu vs %zu",
@@ -2080,7 +2081,7 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
       "slicing shape %s at dynamic start_indices %s with slice_sizes={%s}",
       ShapeUtil::HumanString(operand_shape).c_str(),
       ShapeUtil::HumanString(start_indices_shape).c_str(),
-      Join(slice_sizes, ", ").c_str());
+      StrJoin(slice_sizes, ", ").c_str());
 
   if (ShapeUtil::Rank(start_indices_shape) != 1) {
     return InvalidArgument(
@@ -2377,7 +2378,8 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
     return InvalidArgument(
         "Reshape dimensions [%s] are not a permutation of the operand "
         "dimensions (operand shape is %s).",
-        Join(dimensions, ",").c_str(), ShapeUtil::HumanString(operand).c_str());
+        StrJoin(dimensions, ",").c_str(),
+        ShapeUtil::HumanString(operand).c_str());
   }
 
   return inferred_shape;
@@ -2497,7 +2499,7 @@ ShapeInference::InferDegenerateDimensionBroadcastShape(HloOpcode operation,
   if (arg_shapes.size() != to_apply.parameters_size()) {
     string computation_signature = ShapeUtil::HumanString(to_apply);
     string argument_shapes =
-        Join(arg_shapes, ", ", [](string* out, const Shape* shape) {
+        StrJoin(arg_shapes, ", ", [](string* out, const Shape* shape) {
           absl::StrAppend(out, ShapeUtil::HumanString(*shape));
         });
     return InvalidArgument(
@@ -2531,14 +2533,14 @@ static Status ValidateGatherDimensionNumbers(
   if (!absl::c_is_sorted(dim_numbers.offset_dims())) {
     return InvalidArgument(
         "Output window dimensions in gather op must be ascending; got: %s.",
-        Join(dim_numbers.offset_dims(), ", ").c_str());
+        StrJoin(dim_numbers.offset_dims(), ", ").c_str());
   }
 
   if (absl::c_adjacent_find(dim_numbers.offset_dims()) !=
       dim_numbers.offset_dims().end()) {
     return InvalidArgument(
         "Output window dimensions in gather op must not repeat; got: %s.",
-        Join(dim_numbers.offset_dims(), ", ").c_str());
+        StrJoin(dim_numbers.offset_dims(), ", ").c_str());
   }
 
   const int64 output_offset_dim_count = dim_numbers.offset_dims_size();
@@ -2587,7 +2589,7 @@ static Status ValidateGatherDimensionNumbers(
     return InvalidArgument(
         "Repeated dimensions are not allowed in start_index_map; "
         "got: %s.",
-        Join(dim_numbers.start_index_map(), ", ").c_str());
+        StrJoin(dim_numbers.start_index_map(), ", ").c_str());
   }
 
   for (int64 collapsed_dim : dim_numbers.collapsed_slice_dims()) {
@@ -2602,7 +2604,7 @@ static Status ValidateGatherDimensionNumbers(
   if (!absl::c_is_sorted(dim_numbers.collapsed_slice_dims())) {
     return InvalidArgument(
         "collapsed_slice_dims in gather op must be sorted; got: %s",
-        Join(dim_numbers.collapsed_slice_dims(), ", ").c_str());
+        StrJoin(dim_numbers.collapsed_slice_dims(), ", ").c_str());
   }
 
   if (absl::c_adjacent_find(dim_numbers.collapsed_slice_dims()) !=
@@ -2610,7 +2612,7 @@ static Status ValidateGatherDimensionNumbers(
     return InvalidArgument(
         "Repeated dimensions not allowed in collapsed_slice_dims in gather op; "
         "got: %s.",
-        Join(dim_numbers.collapsed_slice_dims(), ", ").c_str());
+        StrJoin(dim_numbers.collapsed_slice_dims(), ", ").c_str());
   }
 
   return Status::OK();
@@ -2672,8 +2674,9 @@ static Status ValidateGatherDimensionNumbers(
         "All components of the offset index in a gather op must either be a "
         "offset dimension or explicitly collapsed; got len(slice_sizes)=%lu, "
         "output_slice_sizes=%s, collapsed_slice_dims=%s.",
-        slice_sizes.size(), Join(gather_dim_numbers.offset_dims(), ",").c_str(),
-        Join(gather_dim_numbers.collapsed_slice_dims(), ",").c_str());
+        slice_sizes.size(),
+        StrJoin(gather_dim_numbers.offset_dims(), ",").c_str(),
+        StrJoin(gather_dim_numbers.collapsed_slice_dims(), ",").c_str());
   }
 
   for (int i = 0; i < slice_sizes.size(); i++) {
@@ -2736,13 +2739,13 @@ Status ValidateScatterDimensionNumbers(
   if (!absl::c_is_sorted(dim_numbers.update_window_dims())) {
     return InvalidArgument(
         "update_window_dims in scatter op must be sorted; got: %s.",
-        Join(dim_numbers.update_window_dims(), ", ").c_str());
+        StrJoin(dim_numbers.update_window_dims(), ", ").c_str());
   }
   if (absl::c_adjacent_find(dim_numbers.update_window_dims()) !=
       dim_numbers.update_window_dims().end()) {
     return InvalidArgument(
         "update_window_dims in scatter op must not repeat; got: %s.",
-        Join(dim_numbers.update_window_dims(), ", ").c_str());
+        StrJoin(dim_numbers.update_window_dims(), ", ").c_str());
   }
   const int64 updates_rank = ShapeUtil::Rank(updates_shape);
   for (int64 window_dim : dim_numbers.update_window_dims()) {
@@ -2758,13 +2761,13 @@ Status ValidateScatterDimensionNumbers(
   if (!absl::c_is_sorted(dim_numbers.inserted_window_dims())) {
     return InvalidArgument(
         "inserted_window_dims in scatter op must be sorted; got: %s.",
-        Join(dim_numbers.inserted_window_dims(), ", ").c_str());
+        StrJoin(dim_numbers.inserted_window_dims(), ", ").c_str());
   }
   if (absl::c_adjacent_find(dim_numbers.inserted_window_dims()) !=
       dim_numbers.inserted_window_dims().end()) {
     return InvalidArgument(
         "inserted_window_dims in scatter op must not repeat; got: %s.",
-        Join(dim_numbers.inserted_window_dims(), ", ").c_str());
+        StrJoin(dim_numbers.inserted_window_dims(), ", ").c_str());
   }
   for (int64 inserted_dim : dim_numbers.inserted_window_dims()) {
     if (inserted_dim < 0 || inserted_dim >= operand_shape.dimensions_size()) {
@@ -2806,7 +2809,7 @@ Status ValidateScatterDimensionNumbers(
     return InvalidArgument(
         "Repeated dimensions not allowed in scatter_dims_to_operand_dims; "
         "got: %s.",
-        Join(dim_numbers.scatter_dims_to_operand_dims(), ", ").c_str());
+        StrJoin(dim_numbers.scatter_dims_to_operand_dims(), ", ").c_str());
   }
 
   return Status::OK();