ARROW-9001: [R] Box outputs as correct type in call_function

cpp/src/arrow/compute/type_fwd.h

@@ -23,6 +23,8 @@ struct Datum;
 
 namespace compute {
 
+struct CastOptions;
+
 class ExecContext;
 class KernelContext;
 

cpp/src/arrow/csv/options.h

@@ -23,6 +23,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "arrow/csv/type_fwd.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {

cpp/src/arrow/csv/type_fwd.h

@@ -0,0 +1,27 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace arrow {
+namespace csv {
+
+class TableReader;
+struct ConvertOptions;
+struct ReadOptions;
+struct ParseOptions;
+
+}  // namespace csv
+}  // namespace arrow

cpp/src/arrow/dataset/type_fwd.h

@@ -36,10 +36,11 @@ class ExecContext;
 namespace dataset {
 
 class Dataset;
+class DatasetFactory;
 using DatasetVector = std::vector<std::shared_ptr<Dataset>>;
 
 class UnionDataset;
-class DatasetFactory;
+class UnionDatasetFactory;
 
 class Fragment;
 using FragmentIterator = Iterator<std::shared_ptr<Fragment>>;
@@ -51,6 +52,7 @@ class FileFragment;
 class FileWriter;
 class FileWriteOptions;
 class FileSystemDataset;
+class FileSystemDatasetFactory;
 struct FileSystemDatasetWriteOptions;
 
 class InMemoryDataset;
@@ -77,6 +79,8 @@ const std::shared_ptr<Expression>& scalar(bool);
 class Partitioning;
 class PartitioningFactory;
 class PartitioningOrFactory;
+class DirectoryPartitioning;
+class HivePartitioning;
 
 struct ScanContext;
 

cpp/src/arrow/ipc/feather.h

@@ -128,7 +128,7 @@ struct ARROW_EXPORT WriteProperties {
   Compression::type compression = Compression::UNCOMPRESSED;
 
   /// Compressor-specific compression level
-  int compression_level = Compression::kUseDefaultCompressionLevel;
+  int compression_level = ::arrow::util::kUseDefaultCompressionLevel;
 };
 
 ARROW_EXPORT

cpp/src/arrow/json/options.h

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <memory>
 
+#include "arrow/json/type_fwd.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {

cpp/src/arrow/json/type_fwd.h

@@ -0,0 +1,26 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace arrow {
+namespace json {
+
+class TableReader;
+struct ReadOptions;
+struct ParseOptions;
+
+}  // namespace json
+}  // namespace arrow

cpp/src/arrow/util/compression.h

@@ -24,31 +24,13 @@
 
 #include "arrow/result.h"
 #include "arrow/status.h"
+#include "arrow/util/type_fwd.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
-
-struct Compression {
-  /// \brief Compression algorithm
-  enum type {
-    UNCOMPRESSED,
-    SNAPPY,
-    GZIP,
-    BROTLI,
-    ZSTD,
-    LZ4,
-    LZ4_FRAME,
-    LZO,
-    BZ2,
-    LZ4_HADOOP
-  };
-
-  static constexpr int kUseDefaultCompressionLevel = std::numeric_limits<int>::min();
-};
-
 namespace util {
 
-constexpr int kUseDefaultCompressionLevel = Compression::kUseDefaultCompressionLevel;
+constexpr int kUseDefaultCompressionLevel = std::numeric_limits<int>::min();
 
 /// \brief Streaming compressor interface
 ///

cpp/src/arrow/util/type_fwd.h

@@ -22,11 +22,36 @@ namespace arrow {
 template <typename T>
 class Future;
 
+class TimestampParser;
+
 namespace internal {
 
 class Executor;
 class TaskGroup;
 class ThreadPool;
 
 }  // namespace internal
+
+struct Compression {
+  /// \brief Compression algorithm
+  enum type {
+    UNCOMPRESSED,
+    SNAPPY,
+    GZIP,
+    BROTLI,
+    ZSTD,
+    LZ4,
+    LZ4_FRAME,
+    LZO,
+    BZ2,
+    LZ4_HADOOP
+  };
+};
+
+namespace util {
+class Compressor;
+class Decompressor;
+class Codec;
+}  // namespace util
+
 }  // namespace arrow

cpp/src/parquet/arrow/generate_fuzz_corpus.cc

@@ -195,4 +195,4 @@ int Main(int argc, char** argv) {
 
 }  // namespace arrow
 
-int main(int argc, char** argv) { return arrow::Main(argc, argv); }
+int main(int argc, char** argv) { return ::arrow::Main(argc, argv); }

cpp/src/parquet/arrow/schema_internal.cc

@@ -19,8 +19,8 @@
 
 #include "arrow/type.h"
 
-using ArrowType = arrow::DataType;
-using ArrowTypeId = arrow::Type;
+using ArrowType = ::arrow::DataType;
+using ArrowTypeId = ::arrow::Type;
 using ParquetType = parquet::Type;
 
 namespace parquet {

cpp/src/parquet/column_writer.cc

@@ -1129,7 +1129,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
     if (maybe_parent_nulls) {
       ARROW_ASSIGN_OR_RAISE(
           bits_buffer_,
-          arrow::AllocateResizableBuffer(
+          ::arrow::AllocateResizableBuffer(
               BitUtil::BytesForBits(properties_->write_batch_size()), ctx->memory_pool));
       bits_buffer_->ZeroPadding();
     }
@@ -1304,7 +1304,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
 
   Result<std::shared_ptr<Array>> MaybeReplaceValidity(std::shared_ptr<Array> array,
                                                       int64_t new_null_count,
-                                                      arrow::MemoryPool* memory_pool) {
+                                                      ::arrow::MemoryPool* memory_pool) {
     if (bits_buffer_ == nullptr) {
       return array;
     }
@@ -1320,7 +1320,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
       RETURN_NOT_OK(::arrow::VisitArrayInline(*array, &slicer));
       buffers[1] = slicer.buffer_;
     }
-    return arrow::MakeArray(std::make_shared<ArrayData>(
+    return ::arrow::MakeArray(std::make_shared<ArrayData>(
         array->type(), array->length(), std::move(buffers), new_null_count));
   }
 
@@ -1462,7 +1462,7 @@ Status TypedColumnWriterImpl<DType>::WriteArrowDictionary(
   auto WriteIndicesChunk = [&](int64_t offset, int64_t batch_size) {
     int64_t batch_num_values = 0;
     int64_t batch_num_spaced_values = 0;
-    int64_t null_count = arrow::kUnknownNullCount;
+    int64_t null_count = ::arrow::kUnknownNullCount;
     // Bits is not null for nullable values.  At this point in the code we can't determine
     // if the leaf array has the same null values as any parents it might have had so we
     // need to recompute it from def levels.