c10::optional -> std::optional in executorch (#5871)

Summary:
`c10::optional` has been just an alias for `std::optional` for some time now. We are removing the `c10::optional` alias; this change facilitates that removal.

Pull Request resolved: #5871

Reviewed By: q10, tarun292, bunnypak

Differential Revision: D63876538

fbshipit-source-id: c2dd1e8857f9b13eb875593184c08a5c16ef59ef

Author: r-barnes

extension/aten_util/make_aten_functor_from_et_functor.h

@@ -62,12 +62,12 @@ struct type_map<torch::executor::Tensor> final {
 // Optional.
 template <class T>
 struct type_map<torch::executor::optional<T>> final {
-  using type = c10::optional<typename type_map<T>::type>;
+  using type = std::optional<typename type_map<T>::type>;
 };
 
 template <class T>
 struct type_map<torch::executor::optional<T>&> final {
-  using type = c10::optional<typename type_map<T>::type>&;
+  using type = std::optional<typename type_map<T>::type>&;
 };
 
 // ArrayRef.
@@ -150,11 +150,11 @@ struct type_convert<
 
 // Optionals: ATen to ETen.
 template <class F, class T>
-struct type_convert<c10::optional<F>, torch::executor::optional<T>> final {
+struct type_convert<std::optional<F>, torch::executor::optional<T>> final {
  public:
-  c10::optional<F> val;
+  std::optional<F> val;
   std::unique_ptr<struct type_convert<F, T>> convert_struct;
-  explicit type_convert(c10::optional<F> value) : val(value) {}
+  explicit type_convert(std::optional<F> value) : val(value) {}
   torch::executor::optional<T> call() {
     if (val.has_value()) {
       convert_struct = std::make_unique<struct type_convert<F, T>>(
@@ -168,18 +168,18 @@ struct type_convert<c10::optional<F>, torch::executor::optional<T>> final {
 
 // Optionals: ETen to ATen.
 template <class F, class T>
-struct type_convert<torch::executor::optional<F>, c10::optional<T>> final {
+struct type_convert<torch::executor::optional<F>, std::optional<T>> final {
  public:
   torch::executor::optional<F> val;
   std::unique_ptr<struct type_convert<F, T>> convert_struct;
   explicit type_convert(torch::executor::optional<F> value) : val(value) {}
-  c10::optional<T> call() {
+  std::optional<T> call() {
     if (val.has_value()) {
       convert_struct = std::make_unique<struct type_convert<F, T>>(
           type_convert<F, T>(val.value()));
-      return c10::optional<T>(convert_struct->call());
+      return std::optional<T>(convert_struct->call());
     } else {
-      return c10::optional<T>();
+      return std::optional<T>();
     }
   }
 };

extension/aten_util/test/make_aten_functor_from_et_functor_test.cpp

@@ -138,21 +138,21 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestTypeMap_Optionals) {
   // Scalar.
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::optional<int64_t>>::type,
-               c10::optional<int64_t>>::value));
+               std::optional<int64_t>>::value));
   // Tensor.
   EXPECT_TRUE(
       (std::is_same<
           type_map<torch::executor::optional<torch::executor::Tensor>>::type,
-          c10::optional<at::Tensor>>::value));
+          std::optional<at::Tensor>>::value));
   // ArrayRef.
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::optional<
                    torch::executor::ArrayRef<int64_t>>>::type,
-               c10::optional<c10::ArrayRef<int64_t>>>::value));
+               std::optional<c10::ArrayRef<int64_t>>>::value));
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::optional<
                    torch::executor::ArrayRef<torch::executor::Tensor>>>::type,
-               c10::optional<c10::ArrayRef<at::Tensor>>>::value));
+               std::optional<c10::ArrayRef<at::Tensor>>>::value));
 }
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestTypeMap_ArrayRef) {
@@ -169,11 +169,11 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestTypeMap_ArrayRef) {
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::ArrayRef<
                    torch::executor::optional<int64_t>>>::type,
-               c10::ArrayRef<c10::optional<int64_t>>>::value));
+               c10::ArrayRef<std::optional<int64_t>>>::value));
   EXPECT_TRUE((std::is_same<
                type_map<torch::executor::ArrayRef<
                    torch::executor::optional<torch::executor::Tensor>>>::type,
-               c10::ArrayRef<c10::optional<at::Tensor>>>::value));
+               c10::ArrayRef<std::optional<at::Tensor>>>::value));
 }
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_Tensor) {
@@ -191,9 +191,9 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_Tensor) {
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_OptionalScalar) {
   // Convert optional at to et.
-  auto optional_at_in = c10::optional<int64_t>();
+  auto optional_at_in = std::optional<int64_t>();
   auto optional_et =
-      type_convert<c10::optional<int64_t>, torch::executor::optional<int64_t>>(
+      type_convert<std::optional<int64_t>, torch::executor::optional<int64_t>>(
           optional_at_in)
           .call();
   EXPECT_TRUE(
@@ -203,19 +203,19 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_OptionalScalar) {
   // Convert optional et to at.
   auto optional_et_in = torch::executor::optional<int64_t>();
   auto optional_at_out =
-      type_convert<torch::executor::optional<int64_t>, c10::optional<int64_t>>(
+      type_convert<torch::executor::optional<int64_t>, std::optional<int64_t>>(
           optional_et_in)
           .call();
   EXPECT_TRUE(
-      (std::is_same<decltype(optional_at_out), c10::optional<int64_t>>::value));
+      (std::is_same<decltype(optional_at_out), std::optional<int64_t>>::value));
 }
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_OptionalTensor) {
   // Convert optional at to et.
-  auto optional_at_in = c10::optional<at::Tensor>();
+  auto optional_at_in = std::optional<at::Tensor>();
   auto optional_et =
       type_convert<
-          c10::optional<at::Tensor>,
+          std::optional<at::Tensor>,
           torch::executor::optional<torch::executor::Tensor>>(optional_at_in)
           .call();
   EXPECT_TRUE((std::is_same<
@@ -227,10 +227,10 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestConvert_OptionalTensor) {
   auto et_in = torch::executor::optional<torch::executor::Tensor>(tf.ones({3}));
   auto optional_at_out = type_convert<
                              torch::executor::optional<torch::executor::Tensor>,
-                             c10::optional<at::Tensor>>(optional_et)
+                             std::optional<at::Tensor>>(optional_et)
                              .call();
   EXPECT_TRUE(
-      (std::is_same<decltype(optional_at_out), c10::optional<at::Tensor>>::
+      (std::is_same<decltype(optional_at_out), std::optional<at::Tensor>>::
            value));
 }
 
@@ -344,8 +344,8 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestWrap_EmbeddingByte) {
 }
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestWrap_OptionalScalarAdd) {
-  c10::optional<int64_t> a = c10::optional<int64_t>(3);
-  c10::optional<int64_t> b = c10::optional<int64_t>();
+  std::optional<int64_t> a = std::optional<int64_t>(3);
+  std::optional<int64_t> b = std::optional<int64_t>();
   at::Tensor out = torch::tensor({0});
 
   auto op = c10::Dispatcher::singleton().findSchema(
@@ -359,8 +359,8 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestWrap_OptionalScalarAdd) {
 }
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestWrap_OptionalTensorAdd) {
-  c10::optional<at::Tensor> a = c10::optional<at::Tensor>(torch::tensor({8}));
-  c10::optional<at::Tensor> b = c10::optional<at::Tensor>();
+  std::optional<at::Tensor> a = std::optional<at::Tensor>(torch::tensor({8}));
+  std::optional<at::Tensor> b = std::optional<at::Tensor>();
   at::Tensor out = torch::tensor({0});
 
   auto op = c10::Dispatcher::singleton().findSchema(
@@ -405,10 +405,10 @@ TEST_F(MakeATenFunctorFromETFunctorTest, TestWrap_ArrayRefTensorAdd) {
 }
 
 TEST_F(MakeATenFunctorFromETFunctorTest, TestWrap_ArrayRefOptional) {
-  std::vector<c10::optional<at::Tensor>> vec{
-      c10::optional<at::Tensor>(torch::tensor({1})),
-      c10::optional<at::Tensor>(),
-      c10::optional<at::Tensor>(torch::tensor({3}))};
+  std::vector<std::optional<at::Tensor>> vec{
+      std::optional<at::Tensor>(torch::tensor({1})),
+      std::optional<at::Tensor>(),
+      std::optional<at::Tensor>(torch::tensor({3}))};
   at::Tensor out = torch::tensor({0});
 
   at::ArrayRef arrayref = at::ArrayRef(vec.data(), vec.size());

kernels/test/op_index_put_test.cpp

@@ -34,7 +34,7 @@ class OpIndexPutOutTest : public OperatorTest {
       const bool accumulate,
       Tensor& out) {
 #ifdef USE_ATEN_LIB
-    c10::List<c10::optional<at::Tensor>> indices_list(indices);
+    c10::List<std::optional<at::Tensor>> indices_list(indices);
     return torch::executor::aten::index_put_outf(
         context_, input, indices_list, values, accumulate, out);
 #else