Fix leaked host objects from moving out of unique_ptr::release()

Several places called release() on a std::unique_ptr and then moved
from the raw pointer it returned, e.g. std::move(*ptr.release()) or
ptr.release()[0]. The device memory was moved out and freed normally,
but nothing deleted the small host-side object (rmm::device_buffer,
cuda::device_buffer, or cudf::column), so each call leaked it.

Move from *ptr instead so the unique_ptr keeps ownership and deletes
the moved-from object. This fixes the sites listed in NVIDIA#24926 plus the
same pattern in groupby argmin/argmax, the IO column_buffer, the JNI
list-overlap code, and the benchmark data generators.

Also add a note about this pattern to cpp/REVIEW_GUIDELINES.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: davidwendt

cpp/REVIEW_GUIDELINES.md

@@ -42,6 +42,7 @@
 - CUDA stream/event leaks or improper cleanup
 - Missing RAII or proper cleanup, including in exception paths
 - Raw owning pointers instead of `std::unique_ptr`, `std::shared_ptr`, `std::reference_wrapper`
+- Moving from the raw pointer returned by `std::unique_ptr::release()` (e.g. `std::move(*ptr.release())`, `ptr.release()[0]`, `auto p = contents.data.release();`) leaks the host object; use `std::move(*ptr)` instead. (`table::release()` and `device_uvector::release()` return owning values and are fine.)
 
 ### API Breaking Changes
 - C++ API changes without proper deprecation warnings

cpp/benchmarks/common/generate_input.cu

@@ -526,11 +526,8 @@ std::unique_ptr<cudf::column> create_random_utf8_string_column(data_profile cons
                     cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)),
                   0};
 
-  return cudf::make_strings_column(num_rows,
-                                   std::move(offsets),
-                                   chars.release(),
-                                   null_count,
-                                   std::move(*result_bitmask.release()));
+  return cudf::make_strings_column(
+    num_rows, std::move(offsets), chars.release(), null_count, std::move(*result_bitmask));
 }
 
 // Forward declarations for create_rand_col_fn
@@ -637,7 +634,7 @@ std::unique_ptr<cudf::column> create_random_column(data_profile const& profile,
                   0};
 
   return std::make_unique<cudf::column>(
-    dtype, num_rows, data.release(), std::move(*result_bitmask.release()), null_count);
+    dtype, num_rows, data.release(), std::move(*result_bitmask), null_count);
 }
 
 /**
@@ -729,7 +726,7 @@ std::unique_ptr<cudf::column> create_random_column<cudf::struct_view>(data_profi
       current_child += children_to_adopt.size();
 
       *current_parent = cudf::make_structs_column(
-        num_rows, std::move(children_to_adopt), null_count, std::move(*null_mask.release()));
+        num_rows, std::move(children_to_adopt), null_count, std::move(*null_mask));
     }
 
     if (lvl == 1) {
@@ -817,7 +814,7 @@ std::unique_ptr<cudf::column> create_random_column<cudf::list_view>(data_profile
                                           std::move(offsets_column),
                                           std::move(current_child_column),
                                           null_count,
-                                          std::move(*null_mask.release()));
+                                          std::move(*null_mask));
 
     if (auto const cv = list_column->view();
         cudf::has_nonempty_nulls(cv, cudf::get_default_stream())) {
@@ -850,7 +847,7 @@ std::unique_ptr<cudf::column> create_distinct_rows_column(data_profile const& pr
     auto null_mask = valid_dist(engine, num_rows);
     auto [result_bitmask, null_count] =
       cudf::bools_to_mask(cudf::device_span<bool const>(null_mask), cudf::get_default_stream());
-    col->set_null_mask(std::move(*result_bitmask.release()), null_count);
+    col->set_null_mask(std::move(*result_bitmask), null_count);
   }
 
   return col;

cpp/benchmarks/io/text/multibyte_split.cpp

@@ -74,7 +74,7 @@ static cudf::string_scalar create_random_input(int32_t num_chars,
 
   // extract the chars from the returned strings column.
   auto input_column_contents = input_column->release();
-  auto chars_buffer          = input_column_contents.data.release();
+  auto chars_buffer          = std::move(input_column_contents.data);
 
   // turn the chars in to a string scalar.
   return cudf::string_scalar(std::move(*chars_buffer));

cpp/src/copying/copy_range.cu

@@ -184,7 +184,7 @@ std::unique_ptr<cudf::column> out_of_place_copy_range_dispatch::operator()<cudf:
   auto indices_column = std::make_unique<cudf::column>(
     new_indices.type(),
     new_indices.size(),
-    std::move(*(target_indices->release().data.release())),
+    std::move(*(target_indices->release().data)),
     cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr),
     0);
 
@@ -194,7 +194,7 @@ std::unique_ptr<cudf::column> out_of_place_copy_range_dispatch::operator()<cudf:
   // create column with keys_column and indices_column
   return make_dictionary_column(std::move(keys_column),
                                 std::move(indices_column),
-                                std::move(*(target_contents.null_mask.release())),
+                                std::move(*(target_contents.null_mask)),
                                 null_count);
 }
 

cpp/src/dictionary/detail/concatenate.cu

@@ -289,7 +289,7 @@ std::unique_ptr<column> concatenate(host_span<column_view const> columns,
   // finally, frankenstein that dictionary column together
   return make_dictionary_column(std::move(keys_column),
                                 std::move(indices_column),
-                                std::move(*(contents.null_mask.release())),
+                                std::move(*(contents.null_mask)),
                                 null_count);
 }
 

cpp/src/dictionary/dictionary_factories.cu

@@ -141,7 +141,7 @@ std::unique_ptr<column> make_dictionary_column(std::unique_ptr<column> keys,
     if (new_type == indices_type || cudf::size_of(new_type) == cudf::size_of(indices_type)) {
       return std::make_unique<column>(new_type,
                                       indices_size,
-                                      std::move(*(contents.data.release())),
+                                      std::move(*(contents.data)),
                                       cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED),
                                       0);
     }
@@ -150,10 +150,8 @@ std::unique_ptr<column> make_dictionary_column(std::unique_ptr<column> keys,
     return cudf::detail::cast(cast_view, new_type, stream, mr);
   }();
 
-  return make_dictionary_column(std::move(keys),
-                                std::move(indices_column),
-                                std::move(*(contents.null_mask.release())),
-                                null_count);
+  return make_dictionary_column(
+    std::move(keys), std::move(indices_column), std::move(*(contents.null_mask)), null_count);
 }
 
 }  // namespace cudf

cpp/src/groupby/sort/group_argmax.cu

@@ -46,7 +46,7 @@ std::unique_ptr<column> group_argmax(column_view const& values,
                  output.data()                       // result (must not overlap map)
   );
   auto null_count = indices_view.null_count();
-  auto null_mask  = indices->release().null_mask.release();
+  auto null_mask  = std::move(indices->release().null_mask);
   return std::make_unique<column>(std::move(output), std::move(*null_mask), null_count);
 }
 

cpp/src/groupby/sort/group_argmin.cu

@@ -48,7 +48,7 @@ std::unique_ptr<column> group_argmin(column_view const& values,
                  output.data()                       // result (must not overlap map)
   );
   auto null_count = indices_view.null_count();
-  auto null_mask  = indices->release().null_mask.release();
+  auto null_mask  = std::move(indices->release().null_mask);
   return std::make_unique<column>(std::move(output), std::move(*null_mask), null_count);
 }
 

cpp/src/interop/from_arrow_host_strings.cu

@@ -62,7 +62,7 @@ std::unique_ptr<column> from_arrow_string(
                              std::move(offsets_column),
                              std::move(chars),
                              null_count,
-                             std::move(*mask.release()));
+                             std::move(*mask));
 }
 
 constexpr int stringview_vector_idx = 1;

cpp/src/io/json/write_json.cu

@@ -383,7 +383,7 @@ std::unique_ptr<column> struct_to_strings(table_view const& strings_columns,
     num_rows,
     std::make_unique<cudf::column>(
       std::move(row_string_offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0),
-    std::move(chars_data.release()[0]),
+    std::move(*chars_data),
     0,
     cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED));
 }
@@ -546,7 +546,7 @@ std::unique_ptr<column> join_list_of_strings(lists_column_view const& lists_stri
     num_lists,
     std::make_unique<cudf::column>(
       std::move(row_string_offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0),
-    std::move(chars_data.release()[0]),
+    std::move(*chars_data),
     lists_strings.null_count(),
     cudf::detail::copy_bitmask(lists_strings.parent(), stream, mr));
 }