Clean up FOLLY nullable annotation (facebookincubator#9247)

Summary: Pull Request resolved: facebookincubator#9247

Reviewed By: tanjialiang

Differential Revision: D55354910

Pulled By: xiaoxmeng

fbshipit-source-id: 0e488d1b60b92086db966fffbf191ad622b5a8c0

pyvelox/serde.cpp

@@ -24,7 +24,7 @@ namespace facebook::velox::py {
 namespace py = pybind11;
 
 namespace {
-VectorPtr pyRestoreVectorFromFileHelper(const char* FOLLY_NONNULL filePath) {
+VectorPtr pyRestoreVectorFromFileHelper(const char* filePath) {
   using namespace facebook::velox;
   memory::MemoryPool* pool = PyVeloxContext::getSingletonInstance().pool();
   return restoreVectorFromFile(filePath, pool);

velox/common/base/BloomFilter.h

@@ -114,16 +114,14 @@ class BloomFilter {
   }
 
   inline static void
-  set(uint64_t* FOLLY_NONNULL bloom, int32_t bloomSize, uint64_t hashCode) {
+  set(uint64_t* bloom, int32_t bloomSize, uint64_t hashCode) {
     auto mask = bloomMask(hashCode);
     auto index = bloomIndex(bloomSize, hashCode);
     bloom[index] |= mask;
   }
 
-  inline static bool test(
-      const uint64_t* FOLLY_NONNULL bloom,
-      int32_t bloomSize,
-      uint64_t hashCode) {
+  inline static bool
+  test(const uint64_t* bloom, int32_t bloomSize, uint64_t hashCode) {
     auto mask = bloomMask(hashCode);
     auto index = bloomIndex(bloomSize, hashCode);
     return mask == (bloom[index] & mask);

velox/common/base/tests/Memcpy.cpp

@@ -41,10 +41,10 @@ uint64_t sum(uint64_t* data, int32_t size) {
 }
 
 struct CopyCallable {
-  void* FOLLY_NULLABLE source;
-  void* FOLLY_NULLABLE destination;
+  void* source;
+  void* destination;
   int64_t size;
-  Semaphore* FOLLY_NULLABLE sem;
+  Semaphore* sem;
 
   void operator()() {
     if (FLAGS_system_memcpy) {

velox/common/caching/ScanTracker.h

@@ -119,7 +119,7 @@ class ScanTracker {
       std::string_view id,
       std::function<void(ScanTracker* FOLLY_NONNULL)> unregisterer,
       int32_t loadQuantum,
-      FileGroupStats* FOLLY_NULLABLE fileGroupStats = nullptr)
+      FileGroupStats* fileGroupStats = nullptr)
       : id_(id),
         unregisterer_(unregisterer),
         loadQuantum_(loadQuantum),
@@ -172,7 +172,7 @@ class ScanTracker {
     return id_;
   }
 
-  FileGroupStats* FOLLY_NULLABLE fileGroupStats() const {
+  FileGroupStats* fileGroupStats() const {
     return fileGroupStats_;
   }
 
@@ -190,7 +190,7 @@ class ScanTracker {
   // single 10MB reference for 'fileGroupStats_'. 0 means the read
   // size is unlimited.
   const int32_t loadQuantum_;
-  FileGroupStats* FOLLY_NULLABLE fileGroupStats_;
+  FileGroupStats* fileGroupStats_;
 };
 
 } // namespace facebook::velox::cache

velox/common/file/File.h

@@ -50,8 +50,8 @@ class ReadFile {
   // buffer 'buf'. The bytes are returned as a string_view pointing to 'buf'.
   //
   // This method should be thread safe.
-  virtual std::string_view
-  pread(uint64_t offset, uint64_t length, void* FOLLY_NONNULL buf) const = 0;
+  virtual std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const = 0;
 
   // Same as above, but returns owned data directly.
   //
@@ -174,10 +174,8 @@ class InMemoryReadFile : public ReadFile {
   explicit InMemoryReadFile(std::string file)
       : ownedFile_(std::move(file)), file_(ownedFile_) {}
 
-  std::string_view pread(
-      uint64_t offset,
-      uint64_t length,
-      void* FOLLY_NONNULL buf) const override;
+  std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const override;
 
   std::string pread(uint64_t offset, uint64_t length) const override;
 
@@ -213,7 +211,7 @@ class InMemoryReadFile : public ReadFile {
 
 class InMemoryWriteFile final : public WriteFile {
  public:
-  explicit InMemoryWriteFile(std::string* FOLLY_NONNULL file) : file_(file) {}
+  explicit InMemoryWriteFile(std::string* file) : file_(file) {}
 
   void append(std::string_view data) final;
   void append(std::unique_ptr<folly::IOBuf> data) final;
@@ -222,7 +220,7 @@ class InMemoryWriteFile final : public WriteFile {
   uint64_t size() const final;
 
  private:
-  std::string* FOLLY_NONNULL file_;
+  std::string* file_;
 };
 
 // Current implementation for the local version is quite simple (e.g. no
@@ -237,8 +235,8 @@ class LocalReadFile final : public ReadFile {
 
   ~LocalReadFile();
 
-  std::string_view
-  pread(uint64_t offset, uint64_t length, void* FOLLY_NONNULL buf) const final;
+  std::string_view pread(uint64_t offset, uint64_t length, void* buf)
+      const final;
 
   uint64_t size() const final;
 
@@ -264,8 +262,7 @@ class LocalReadFile final : public ReadFile {
   }
 
  private:
-  void preadInternal(uint64_t offset, uint64_t length, char* FOLLY_NONNULL pos)
-      const;
+  void preadInternal(uint64_t offset, uint64_t length, char* pos) const;
 
   std::string path_;
   int32_t fd_;
@@ -289,7 +286,7 @@ class LocalWriteFile final : public WriteFile {
   uint64_t size() const final;
 
  private:
-  FILE* FOLLY_NONNULL file_;
+  FILE* file_;
   mutable long size_;
   bool closed_{false};
 };

velox/connectors/fuzzer/FuzzerConnector.cpp

@@ -22,7 +22,7 @@ namespace facebook::velox::connector::fuzzer {
 FuzzerDataSource::FuzzerDataSource(
     const std::shared_ptr<const RowType>& outputType,
     const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    velox::memory::MemoryPool* FOLLY_NONNULL pool)
+    velox::memory::MemoryPool* pool)
     : outputType_(outputType), pool_(pool) {
   auto fuzzerTableHandle =
       std::dynamic_pointer_cast<FuzzerTableHandle>(tableHandle);

velox/connectors/fuzzer/FuzzerConnector.h

@@ -56,7 +56,7 @@ class FuzzerDataSource : public DataSource {
   FuzzerDataSource(
       const std::shared_ptr<const RowType>& outputType,
       const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      velox::memory::MemoryPool* FOLLY_NONNULL pool);
+      velox::memory::MemoryPool* pool);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
 
@@ -96,15 +96,15 @@ class FuzzerDataSource : public DataSource {
   size_t completedRows_{0};
   size_t completedBytes_{0};
 
-  memory::MemoryPool* FOLLY_NONNULL pool_;
+  memory::MemoryPool* pool_;
 };
 
 class FuzzerConnector final : public Connector {
  public:
   FuzzerConnector(
       const std::string& id,
       std::shared_ptr<const Config> config,
-      folly::Executor* FOLLY_NULLABLE /*executor*/)
+      folly::Executor* /*executor*/)
       : Connector(id) {}
 
   std::unique_ptr<DataSource> createDataSource(
@@ -113,7 +113,7 @@ class FuzzerConnector final : public Connector {
       const std::unordered_map<
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& /*columnHandles*/,
-      ConnectorQueryCtx* FOLLY_NONNULL connectorQueryCtx) override final {
+      ConnectorQueryCtx* connectorQueryCtx) override final {
     return std::make_unique<FuzzerDataSource>(
         outputType, tableHandle, connectorQueryCtx->memoryPool());
   }
@@ -130,17 +130,17 @@ class FuzzerConnector final : public Connector {
 
 class FuzzerConnectorFactory : public ConnectorFactory {
  public:
-  static constexpr const char* FOLLY_NONNULL kFuzzerConnectorName{"fuzzer"};
+  static constexpr const char* kFuzzerConnectorName{"fuzzer"};
 
   FuzzerConnectorFactory() : ConnectorFactory(kFuzzerConnectorName) {}
 
-  explicit FuzzerConnectorFactory(const char* FOLLY_NONNULL connectorName)
+  explicit FuzzerConnectorFactory(const char* connectorName)
       : ConnectorFactory(connectorName) {}
 
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
       std::shared_ptr<const Config> config,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) override {
+      folly::Executor* executor = nullptr) override {
     return std::make_shared<FuzzerConnector>(id, config, executor);
   }
 };

velox/connectors/hive/HiveConnector.cpp

@@ -54,7 +54,7 @@ namespace facebook::velox::connector::hive {
 HiveConnector::HiveConnector(
     const std::string& id,
     std::shared_ptr<const Config> config,
-    folly::Executor* FOLLY_NULLABLE executor)
+    folly::Executor* executor)
     : Connector(id),
       hiveConfig_(std::make_shared<HiveConfig>(config)),
       fileHandleFactory_(

velox/connectors/hive/HiveConnector.h

@@ -32,7 +32,7 @@ class HiveConnector : public Connector {
   HiveConnector(
       const std::string& id,
       std::shared_ptr<const Config> config,
-      folly::Executor* FOLLY_NULLABLE executor);
+      folly::Executor* executor);
 
   const std::shared_ptr<const Config>& connectorConfig() const override {
     return hiveConfig_->config();
@@ -60,7 +60,7 @@ class HiveConnector : public Connector {
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) override final;
 
-  folly::Executor* FOLLY_NULLABLE executor() const override {
+  folly::Executor* executor() const override {
     return executor_;
   }
 
@@ -77,18 +77,17 @@ class HiveConnector : public Connector {
  protected:
   const std::shared_ptr<HiveConfig> hiveConfig_;
   FileHandleFactory fileHandleFactory_;
-  folly::Executor* FOLLY_NULLABLE executor_;
+  folly::Executor* executor_;
 };
 
 class HiveConnectorFactory : public ConnectorFactory {
  public:
-  static constexpr const char* FOLLY_NONNULL kHiveConnectorName = "hive";
-  static constexpr const char* FOLLY_NONNULL kHiveHadoop2ConnectorName =
-      "hive-hadoop2";
+  static constexpr const char* kHiveConnectorName = "hive";
+  static constexpr const char* kHiveHadoop2ConnectorName = "hive-hadoop2";
 
   HiveConnectorFactory() : ConnectorFactory(kHiveConnectorName) {}
 
-  explicit HiveConnectorFactory(const char* FOLLY_NONNULL connectorName)
+  explicit HiveConnectorFactory(const char* connectorName)
       : ConnectorFactory(connectorName) {}
 
   /// Register HiveConnector components such as Dwrf, Parquet readers and
@@ -98,7 +97,7 @@ class HiveConnectorFactory : public ConnectorFactory {
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
       std::shared_ptr<const Config> config,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) override {
+      folly::Executor* executor = nullptr) override {
     return std::make_shared<HiveConnector>(id, config, executor);
   }
 };

velox/connectors/hive/SplitReader.h

@@ -117,7 +117,7 @@ class SplitReader {
       const std::shared_ptr<const velox::RowType>& tableSchema);
 
   void setPartitionValue(
-      common::ScanSpec* FOLLY_NONNULL spec,
+      common::ScanSpec* spec,
       const std::string& partitionKey,
       const std::optional<std::string>& value) const;
 

velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp

@@ -44,7 +44,7 @@ class AbfsConfig {
   }
 
  private:
-  const Config* FOLLY_NONNULL config_;
+  const Config* config_;
 };
 
 class AbfsReadFile::Impl {

velox/connectors/tpch/TpchConnector.cpp

@@ -63,7 +63,7 @@ TpchDataSource::TpchDataSource(
     const std::unordered_map<
         std::string,
         std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-    velox::memory::MemoryPool* FOLLY_NONNULL pool)
+    velox::memory::MemoryPool* pool)
     : pool_(pool) {
   auto tpchTableHandle =
       std::dynamic_pointer_cast<TpchTableHandle>(tableHandle);

velox/connectors/tpch/TpchConnector.h

@@ -75,7 +75,7 @@ class TpchDataSource : public DataSource {
       const std::unordered_map<
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-      velox::memory::MemoryPool* FOLLY_NONNULL pool);
+      velox::memory::MemoryPool* pool);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
 
@@ -123,15 +123,15 @@ class TpchDataSource : public DataSource {
   size_t completedRows_{0};
   size_t completedBytes_{0};
 
-  memory::MemoryPool* FOLLY_NONNULL pool_;
+  memory::MemoryPool* pool_;
 };
 
 class TpchConnector final : public Connector {
  public:
   TpchConnector(
       const std::string& id,
       std::shared_ptr<const Config> config,
-      folly::Executor* FOLLY_NULLABLE /*executor*/)
+      folly::Executor* /*executor*/)
       : Connector(id) {}
 
   std::unique_ptr<DataSource> createDataSource(
@@ -140,7 +140,7 @@ class TpchConnector final : public Connector {
       const std::unordered_map<
           std::string,
           std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-      ConnectorQueryCtx* FOLLY_NONNULL connectorQueryCtx) override final {
+      ConnectorQueryCtx* connectorQueryCtx) override final {
     return std::make_unique<TpchDataSource>(
         outputType,
         tableHandle,
@@ -160,17 +160,17 @@ class TpchConnector final : public Connector {
 
 class TpchConnectorFactory : public ConnectorFactory {
  public:
-  static constexpr const char* FOLLY_NONNULL kTpchConnectorName{"tpch"};
+  static constexpr const char* kTpchConnectorName{"tpch"};
 
   TpchConnectorFactory() : ConnectorFactory(kTpchConnectorName) {}
 
-  explicit TpchConnectorFactory(const char* FOLLY_NONNULL connectorName)
+  explicit TpchConnectorFactory(const char* connectorName)
       : ConnectorFactory(connectorName) {}
 
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
       std::shared_ptr<const Config> config,
-      folly::Executor* FOLLY_NULLABLE executor = nullptr) override {
+      folly::Executor* executor = nullptr) override {
     return std::make_shared<TpchConnector>(id, config, executor);
   }
 };

velox/docs/develop/arena.rst

@@ -75,11 +75,11 @@ non-contiguous allocation, it frees all the blocks in that allocation.
 
       // Allocates 'size' contiguous bytes preceded by a Header. Returns
       // the address of Header.
-      Header* FOLLY_NONNULL allocate(int32_t size);
+      Header* allocate(int32_t size);
 
       // Adds the allocation of 'header' and any extensions (if header has
       // kContinued set) to the free list.
-      void free(Header* FOLLY_NONNULL header);
+      void free(Header* header);
 
 StlAllocator, an allocator backed by HashStringAllocator that can be used with
 STL containers, is implemented using the above allocate() and free() methods.
@@ -116,7 +116,7 @@ The prepareRead() method allows deserializing the data using ByteInputStream.
     // Sets 'stream' to range over the data in the range of 'header' and
     // possible continuation ranges.
     static void prepareRead(
-        const Header* FOLLY_NONNULL header,
+        const Header* header,
         ByteInputStream& stream);
 
 Examples of Usage

velox/dwio/common/BitConcatenation.cpp

@@ -19,7 +19,7 @@
 namespace facebook::velox::dwio::common {
 
 void BitConcatenation::append(
-    const uint64_t* FOLLY_NULLABLE bits,
+    const uint64_t* bits,
     int32_t begin,
     int32_t end) {
   int32_t numBits = end - begin;
@@ -46,7 +46,7 @@ void BitConcatenation::appendOnes(int32_t numOnes) {
   }
 }
 
-uint64_t* FOLLY_NONNULL BitConcatenation::ensureSpace(int32_t numBits) {
+uint64_t* BitConcatenation::ensureSpace(int32_t numBits) {
   if (!*buffer_) {
     *buffer_ = AlignedBuffer::allocate<bool>(numBits_ + numBits, &pool_, true);
   } else if (numBits_ + numBits > (*buffer_)->capacity() * 8) {