Fix a bunch of documentation warnings

Change-Id: I38e0c03c37eb7e922e07526754a1062a10f3ebc7

cpp/cmake_modules/SetupCxxFlags.cmake

@@ -72,8 +72,8 @@ if ("${UPPERCASE_BUILD_WARNING_LEVEL}" STREQUAL "CHECKIN")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Weverything -Wno-c++98-compat \
 -Wno-c++98-compat-pedantic -Wno-deprecated -Wno-weak-vtables -Wno-padded \
 -Wno-missing-field-initializers \
--Wno-unused-parameter -Wno-undef -Wno-documentation-deprecated-sync \
--Wno-shadow -Wno-switch-enum -Wno-documentation -Wno-exit-time-destructors \
+-Wno-unused-parameter -Wno-undef \
+-Wno-shadow -Wno-switch-enum -Wno-exit-time-destructors \
 -Wno-global-constructors -Wno-weak-template-vtables -Wno-undefined-reinterpret-cast \
 -Wno-implicit-fallthrough -Wno-old-style-cast -Wno-unreachable-code-return \
 -Wno-float-equal -Wno-missing-prototypes \

cpp/cmake_modules/ThirdpartyToolchain.cmake

@@ -126,6 +126,7 @@ endif()
 set(Boost_DEBUG TRUE)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_ADDITIONAL_VERSIONS
+  "1.65.0" "1.65"
   "1.64.0" "1.64"
   "1.63.0" "1.63"
   "1.62.0" "1.61"

cpp/src/arrow/array.cc

@@ -194,7 +194,8 @@ ListArray::ListArray(const std::shared_ptr<DataType>& type, int64_t length,
   SetData(internal_data);
 }
 
-Status ListArray::FromArrays(const Array& offsets, const Array& values, MemoryPool* pool,
+Status ListArray::FromArrays(const Array& offsets, const Array& values,
+                             MemoryPool* ARROW_ARG_UNUSED(pool),
                              std::shared_ptr<Array>* out) {
   if (ARROW_PREDICT_FALSE(offsets.length() == 0)) {
     return Status::Invalid("List offsets must have non-zero length");
@@ -433,13 +434,13 @@ Status Array::Accept(ArrayVisitor* visitor) const {
 namespace internal {
 
 struct ValidateVisitor {
-  Status Visit(const NullArray& array) { return Status::OK(); }
+  Status Visit(const NullArray&) { return Status::OK(); }
 
-  Status Visit(const PrimitiveArray& array) { return Status::OK(); }
+  Status Visit(const PrimitiveArray&) { return Status::OK(); }
 
-  Status Visit(const DecimalArray& array) { return Status::OK(); }
+  Status Visit(const DecimalArray&) { return Status::OK(); }
 
-  Status Visit(const BinaryArray& array) {
+  Status Visit(const BinaryArray&) {
     // TODO(wesm): what to do here?
     return Status::OK();
   }
@@ -581,7 +582,7 @@ class ArrayDataWrapper {
       : data_(data), out_(out) {}
 
   template <typename T>
-  Status Visit(const T& type) {
+  Status Visit(const T&) {
     using ArrayType = typename TypeTraits<T>::ArrayType;
     *out_ = std::make_shared<ArrayType>(data_);
     return Status::OK();

cpp/src/arrow/array.h

@@ -674,7 +674,7 @@ ARROW_EXPORT
 Status ValidateArray(const Array& array);
 
 #ifndef ARROW_NO_DEPRECATED_API
-// \deprecated Since 0.7.0
+// \note Deprecated since 0.7.0
 
 /// Create new arrays for logical types that are backed by primitive arrays.
 ARROW_EXPORT

cpp/src/arrow/compare.cc

@@ -584,7 +584,7 @@ class TypeEqualsVisitor {
   typename std::enable_if<std::is_base_of<NoExtraMeta, T>::value ||
                               std::is_base_of<PrimitiveCType, T>::value,
                           Status>::type
-  Visit(const T& type) {
+  Visit(const T&) {
     result_ = true;
     return Status::OK();
   }

cpp/src/arrow/compute/cast.h

@@ -46,11 +46,11 @@ Status GetCastFunction(const DataType& in_type, const std::shared_ptr<DataType>&
                        const CastOptions& options, std::unique_ptr<UnaryKernel>* kernel);
 
 /// \brief Cast from one array type to another
-/// \param[in] context
-/// \param[in] array
-/// \param[in] to_type
-/// \param[in] options
-/// \param[out] out
+/// \param[in] context the FunctionContext
+/// \param[in] array array to cast
+/// \param[in] to_type type to cast to
+/// \param[in] options casting options
+/// \param[out] out resulting array
 ///
 /// \since 0.7.0
 /// \note API not yet finalized

cpp/src/arrow/io/file.h

@@ -86,7 +86,7 @@ class ARROW_EXPORT ReadableFile : public RandomAccessFile {
   /// \param[in] pool a MemoryPool for memory allocations
   /// \param[out] file ReadableFile instance
   /// Open file with one's own memory pool for memory allocations
-  static Status Open(const std::string& path, MemoryPool* memory_pool,
+  static Status Open(const std::string& path, MemoryPool* pool,
                      std::shared_ptr<ReadableFile>* file);
 
   Status Close() override;

cpp/src/arrow/ipc/message.h

@@ -82,11 +82,10 @@ class ARROW_EXPORT Message {
   static Status ReadFrom(const std::shared_ptr<Buffer>& metadata, io::InputStream* stream,
                          std::unique_ptr<Message>* out);
 
-  /// \brief Write length-prefixed metadata and body to output stream
+  /// \brief Return true if message type and contents are equal
   ///
-  /// \param[in] file output stream to write to
-  /// \param[out] output_length the number of bytes written
-  /// \return Status
+  /// \param other another message
+  /// \return true if contents equal
   bool Equals(const Message& other) const;
 
   /// \brief the Message metadata

cpp/src/arrow/ipc/reader.h

@@ -54,8 +54,8 @@ class ARROW_EXPORT RecordBatchStreamReader : public RecordBatchReader {
 
   /// Create batch reader from generic MessageReader
   ///
-  /// \param(in) message_reader a MessageReader implementation
-  /// \param(out) out the created RecordBatchReader object
+  /// \param[in] message_reader a MessageReader implementation
+  /// \param[out] out the created RecordBatchReader object
   /// \return Status
   static Status Open(std::unique_ptr<MessageReader> message_reader,
                      std::shared_ptr<RecordBatchReader>* out);
@@ -72,9 +72,9 @@ class ARROW_EXPORT RecordBatchStreamReader : public RecordBatchReader {
 
   /// \brief Record batch stream reader from InputStream
   ///
-  /// \param(in) stream an input stream instance. Must stay alive throughout
+  /// \param[in] stream an input stream instance. Must stay alive throughout
   /// lifetime of stream reader
-  /// \param(out) out the created RecordBatchStreamReader object
+  /// \param[out] out the created RecordBatchStreamReader object
   /// \return Status
   static Status Open(io::InputStream* stream, std::shared_ptr<RecordBatchReader>* out);
 
@@ -112,8 +112,8 @@ class ARROW_EXPORT RecordBatchFileReader {
   /// metadata footer). The metadata must have been written with memory offsets
   /// relative to the start of the containing file
   ///
-  /// @param file: the data source
-  /// @param footer_offset: the position of the end of the Arrow "file"
+  /// @param file the data source
+  /// @param footer_offset the position of the end of the Arrow "file"
   static Status Open(io::RandomAccessFile* file, int64_t footer_offset,
                      std::shared_ptr<RecordBatchFileReader>* reader);
 
@@ -138,8 +138,8 @@ class ARROW_EXPORT RecordBatchFileReader {
   /// Read a record batch from the file. Does not copy memory if the input
   /// source supports zero-copy.
   ///
-  /// \param(in) i the index of the record batch to return
-  /// \param(out) batch the read batch
+  /// \param[in] i the index of the record batch to return
+  /// \param[out] batch the read batch
   /// \return Status
   Status ReadRecordBatch(int i, std::shared_ptr<RecordBatch>* batch);
 
@@ -165,20 +165,19 @@ Status ReadSchema(io::InputStream* stream, std::shared_ptr<Schema>* out);
 /// Read record batch as encapsulated IPC message with metadata size prefix and
 /// header
 ///
-/// \param(in) schema the record batch schema
-/// \param(in) offset the file location of the start of the message
-/// \param(in) file the file where the batch is located
-/// \param(out) out the read record batch
+/// \param[in] schema the record batch schema
+/// \param[in] stream the file where the batch is located
+/// \param[out] out the read record batch
 ARROW_EXPORT
 Status ReadRecordBatch(const std::shared_ptr<Schema>& schema, io::InputStream* stream,
                        std::shared_ptr<RecordBatch>* out);
 
 /// \brief Read record batch from file given metadata and schema
 ///
-/// \param(in) metadata a Message containing the record batch metadata
-/// \param(in) schema the record batch schema
-/// \param(in) file a random access file
-/// \param(out) out the read record batch
+/// \param[in] metadata a Message containing the record batch metadata
+/// \param[in] schema the record batch schema
+/// \param[in] file a random access file
+/// \param[out] out the read record batch
 ARROW_EXPORT
 Status ReadRecordBatch(const Buffer& metadata, const std::shared_ptr<Schema>& schema,
                        io::RandomAccessFile* file, std::shared_ptr<RecordBatch>* out);
@@ -186,7 +185,7 @@ Status ReadRecordBatch(const Buffer& metadata, const std::shared_ptr<Schema>& sc
 /// \brief Read record batch from fully encapulated Message
 ///
 /// \param[in] message a message instance containing metadata and body
-/// \param[in] schema
+/// \param[in] schema the record batch schema
 /// \param[out] out the resulting RecordBatch
 /// \return Status
 ARROW_EXPORT
@@ -195,11 +194,11 @@ Status ReadRecordBatch(const Message& message, const std::shared_ptr<Schema>& sc
 
 /// Read record batch from file given metadata and schema
 ///
-/// \param(in) metadata a Message containing the record batch metadata
-/// \param(in) schema the record batch schema
-/// \param(in) file a random access file
-/// \param(in) max_recursion_depth the maximum permitted nesting depth
-/// \param(out) out the read record batch
+/// \param[in] metadata a Message containing the record batch metadata
+/// \param[in] schema the record batch schema
+/// \param[in] file a random access file
+/// \param[in] max_recursion_depth the maximum permitted nesting depth
+/// \param[out] out the read record batch
 ARROW_EXPORT
 Status ReadRecordBatch(const Buffer& metadata, const std::shared_ptr<Schema>& schema,
                        int max_recursion_depth, io::RandomAccessFile* file,
@@ -207,9 +206,9 @@ Status ReadRecordBatch(const Buffer& metadata, const std::shared_ptr<Schema>& sc
 
 /// EXPERIMENTAL: Read arrow::Tensor as encapsulated IPC message in file
 ///
-/// \param(in) offset the file location of the start of the message
-/// \param(in) file the file where the batch is located
-/// \param(out) out the read tensor
+/// \param[in] offset the file location of the start of the message
+/// \param[in] file the file where the batch is located
+/// \param[out] out the read tensor
 ARROW_EXPORT
 Status ReadTensor(int64_t offset, io::RandomAccessFile* file,
                   std::shared_ptr<Tensor>* out);

cpp/src/arrow/ipc/writer.h

@@ -61,7 +61,7 @@ class ARROW_EXPORT RecordBatchWriter {
   virtual Status WriteRecordBatch(const RecordBatch& batch, bool allow_64bit = false) = 0;
 
   /// \brief Write possibly-chunked table by creating sequence of record batches
-  /// \param[in] table
+  /// \param[in] table table to write
   /// \return Status
   Status WriteTable(const Table& table);
 
@@ -87,9 +87,9 @@ class ARROW_EXPORT RecordBatchStreamWriter : public RecordBatchWriter {
   /// Create a new writer from stream sink and schema. User is responsible for
   /// closing the actual OutputStream.
   ///
-  /// \param(in) sink output stream to write to
-  /// \param(in) schema the schema of the record batches to be written
-  /// \param(out) out the created stream writer
+  /// \param[in] sink output stream to write to
+  /// \param[in] schema the schema of the record batches to be written
+  /// \param[out] out the created stream writer
   /// \return Status
   static Status Open(io::OutputStream* sink, const std::shared_ptr<Schema>& schema,
                      std::shared_ptr<RecordBatchWriter>* out);
@@ -121,9 +121,9 @@ class ARROW_EXPORT RecordBatchFileWriter : public RecordBatchStreamWriter {
 
   /// Create a new writer from stream sink and schema
   ///
-  /// \param(in) sink output stream to write to
-  /// \param(in) schema the schema of the record batches to be written
-  /// \param(out) out the created stream writer
+  /// \param[in] sink output stream to write to
+  /// \param[in] schema the schema of the record batches to be written
+  /// \param[out] out the created stream writer
   /// \return Status
   static Status Open(io::OutputStream* sink, const std::shared_ptr<Schema>& schema,
                      std::shared_ptr<RecordBatchWriter>* out);
@@ -155,13 +155,13 @@ class ARROW_EXPORT RecordBatchFileWriter : public RecordBatchStreamWriter {
 /// to the end of the body and end of the metadata / data header (suffixed by
 /// the header size) is returned in out-variables
 ///
-/// \param(in) buffer_start_offset the start offset to use in the buffer metadata,
+/// \param[in] buffer_start_offset the start offset to use in the buffer metadata,
 /// default should be 0
-/// \param(in) allow_64bit permit field lengths exceeding INT32_MAX. May not be
+/// \param[in] allow_64bit permit field lengths exceeding INT32_MAX. May not be
 /// readable by other Arrow implementations
-/// \param(out) metadata_length: the size of the length-prefixed flatbuffer
+/// \param[out] metadata_length the size of the length-prefixed flatbuffer
 /// including padding to a 64-byte boundary
-/// \param(out) body_length: the size of the contiguous buffer block plus
+/// \param[out] body_length the size of the contiguous buffer block plus
 /// padding bytes
 /// \return Status
 ///
@@ -198,7 +198,7 @@ Status SerializeRecordBatch(const RecordBatch& batch, MemoryPool* pool,
 /// \brief Serialize schema using stream writer as a sequence of one or more
 /// IPC messages
 ///
-/// \param[in] scheam the schema to write
+/// \param[in] schema the schema to write
 /// \param[in] pool a MemoryPool to allocate memory from
 /// \param[out] out the serialized schema
 /// \return Status

cpp/src/arrow/pretty_print.cc

@@ -199,7 +199,7 @@ class ArrayPrinter : public PrettyPrinter {
     }
   }
 
-  Status Visit(const NullArray& array) { return Status::OK(); }
+  Status Visit(const NullArray&) { return Status::OK(); }
 
   template <typename T>
   typename std::enable_if<std::is_base_of<PrimitiveArray, T>::value ||
@@ -213,7 +213,7 @@ class ArrayPrinter : public PrettyPrinter {
     return Status::OK();
   }
 
-  Status Visit(const IntervalArray& array) { return Status::NotImplemented("interval"); }
+  Status Visit(const IntervalArray&) { return Status::NotImplemented("interval"); }
 
   Status WriteValidityBitmap(const Array& array);
 

cpp/src/arrow/python/arrow_to_python.h

@@ -54,7 +54,7 @@ Status ReadSerializedObject(io::RandomAccessFile* src, SerializedPyObject* out);
 /// _serialize_callback method for serialization and a _deserialize_callback
 /// method for deserialization. If context is None, no custom serialization
 /// will be attempted.
-/// \param[in] object
+/// \param[in] object object to deserialize
 /// \param[in] base a Python object holding the underlying data that any NumPy
 /// arrays will reference, to avoid premature deallocation
 /// \param[out] out the returned object

cpp/src/arrow/table.h

@@ -113,7 +113,7 @@ class ARROW_EXPORT Column {
 /// sequence of fields, each a contiguous Arrow array
 class ARROW_EXPORT RecordBatch {
  public:
-  /// \param[in] schema
+  /// \param[in] schema The record batch schema
   /// \param[in] num_rows length of fields in the record batch. Each array
   /// should have the same length as num_rows
   /// \param[in] columns the record batch fields as vector of arrays
@@ -209,16 +209,16 @@ class ARROW_EXPORT Table {
  public:
   /// \brief Construct Table from schema and columns
   /// If columns is zero-length, the table's number of rows is zero
-  /// \param schema
-  /// \param columns
-  /// \param number of rows in table, -1 (default) to infer from columns
+  /// \param schema The table schema (column types)
+  /// \param columns The table's columns
+  /// \param num_rows number of rows in table, -1 (default) to infer from columns
   Table(const std::shared_ptr<Schema>& schema,
         const std::vector<std::shared_ptr<Column>>& columns, int64_t num_rows = -1);
 
   /// \brief Construct Table from schema and arrays
-  /// \param schema
-  /// \param arrays
-  /// \param number of rows in table, -1 (default) to infer from columns
+  /// \param schema The table schema (column types)
+  /// \param arrays The table's columns as arrays
+  /// \param num_rows number of rows in table, -1 (default) to infer from columns
   Table(const std::shared_ptr<Schema>& schema,
         const std::vector<std::shared_ptr<Array>>& arrays, int64_t num_rows = -1);
 
@@ -231,7 +231,7 @@ class ARROW_EXPORT Table {
   /// \return the table's schema
   std::shared_ptr<Schema> schema() const { return schema_; }
 
-  /// \param[i] i column index, does not boundscheck
+  /// \param[in] i column index, does not boundscheck
   /// \return the i-th column
   std::shared_ptr<Column> column(int i) const { return columns_[i]; }
 
@@ -283,7 +283,7 @@ class ARROW_EXPORT RecordBatchReader {
   /// Read the next record batch in the stream. Return nullptr for batch when
   /// reaching end of stream
   ///
-  /// \param(out) batch the next loaded batch, nullptr at end of stream
+  /// \param[out] batch the next loaded batch, nullptr at end of stream
   /// \return Status
   virtual Status ReadNext(std::shared_ptr<RecordBatch>* batch) = 0;
 

cpp/src/arrow/type-test.cc

@@ -68,8 +68,7 @@ TEST(TestField, TestAddMetadata) {
       new KeyValueMetadata({"foo", "bar"}, {"bizz", "buzz"}));
   auto f0 = field("f0", int32());
   auto f1 = field("f0", int32(), true, metadata);
-  std::shared_ptr<Field> f2;
-  ASSERT_OK(f0->AddMetadata(metadata, &f2));
+  std::shared_ptr<Field> f2 = f0->AddMetadata(metadata);
 
   ASSERT_FALSE(f2->Equals(*f0));
   ASSERT_TRUE(f2->Equals(*f1));
@@ -184,8 +183,7 @@ TEST_F(TestSchema, TestAddMetadata) {
   auto metadata = std::shared_ptr<KeyValueMetadata>(
       new KeyValueMetadata({"foo", "bar"}, {"bizz", "buzz"}));
   auto schema = std::make_shared<Schema>(fields);
-  std::shared_ptr<Schema> new_schema;
-  ASSERT_OK(schema->AddMetadata(metadata, &new_schema));
+  std::shared_ptr<Schema> new_schema = schema->AddMetadata(metadata);
   ASSERT_TRUE(metadata->Equals(*new_schema->metadata()));
 
   // Not copied

cpp/src/arrow/type.cc

@@ -36,12 +36,16 @@ std::shared_ptr<Field> Field::AddMetadata(
   return std::make_shared<Field>(name_, type_, nullable_, metadata);
 }
 
+#ifndef ARROW_NO_DEPRECATED_API
+
 Status Field::AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
                           std::shared_ptr<Field>* out) const {
   *out = AddMetadata(metadata);
   return Status::OK();
 }
 
+#endif
+
 std::shared_ptr<Field> Field::RemoveMetadata() const {
   return std::make_shared<Field>(name_, type_, nullable_);
 }
@@ -307,12 +311,16 @@ std::shared_ptr<Schema> Schema::AddMetadata(
   return std::make_shared<Schema>(fields_, metadata);
 }
 
+#ifndef ARROW_NO_DEPRECATED_API
+
 Status Schema::AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
                            std::shared_ptr<Schema>* out) const {
   *out = AddMetadata(metadata);
   return Status::OK();
 }
 
+#endif
+
 std::shared_ptr<const KeyValueMetadata> Schema::metadata() const { return metadata_; }
 
 std::shared_ptr<Schema> Schema::RemoveMetadata() const {

cpp/src/arrow/type.h

@@ -227,9 +227,11 @@ class ARROW_EXPORT Field {
 
   std::shared_ptr<const KeyValueMetadata> metadata() const { return metadata_; }
 
-  /// \deprecated
+#ifndef ARROW_NO_DEPRECATED_API
+  /// \note Deprecated since 0.8.0
   Status AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
                      std::shared_ptr<Field>* out) const;
+#endif
 
   std::shared_ptr<Field> AddMetadata(
       const std::shared_ptr<const KeyValueMetadata>& metadata) const;
@@ -749,9 +751,11 @@ class ARROW_EXPORT Schema {
                   std::shared_ptr<Schema>* out) const;
   Status RemoveField(int i, std::shared_ptr<Schema>* out) const;
 
-  /// \deprecated
+#ifndef ARROW_NO_DEPRECATED_API
+  /// \note Deprecated since 0.8.0
   Status AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
                      std::shared_ptr<Schema>* out) const;
+#endif
 
   /// \brief Replace key-value metadata with new metadata
   ///

cpp/src/arrow/util/compression_brotli.cc

@@ -25,6 +25,7 @@
 #include <brotli/types.h>
 
 #include "arrow/status.h"
+#include "arrow/util/macros.h"
 
 namespace arrow {
 
@@ -41,7 +42,8 @@ Status BrotliCodec::Decompress(int64_t input_len, const uint8_t* input,
   return Status::OK();
 }
 
-int64_t BrotliCodec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
+int64_t BrotliCodec::MaxCompressedLen(int64_t input_len,
+                                      const uint8_t* ARROW_ARG_UNUSED(input)) {
   return BrotliEncoderMaxCompressedSize(input_len);
 }
 

cpp/src/arrow/util/compression_lz4.cc

@@ -22,6 +22,7 @@
 #include <lz4.h>
 
 #include "arrow/status.h"
+#include "arrow/util/macros.h"
 
 namespace arrow {
 
@@ -39,7 +40,8 @@ Status Lz4Codec::Decompress(int64_t input_len, const uint8_t* input, int64_t out
   return Status::OK();
 }
 
-int64_t Lz4Codec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
+int64_t Lz4Codec::MaxCompressedLen(int64_t input_len,
+                                   const uint8_t* ARROW_ARG_UNUSED(input)) {
   return LZ4_compressBound(static_cast<int>(input_len));
 }
 

cpp/src/arrow/util/compression_snappy.cc

@@ -33,7 +33,8 @@ namespace arrow {
 // Snappy implementation
 
 Status SnappyCodec::Decompress(int64_t input_len, const uint8_t* input,
-                               int64_t output_len, uint8_t* output_buffer) {
+                               int64_t ARROW_ARG_UNUSED(output_len),
+                               uint8_t* output_buffer) {
   if (!snappy::RawUncompress(reinterpret_cast<const char*>(input),
                              static_cast<size_t>(input_len),
                              reinterpret_cast<char*>(output_buffer))) {
@@ -42,12 +43,14 @@ Status SnappyCodec::Decompress(int64_t input_len, const uint8_t* input,
   return Status::OK();
 }
 
-int64_t SnappyCodec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
+int64_t SnappyCodec::MaxCompressedLen(int64_t input_len,
+                                      const uint8_t* ARROW_ARG_UNUSED(input)) {
   return snappy::MaxCompressedLength(input_len);
 }
 
 Status SnappyCodec::Compress(int64_t input_len, const uint8_t* input,
-                             int64_t output_buffer_len, uint8_t* output_buffer,
+                             int64_t ARROW_ARG_UNUSED(output_buffer_len),
+                             uint8_t* output_buffer,
                              int64_t* output_length) {
   size_t output_len;
   snappy::RawCompress(reinterpret_cast<const char*>(input),

cpp/src/arrow/util/compression_zlib.cc

@@ -165,7 +165,8 @@ class GZipCodec::GZipCodecImpl {
     return Status::OK();
   }
 
-  int64_t MaxCompressedLen(int64_t input_length, const uint8_t* input) {
+  int64_t MaxCompressedLen(int64_t input_length,
+                           const uint8_t* ARROW_ARG_UNUSED(input)) {
     // Most be in compression mode
     if (!compressor_initialized_) {
       Status s = InitCompressor();

cpp/src/arrow/util/compression_zstd.cc

@@ -23,6 +23,7 @@
 #include <zstd.h>
 
 #include "arrow/status.h"
+#include "arrow/util/macros.h"
 
 using std::size_t;
 
@@ -42,7 +43,8 @@ Status ZSTDCodec::Decompress(int64_t input_len, const uint8_t* input, int64_t ou
   return Status::OK();
 }
 
-int64_t ZSTDCodec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
+int64_t ZSTDCodec::MaxCompressedLen(int64_t input_len,
+                                    const uint8_t* ARROW_ARG_UNUSED(input)) {
   return ZSTD_compressBound(input_len);
 }
 

cpp/src/arrow/util/decimal.h

@@ -75,8 +75,8 @@ class ARROW_EXPORT Decimal128 {
   ///  -21 /  5 -> -4, -1
   ///   21 / -5 -> -4,  1
   ///  -21 / -5 ->  4, -1
-  /// @param right the number to divide by
-  /// @param remainder the remainder after the division
+  /// \param divisor the number to divide by
+  /// \param remainder the remainder after the division
   Status Divide(const Decimal128& divisor, Decimal128* result,
                 Decimal128* remainder) const;
 

cpp/src/arrow/util/logging.h

@@ -90,7 +90,7 @@ namespace internal {
 class NullLog {
  public:
   template <class T>
-  NullLog& operator<<(const T& t) {
+  NullLog& operator<<(const T& ARROW_ARG_UNUSED(t)) {
     return *this;
   }
 };

cpp/src/arrow/util/macros.h

@@ -26,7 +26,7 @@
 #endif
 
 #define ARROW_UNUSED(x) (void)x
-
+#define ARROW_ARG_UNUSED(x)
 //
 // GCC can be told that a certain branch is not likely to be taken (for
 // instance, a CHECK failure), and use that information in static analysis.

cpp/src/arrow/util/sse-util.h

@@ -176,27 +176,27 @@ static inline int SSE4_cmpestri(__m128i str1, int len1, __m128i str2, int len2)
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u8(uint32_t crc, uint8_t v) {
+static inline uint32_t SSE4_crc32_u8(uint32_t, uint8_t) {
   DCHECK(false) << "CPU doesn't support SSE 4.2";
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u16(uint32_t crc, uint16_t v) {
+static inline uint32_t SSE4_crc32_u16(uint32_t, uint16_t) {
   DCHECK(false) << "CPU doesn't support SSE 4.2";
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u32(uint32_t crc, uint32_t v) {
+static inline uint32_t SSE4_crc32_u32(uint32_t, uint32_t) {
   DCHECK(false) << "CPU doesn't support SSE 4.2";
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u64(uint32_t crc, uint64_t v) {
+static inline uint32_t SSE4_crc32_u64(uint32_t, uint64_t) {
   DCHECK(false) << "CPU doesn't support SSE 4.2";
   return 0;
 }
 
-static inline int64_t POPCNT_popcnt_u64(uint64_t a) {
+static inline int64_t POPCNT_popcnt_u64(uint64_t) {
   DCHECK(false) << "CPU doesn't support SSE 4.2";
   return 0;
 }
@@ -205,27 +205,27 @@ static inline int64_t POPCNT_popcnt_u64(uint64_t a) {
 
 #else
 
-static inline uint32_t SSE4_crc32_u8(uint32_t crc, uint8_t v) {
+static inline uint32_t SSE4_crc32_u8(uint32_t, uint8_t) {
   DCHECK(false) << "SSE support is not enabled";
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u16(uint32_t crc, uint16_t v) {
+static inline uint32_t SSE4_crc32_u16(uint32_t, uint16_t) {
   DCHECK(false) << "SSE support is not enabled";
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u32(uint32_t crc, uint32_t v) {
+static inline uint32_t SSE4_crc32_u32(uint32_t, uint32_t) {
   DCHECK(false) << "SSE support is not enabled";
   return 0;
 }
 
-static inline uint32_t SSE4_crc32_u64(uint32_t crc, uint64_t v) {
+static inline uint32_t SSE4_crc32_u64(uint32_t, uint64_t) {
   DCHECK(false) << "SSE support is not enabled";
   return 0;
 }
 
-static inline int64_t POPCNT_popcnt_u64(uint64_t a) {
+static inline int64_t POPCNT_popcnt_u64(uint64_t) {
   DCHECK(false) << "SSE support is not enabled";
   return 0;
 }

cpp/src/arrow/visitor.cc

@@ -56,10 +56,7 @@ ARRAY_VISITOR_DEFAULT(ListArray);
 ARRAY_VISITOR_DEFAULT(StructArray);
 ARRAY_VISITOR_DEFAULT(UnionArray);
 ARRAY_VISITOR_DEFAULT(DictionaryArray);
-
-Status ArrayVisitor::Visit(const DecimalArray& array) {
-  return Status::NotImplemented("decimal");
-}
+ARRAY_VISITOR_DEFAULT(DecimalArray);
 
 #undef ARRAY_VISITOR_DEFAULT
 

cpp/src/plasma/client.cc

@@ -286,7 +286,6 @@ Status PlasmaClient::Get(const ObjectID* object_ids, int64_t num_objects,
 /// calls will not do anything. The client will only send a message to the store
 /// releasing the object when the client is truly done with the object.
 ///
-/// @param conn The plasma connection.
 /// @param object_id The object ID to attempt to release.
 Status PlasmaClient::PerformRelease(const ObjectID& object_id) {
   // Decrement the count of the number of instances of this object that are

cpp/src/plasma/client.h

@@ -120,7 +120,7 @@ class ARROW_EXPORT PlasmaClient {
   /// the caller should not release objects that were not retrieved.
   ///
   /// \param object_ids The IDs of the objects to get.
-  /// \param num_object_ids The number of object IDs to get.
+  /// \param num_objects The number of object IDs to get.
   /// \param timeout_ms The amount of time in milliseconds to wait before this
   ///        request times out. If this value is -1, then no timeout is set.
   /// \param object_buffers An array where the results will be stored. If the
@@ -181,7 +181,6 @@ class ARROW_EXPORT PlasmaClient {
 
   /// Compute the hash of an object in the object store.
   ///
-  /// \param conn The object containing the connection state.
   /// \param object_id The ID of the object we want to hash.
   /// \param digest A pointer at which to return the hash digest of the object.
   ///        The pointer must have at least kDigestSize bytes allocated.
@@ -277,7 +276,6 @@ class ARROW_EXPORT PlasmaClient {
 
   /// Transfer local object to a different plasma manager.
   ///
-  /// \param conn The object containing the connection state.
   /// \param addr IP address of the plasma manager we are transfering to.
   /// \param port Port of the plasma manager we are transfering to.
   /// \param object_id ObjectID of the object we are transfering.
@@ -287,7 +285,6 @@ class ARROW_EXPORT PlasmaClient {
   /// Return the status of a given object. This method may query the object
   /// table.
   ///
-  /// \param conn The object containing the connection state.
   /// \param object_id The ID of the object whose status we query.
   /// \param object_status Out parameter for object status. Can take the
   ///         following values.
@@ -305,7 +302,6 @@ class ARROW_EXPORT PlasmaClient {
 
   /// Get the file descriptor for the socket connection to the plasma manager.
   ///
-  /// \param conn The plasma connection.
   /// \return The file descriptor for the manager connection. If there is no
   ///         connection to the manager, this is -1.
   int get_manager_fd();

cpp/src/plasma/events.h

@@ -66,7 +66,6 @@ class EventLoop {
   /// Remove a file event handler from the event loop.
   ///
   /// @param fd The file descriptor of the event handler.
-  /// @return Void.
   void RemoveFileEvent(int fd);
 
   /// Register a handler that will be called after a time slice of
@@ -84,8 +83,6 @@ class EventLoop {
   int RemoveTimer(int64_t timer_id);
 
   /// \brief Run the event loop.
-  ///
-  /// @return Void.
   void Start();
 
   /// \brief Stop the event loop

cpp/src/plasma/eviction_policy.h

@@ -70,7 +70,6 @@ class EvictionPolicy {
   /// cache.
   ///
   /// @param object_id The object ID of the object that was created.
-  /// @return Void.
   void object_created(const ObjectID& object_id);
 
   /// This method will be called when the Plasma store needs more space, perhaps
@@ -94,7 +93,6 @@ class EvictionPolicy {
   /// @param object_id The ID of the object that is now being used.
   /// @param objects_to_evict The object IDs that were chosen for eviction will
   ///        be stored into this vector.
-  /// @return Void.
   void begin_object_access(const ObjectID& object_id,
                            std::vector<ObjectID>* objects_to_evict);
 
@@ -106,7 +104,6 @@ class EvictionPolicy {
   /// @param object_id The ID of the object that is no longer being used.
   /// @param objects_to_evict The object IDs that were chosen for eviction will
   ///        be stored into this vector.
-  /// @return Void.
   void end_object_access(const ObjectID& object_id,
                          std::vector<ObjectID>* objects_to_evict);
 

cpp/src/plasma/store.cc

@@ -458,8 +458,7 @@ void PlasmaStore::disconnect_client(int client_fd) {
 /// be
 /// buffered, and this will be called again when the send buffer has room.
 ///
-/// @param client The client to send the notification to.
-/// @return Void.
+/// @param client_fd The client to send the notification to.
 void PlasmaStore::send_notifications(int client_fd) {
   auto it = pending_notifications_.find(client_fd);
 

cpp/src/plasma/store.h

@@ -77,7 +77,6 @@ class PlasmaStore {
   /// be called on objects that are returned by the eviction policy to evict.
   ///
   /// @param object_ids Object IDs of the objects to be deleted.
-  /// @return Void.
   void delete_objects(const std::vector<ObjectID>& object_ids);
 
   /// Process a get request from a client. This method assumes that we will
@@ -91,7 +90,6 @@ class PlasmaStore {
   /// @param client The client making this request.
   /// @param object_ids Object IDs of the objects to be gotten.
   /// @param timeout_ms The timeout for the get request in milliseconds.
-  /// @return Void.
   void process_get_request(Client* client, const std::vector<ObjectID>& object_ids,
                            int64_t timeout_ms);
 
@@ -101,7 +99,6 @@ class PlasmaStore {
   /// @param digest The digest of the object. This is used to tell if two
   /// objects
   ///        with the same object ID are the same.
-  /// @return Void.
   void seal_object(const ObjectID& object_id, unsigned char digest[]);
 
   /// Check if the plasma store contains an object:
@@ -115,25 +112,21 @@ class PlasmaStore {
   ///
   /// @param object_id The object ID of the object that is being released.
   /// @param client The client making this request.
-  /// @param Void.
   void release_object(const ObjectID& object_id, Client* client);
 
   /// Subscribe a file descriptor to updates about new sealed objects.
   ///
   /// @param client The client making this request.
-  /// @return Void.
   void subscribe_to_updates(Client* client);
 
   /// Connect a new client to the PlasmaStore.
   ///
   /// @param listener_sock The socket that is listening to incoming connections.
-  /// @return Void.
   void connect_client(int listener_sock);
 
   /// Disconnect a client from the PlasmaStore.
   ///
   /// @param client_fd The client file descriptor that is disconnected.
-  /// @return Void.
   void disconnect_client(int client_fd);
 
   void send_notifications(int client_fd);

cpp/src/plasma/test/serialization_tests.cc

@@ -43,7 +43,7 @@ int create_temp_file(void) {
  * Seek to the beginning of a file and read a message from it.
  *
  * @param fd File descriptor of the file.
- * @param message type Message type that we expect in the file.
+ * @param message_type Message type that we expect in the file.
  *
  * @return Pointer to the content of the message. Needs to be freed by the
  * caller.