Repository: apache/arrow
File: cpp/src/parquet/arrow/reader.cc (C++)

Code before:
  return Status::OK();
}

Status FileReader::Make(::arrow::MemoryPool* pool,
                        std::unique_ptr<ParquetFileReader> reader,
                        std::unique_ptr<FileReader>* out) {
  ARROW_ASSIGN_OR_RAISE(*out,
                        Make(pool, std::move(reader), default_arrow_reader_properties()));
  return Status::OK();
}

Result<std::unique_ptr<FileReader>> FileReader::Make(
    ::arrow::MemoryPool* pool, std::unique_ptr<ParquetFileReader> parquet_reader,
    const ArrowReaderProperties& properties) {
  std::unique_ptr<FileReader> reader =
      std::make_unique<FileReaderImpl>(pool, std::move(parquet_reader), properties);
  RETURN_NOT_OK(static_cast<FileReaderImpl*>(reader.get())->Init());
  return reader;
}

Result<std::unique_ptr<FileReader>> FileReader::Make(
    ::arrow::MemoryPool* pool, std::unique_ptr<ParquetFileReader> parquet_reader) {
  std::unique_ptr<FileReader> reader = std::make_unique<FileReaderImpl>(
      pool, std::move(parquet_reader), default_arrow_reader_properties());
  RETURN_NOT_OK(static_cast<FileReaderImpl*>(reader.get())->Init());
  return reader;
}

FileReaderBuilder::FileReaderBuilder()
    : pool_(::arrow::default_memory_pool()),
      properties_(default_arrow_reader_properties()) {}

Status FileReaderBuilder::Open(std::shared_ptr<::arrow::io::RandomAccessFile> file,
                               const ReaderProperties& properties,
                               std::shared_ptr<FileMetaData> metadata) {
  PARQUET_CATCH_NOT_OK(raw_reader_ = ParquetReader::Open(std::move(file), properties,
                                                         std::move(metadata)));
  return Status::OK();
}

Status FileReaderBuilder::OpenFile(const std::string& path, bool memory_map,
                                   const ReaderProperties& properties,
                                   std::shared_ptr<FileMetaData> metadata) {
  PARQUET_CATCH_NOT_OK(raw_reader_ = ParquetReader::OpenFile(path, memory_map, properties,
                                                             std::move(metadata)));
  return Status::OK();
}

FileReaderBuilder* FileReaderBuilder::memory_pool(::arrow::MemoryPool* pool) {
  pool_ = pool;
  return this;

Review comment (suggestion):
```suggestion
  return Make(pool, std::move(parquet_reader), default_arrow_reader_properties());
```

Code after:
  return Status::OK();
}

Status FileReader::Make(::arrow::MemoryPool* pool,
                        std::unique_ptr<ParquetFileReader> reader,
                        std::unique_ptr<FileReader>* out) {
  ARROW_ASSIGN_OR_RAISE(*out,
                        Make(pool, std::move(reader), default_arrow_reader_properties()));
  return Status::OK();
}

Result<std::unique_ptr<FileReader>> FileReader::Make(
    ::arrow::MemoryPool* pool, std::unique_ptr<ParquetFileReader> parquet_reader,
    const ArrowReaderProperties& properties) {
  std::unique_ptr<FileReader> reader =
      std::make_unique<FileReaderImpl>(pool, std::move(parquet_reader), properties);
  RETURN_NOT_OK(static_cast<FileReaderImpl*>(reader.get())->Init());
  return reader;
}

Result<std::unique_ptr<FileReader>> FileReader::Make(
    ::arrow::MemoryPool* pool, std::unique_ptr<ParquetFileReader> parquet_reader) {
  return Make(pool, std::move(parquet_reader), default_arrow_reader_properties());
}

FileReaderBuilder::FileReaderBuilder()
    : pool_(::arrow::default_memory_pool()),
      properties_(default_arrow_reader_properties()) {}

Status FileReaderBuilder::Open(std::shared_ptr<::arrow::io::RandomAccessFile> file,
                               const ReaderProperties& properties,
                               std::shared_ptr<FileMetaData> metadata) {
  PARQUET_CATCH_NOT_OK(raw_reader_ = ParquetReader::Open(std::move(file), properties,
                                                         std::move(metadata)));
  return Status::OK();
}

Status FileReaderBuilder::OpenFile(const std::string& path, bool memory_map,
                                   const ReaderProperties& properties,
                                   std::shared_ptr<FileMetaData> metadata) {
  PARQUET_CATCH_NOT_OK(raw_reader_ = ParquetReader::OpenFile(path, memory_map, properties,
                                                             std::move(metadata)));
  return Status::OK();
}

FileReaderBuilder* FileReaderBuilder::memory_pool(::arrow::MemoryPool* pool) {
  pool_ = pool;
  return this;
}

FileReaderBuilder* FileReaderBuilder::properties(