ARROW-17803: [C++] Use [[nodiscard]] (apache#14193)

C++17 supports the standard attribute `[[nodiscard]]`, use that instead of the clang-specific `__attribute__((warn_unused_result))`.

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>

cpp/src/arrow/array/array_base.h

@@ -207,7 +207,7 @@ class ARROW_EXPORT Array {
  private:
   ARROW_DISALLOW_COPY_AND_ASSIGN(Array);
 
-  ARROW_EXPORT friend void PrintTo(const Array& x, std::ostream* os);
+  ARROW_FRIEND_EXPORT friend void PrintTo(const Array& x, std::ostream* os);
 };
 
 static inline std::ostream& operator<<(std::ostream& os, const Array& x) {

cpp/src/arrow/compare.h

@@ -92,54 +92,54 @@ class EqualOptions {
 };
 
 /// Returns true if the arrays are exactly equal
-bool ARROW_EXPORT ArrayEquals(const Array& left, const Array& right,
+ARROW_EXPORT bool ArrayEquals(const Array& left, const Array& right,
                               const EqualOptions& = EqualOptions::Defaults());
 
 /// Returns true if the arrays are approximately equal. For non-floating point
 /// types, this is equivalent to ArrayEquals(left, right)
-bool ARROW_EXPORT ArrayApproxEquals(const Array& left, const Array& right,
+ARROW_EXPORT bool ArrayApproxEquals(const Array& left, const Array& right,
                                     const EqualOptions& = EqualOptions::Defaults());
 
 /// Returns true if indicated equal-length segment of arrays are exactly equal
-bool ARROW_EXPORT ArrayRangeEquals(const Array& left, const Array& right,
+ARROW_EXPORT bool ArrayRangeEquals(const Array& left, const Array& right,
                                    int64_t start_idx, int64_t end_idx,
                                    int64_t other_start_idx,
                                    const EqualOptions& = EqualOptions::Defaults());
 
 /// Returns true if indicated equal-length segment of arrays are approximately equal
-bool ARROW_EXPORT ArrayRangeApproxEquals(const Array& left, const Array& right,
+ARROW_EXPORT bool ArrayRangeApproxEquals(const Array& left, const Array& right,
                                          int64_t start_idx, int64_t end_idx,
                                          int64_t other_start_idx,
                                          const EqualOptions& = EqualOptions::Defaults());
 
-bool ARROW_EXPORT TensorEquals(const Tensor& left, const Tensor& right,
+ARROW_EXPORT bool TensorEquals(const Tensor& left, const Tensor& right,
                                const EqualOptions& = EqualOptions::Defaults());
 
 /// EXPERIMENTAL: Returns true if the given sparse tensors are exactly equal
-bool ARROW_EXPORT SparseTensorEquals(const SparseTensor& left, const SparseTensor& right,
+ARROW_EXPORT bool SparseTensorEquals(const SparseTensor& left, const SparseTensor& right,
                                      const EqualOptions& = EqualOptions::Defaults());
 
 /// Returns true if the type metadata are exactly equal
 /// \param[in] left a DataType
 /// \param[in] right a DataType
 /// \param[in] check_metadata whether to compare KeyValueMetadata for child
 /// fields
-bool ARROW_EXPORT TypeEquals(const DataType& left, const DataType& right,
+ARROW_EXPORT bool TypeEquals(const DataType& left, const DataType& right,
                              bool check_metadata = true);
 
 /// Returns true if scalars are equal
 /// \param[in] left a Scalar
 /// \param[in] right a Scalar
 /// \param[in] options comparison options
-bool ARROW_EXPORT ScalarEquals(const Scalar& left, const Scalar& right,
+ARROW_EXPORT bool ScalarEquals(const Scalar& left, const Scalar& right,
                                const EqualOptions& options = EqualOptions::Defaults());
 
 /// Returns true if scalars are approximately equal
 /// \param[in] left a Scalar
 /// \param[in] right a Scalar
 /// \param[in] options comparison options
-bool ARROW_EXPORT
-ScalarApproxEquals(const Scalar& left, const Scalar& right,
-                   const EqualOptions& options = EqualOptions::Defaults());
+ARROW_EXPORT bool ScalarApproxEquals(
+    const Scalar& left, const Scalar& right,
+    const EqualOptions& options = EqualOptions::Defaults());
 
 }  // namespace arrow

cpp/src/arrow/compute/exec.h

@@ -246,13 +246,13 @@ struct ARROW_EXPORT ExecBatch {
   }
 
   std::string ToString() const;
-
-  ARROW_EXPORT friend void PrintTo(const ExecBatch&, std::ostream*);
 };
 
 inline bool operator==(const ExecBatch& l, const ExecBatch& r) { return l.Equals(r); }
 inline bool operator!=(const ExecBatch& l, const ExecBatch& r) { return !l.Equals(r); }
 
+ARROW_EXPORT void PrintTo(const ExecBatch&, std::ostream*);
+
 struct ExecValue {
   ArraySpan array = {};
   const Scalar* scalar = NULLPTR;

cpp/src/arrow/compute/exec/expression.h

@@ -130,14 +130,14 @@ class ARROW_EXPORT Expression {
   using Impl = std::variant<Datum, Parameter, Call>;
   std::shared_ptr<Impl> impl_;
 
-  ARROW_EXPORT friend bool Identical(const Expression& l, const Expression& r);
-
-  ARROW_EXPORT friend void PrintTo(const Expression&, std::ostream*);
+  ARROW_FRIEND_EXPORT friend bool Identical(const Expression& l, const Expression& r);
 };
 
 inline bool operator==(const Expression& l, const Expression& r) { return l.Equals(r); }
 inline bool operator!=(const Expression& l, const Expression& r) { return !l.Equals(r); }
 
+ARROW_EXPORT void PrintTo(const Expression&, std::ostream*);
+
 // Factories
 
 ARROW_EXPORT

cpp/src/arrow/datum.h

@@ -215,10 +215,10 @@ struct ARROW_EXPORT Datum {
   bool operator!=(const Datum& other) const { return !Equals(other); }
 
   std::string ToString() const;
-
-  ARROW_EXPORT friend void PrintTo(const Datum&, std::ostream*);
 };
 
+ARROW_EXPORT void PrintTo(const Datum&, std::ostream*);
+
 ARROW_EXPORT std::string ToString(Datum::Kind kind);
 
 }  // namespace arrow

cpp/src/arrow/device.h

@@ -226,7 +226,7 @@ class ARROW_EXPORT CPUMemoryManager : public MemoryManager {
   MemoryPool* pool_;
 
   friend std::shared_ptr<MemoryManager> CPUDevice::memory_manager(MemoryPool* pool);
-  friend ARROW_EXPORT std::shared_ptr<MemoryManager> default_cpu_memory_manager();
+  ARROW_FRIEND_EXPORT friend std::shared_ptr<MemoryManager> default_cpu_memory_manager();
 };
 
 /// \brief Return the default CPU MemoryManager instance

cpp/src/arrow/filesystem/mockfs.h

@@ -38,7 +38,7 @@ struct MockDirInfo {
     return mtime == other.mtime && full_path == other.full_path;
   }
 
-  friend ARROW_EXPORT std::ostream& operator<<(std::ostream&, const MockDirInfo&);
+  ARROW_FRIEND_EXPORT friend std::ostream& operator<<(std::ostream&, const MockDirInfo&);
 };
 
 struct MockFileInfo {
@@ -50,7 +50,7 @@ struct MockFileInfo {
     return mtime == other.mtime && full_path == other.full_path && data == other.data;
   }
 
-  friend ARROW_EXPORT std::ostream& operator<<(std::ostream&, const MockFileInfo&);
+  ARROW_FRIEND_EXPORT friend std::ostream& operator<<(std::ostream&, const MockFileInfo&);
 };
 
 /// A mock FileSystem implementation that holds its contents in memory.

cpp/src/arrow/io/hdfs.h

@@ -278,7 +278,7 @@ class ARROW_EXPORT HdfsOutputStream : public OutputStream {
   ARROW_DISALLOW_COPY_AND_ASSIGN(HdfsOutputStream);
 };
 
-Status ARROW_EXPORT HaveLibHdfs();
+ARROW_EXPORT Status HaveLibHdfs();
 
 }  // namespace io
 }  // namespace arrow

cpp/src/arrow/io/hdfs_internal.h

@@ -215,7 +215,7 @@ struct LibHdfsShim {
 };
 
 // TODO(wesm): Remove these exports when we are linking statically
-Status ARROW_EXPORT ConnectLibHdfs(LibHdfsShim** driver);
+ARROW_EXPORT Status ConnectLibHdfs(LibHdfsShim** driver);
 
 }  // namespace internal
 }  // namespace io

cpp/src/arrow/result.h

@@ -94,7 +94,7 @@ ARROW_EXPORT void InvalidValueOrDie(const Status& st);
 ///   arrow::Result<int> CalculateFoo();
 /// ```
 template <class T>
-class ARROW_MUST_USE_TYPE Result : public util::EqualityComparable<Result<T>> {
+class [[nodiscard]] Result : public util::EqualityComparable<Result<T>> {
   template <typename U>
   friend class Result;
 

cpp/src/arrow/scalar.h

@@ -100,8 +100,6 @@ struct ARROW_EXPORT Scalar : public std::enable_shared_from_this<Scalar>,
   // TODO(bkietz) add compute::CastOptions
   Result<std::shared_ptr<Scalar>> CastTo(std::shared_ptr<DataType> to) const;
 
-  ARROW_EXPORT friend void PrintTo(const Scalar& scalar, std::ostream* os);
-
   /// \brief Apply the ScalarVisitor::Visit() method specialized to the scalar type
   Status Accept(ScalarVisitor* visitor) const;
 
@@ -116,6 +114,8 @@ struct ARROW_EXPORT Scalar : public std::enable_shared_from_this<Scalar>,
       : type(std::move(type)), is_valid(is_valid) {}
 };
 
+ARROW_EXPORT void PrintTo(const Scalar& scalar, std::ostream* os);
+
 /// \defgroup concrete-scalar-classes Concrete Scalar subclasses
 ///
 /// @{

cpp/src/arrow/status.h

@@ -129,8 +129,8 @@ class ARROW_EXPORT StatusDetail {
 ///
 /// Additionally, if an error occurred, a specific error message is generally
 /// attached.
-class ARROW_MUST_USE_TYPE ARROW_EXPORT Status : public util::EqualityComparable<Status>,
-                                                public util::ToStringOstreamable<Status> {
+class ARROW_EXPORT [[nodiscard]] Status : public util::EqualityComparable<Status>,
+                                          public util::ToStringOstreamable<Status> {
  public:
   // Create a success status.
   Status() noexcept : state_(NULLPTR) {}

cpp/src/arrow/type.h

@@ -438,8 +438,6 @@ class ARROW_EXPORT Field : public detail::Fingerprintable,
   std::string ComputeFingerprint() const override;
   std::string ComputeMetadataFingerprint() const override;
 
-  ARROW_EXPORT friend void PrintTo(const Field& field, std::ostream* os);
-
   // Field name
   std::string name_;
 
@@ -455,6 +453,8 @@ class ARROW_EXPORT Field : public detail::Fingerprintable,
   ARROW_DISALLOW_COPY_AND_ASSIGN(Field);
 };
 
+ARROW_EXPORT void PrintTo(const Field& field, std::ostream* os);
+
 namespace detail {
 
 template <typename DERIVED, typename BASE, Type::type TYPE_ID, typename C_TYPE>
@@ -1886,10 +1886,10 @@ class ARROW_EXPORT FieldRef : public util::EqualityComparable<FieldRef> {
   void Flatten(std::vector<FieldRef> children);
 
   std::variant<FieldPath, std::string, std::vector<FieldRef>> impl_;
-
-  ARROW_EXPORT friend void PrintTo(const FieldRef& ref, std::ostream* os);
 };
 
+ARROW_EXPORT void PrintTo(const FieldRef& ref, std::ostream* os);
+
 // ----------------------------------------------------------------------
 // Schema
 
@@ -1997,12 +1997,12 @@ class ARROW_EXPORT Schema : public detail::Fingerprintable,
   std::string ComputeMetadataFingerprint() const override;
 
  private:
-  ARROW_EXPORT friend void PrintTo(const Schema& s, std::ostream* os);
-
   class Impl;
   std::unique_ptr<Impl> impl_;
 };
 
+ARROW_EXPORT void PrintTo(const Schema& s, std::ostream* os);
+
 ARROW_EXPORT
 std::string EndiannessToString(Endianness endianness);
 

cpp/src/arrow/type_fwd.h

@@ -519,16 +519,16 @@ std::shared_ptr<DataType> fixed_size_list(const std::shared_ptr<DataType>& value
                                           int32_t list_size);
 /// \brief Return a Duration instance (naming use _type to avoid namespace conflict with
 /// built in time classes).
-std::shared_ptr<DataType> ARROW_EXPORT duration(TimeUnit::type unit);
+ARROW_EXPORT std::shared_ptr<DataType> duration(TimeUnit::type unit);
 
 /// \brief Return a DayTimeIntervalType instance
-std::shared_ptr<DataType> ARROW_EXPORT day_time_interval();
+ARROW_EXPORT std::shared_ptr<DataType> day_time_interval();
 
 /// \brief Return a MonthIntervalType instance
-std::shared_ptr<DataType> ARROW_EXPORT month_interval();
+ARROW_EXPORT std::shared_ptr<DataType> month_interval();
 
 /// \brief Return a MonthDayNanoIntervalType instance
-std::shared_ptr<DataType> ARROW_EXPORT month_day_nano_interval();
+ARROW_EXPORT std::shared_ptr<DataType> month_day_nano_interval();
 
 /// \brief Create a TimestampType instance from its unit
 ARROW_EXPORT
@@ -541,36 +541,36 @@ std::shared_ptr<DataType> timestamp(TimeUnit::type unit, const std::string& time
 /// \brief Create a 32-bit time type instance
 ///
 /// Unit can be either SECOND or MILLI
-std::shared_ptr<DataType> ARROW_EXPORT time32(TimeUnit::type unit);
+ARROW_EXPORT std::shared_ptr<DataType> time32(TimeUnit::type unit);
 
 /// \brief Create a 64-bit time type instance
 ///
 /// Unit can be either MICRO or NANO
-std::shared_ptr<DataType> ARROW_EXPORT time64(TimeUnit::type unit);
+ARROW_EXPORT std::shared_ptr<DataType> time64(TimeUnit::type unit);
 
 /// \brief Create a StructType instance
-std::shared_ptr<DataType> ARROW_EXPORT
-struct_(const std::vector<std::shared_ptr<Field>>& fields);
+ARROW_EXPORT std::shared_ptr<DataType> struct_(
+    const std::vector<std::shared_ptr<Field>>& fields);
 
 /// \brief Create a RunLengthEncoded instance
 std::shared_ptr<DataType> ARROW_EXPORT run_length_encoded(
     std::shared_ptr<DataType> run_ends_type, std::shared_ptr<DataType> encoded_type);
 
 /// \brief Create a SparseUnionType instance
-std::shared_ptr<DataType> ARROW_EXPORT sparse_union(FieldVector child_fields,
+ARROW_EXPORT std::shared_ptr<DataType> sparse_union(FieldVector child_fields,
                                                     std::vector<int8_t> type_codes = {});
 /// \brief Create a SparseUnionType instance
-std::shared_ptr<DataType> ARROW_EXPORT
-sparse_union(const ArrayVector& children, std::vector<std::string> field_names = {},
-             std::vector<int8_t> type_codes = {});
+ARROW_EXPORT std::shared_ptr<DataType> sparse_union(
+    const ArrayVector& children, std::vector<std::string> field_names = {},
+    std::vector<int8_t> type_codes = {});
 
 /// \brief Create a DenseUnionType instance
-std::shared_ptr<DataType> ARROW_EXPORT dense_union(FieldVector child_fields,
+ARROW_EXPORT std::shared_ptr<DataType> dense_union(FieldVector child_fields,
                                                    std::vector<int8_t> type_codes = {});
 /// \brief Create a DenseUnionType instance
-std::shared_ptr<DataType> ARROW_EXPORT
-dense_union(const ArrayVector& children, std::vector<std::string> field_names = {},
-            std::vector<int8_t> type_codes = {});
+ARROW_EXPORT std::shared_ptr<DataType> dense_union(
+    const ArrayVector& children, std::vector<std::string> field_names = {},
+    std::vector<int8_t> type_codes = {});
 
 /// \brief Create a DictionaryType instance
 /// \param[in] index_type the type of the dictionary indices (must be
@@ -596,9 +596,9 @@ std::shared_ptr<DataType> dictionary(const std::shared_ptr<DataType>& index_type
 /// \param type the field value type
 /// \param nullable whether the values are nullable, default true
 /// \param metadata any custom key-value metadata, default null
-std::shared_ptr<Field> ARROW_EXPORT
-field(std::string name, std::shared_ptr<DataType> type, bool nullable = true,
-      std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
+ARROW_EXPORT std::shared_ptr<Field> field(
+    std::string name, std::shared_ptr<DataType> type, bool nullable = true,
+    std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
 
 /// \brief Create a Field instance with metadata
 ///
@@ -607,9 +607,9 @@ field(std::string name, std::shared_ptr<DataType> type, bool nullable = true,
 /// \param name the field name
 /// \param type the field value type
 /// \param metadata any custom key-value metadata
-std::shared_ptr<Field> ARROW_EXPORT
-field(std::string name, std::shared_ptr<DataType> type,
-      std::shared_ptr<const KeyValueMetadata> metadata);
+ARROW_EXPORT std::shared_ptr<Field> field(
+    std::string name, std::shared_ptr<DataType> type,
+    std::shared_ptr<const KeyValueMetadata> metadata);
 
 /// \brief Create a Schema instance
 ///