[Support] Add transformOptional

[kazu]

Summary

llvm::Optional<T> has transform, which is equivalent to
std::optional<T>::transform. The problem is that
std::optional<T>::transform won't be available until C++23, implying
that we probably cannot use it in our codebase untli 2028 or so. We
certainly don't want to keep llvm::Optional just for transform.

This patch adds transformOptional to STLForwardCompat.h so that we can
use transform during the migration to std::optional and beyond.

I've shamelessly borrowed the implementation and test from
llvm/include/llvm/ADT/Optional.h and
llvm/unittests/ADT/OptionalTest.cpp, respectively.

This is part of an effort to migrate from llvm::Optional to
std::optional:

https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

[dblaikie]

Could we call it transform, or does that complicate things with overload resolution/other functions named transform?

llvm/unittests/ADT/STLForwardCompatTest.cpp

49–78

Do we have enough of these for various unit tests we could have a common/shared one?

[kazu]

In D139779#3986656, @dblaikie wrote:

Could we call it transform, or does that complicate things with overload resolution/other functions named transform?

The compiler and overload resolutions are OK. With the function signature being very narrowly scoped, the proposed function should only match the intended use. (In fact, I used to call this function transform while working on the patch.)

I am not sure if people are OK. clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h:221 uses both llvm::transform (defined in llvm/include/llvm/ADT/STLExtras.h) and llvm::Optional<T>::transform. Having two instances of llvm::transform in one statement is pretty confusing.

But then I personally find the name of transformOptional a bit ugly, which you may also be implying, so I am sitting on the fence as far as the naming goes. You get to break the tie for me. :-)

I'll look into sharing MoveOnly. Maybe I can come up with a preparation patch to share that.

[kazu]

I've renamed transformOptional to transform.

I am now using MoveOnly, which has been moved to a separate file.

[kazu]

PTAL. Thanks!

[MaskRay]

Having llvm::transform not doing what std::transform does appears confusing, so even if the name transformOptional may look strange, I'd vote +1 for it...
A distinct name helps future => std::optional<T>::transform migration as well although that will take many years.

[dblaikie]

Don't have strong feelings - maybe split the difference and go with transformOpt?

[kazu]

Went back to the original naming -- transformOptional.

[kazu]

In D139779#3989537, @dblaikie wrote:

Don't have strong feelings - maybe split the difference and go with transformOpt?

Hmm. Could we actually go with my original transformOptional? Opt could mean command line options or optimizations depending on contexts.

[dblaikie]

In D139779#3994082, @kazu wrote:

In D139779#3989537, @dblaikie wrote:

Don't have strong feelings - maybe split the difference and go with transformOpt?

Hmm. Could we actually go with my original transformOptional? Opt could mean command line options or optimizations depending on contexts.

Fair enough

llvm/include/llvm/ADT/STLForwardCompat.h

 /// These should be replaced with their STL counterparts as the C++ version LLVM
 /// is compiled with is updated.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_STLFORWARDCOMPAT_H
 #define LLVM_ADT_STLFORWARDCOMPAT_H
 
+#include "llvm/ADT/Optional.h"
+#include <optional>
 #include <type_traits>
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //     Features from C++20
 //===----------------------------------------------------------------------===//
 
 template <typename T>
 struct remove_cvref // NOLINT(readability-identifier-naming)
 {
   using type = std::remove_cv_t<std::remove_reference_t<T>>;
 };
 
 template <typename T>
 using remove_cvref_t // NOLINT(readability-identifier-naming)
     = typename llvm::remove_cvref<T>::type;
 
+//===----------------------------------------------------------------------===//
+//     Features from C++23
+//===----------------------------------------------------------------------===//
+
+// TODO: Remove this in favor of std::optional<T>::transform once we switch to
+// C++23.
+template <typename T, typename Function>
+auto transformOptional(const std::optional<T> &O, const Function &F)
+    -> std::optional<decltype(F(O.value()))> {
+  if (O)
+    return F(O.value());
+  return std::nullopt;
+}
+
+// TODO: Remove this in favor of std::optional<T>::transform once we switch to
+// C++23.
+template <typename T, typename Function>
+auto transformOptional(std::optional<T> &&O, const Function &F)
+    -> std::optional<decltype(F(std::move(O).value()))> {
+  if (O)
+    return F(std::move(O).value());
+  return std::nullopt;
+}
+
+// TODO: Remove this once the migration from llvm::Optional to std::optional is
+// complete.
+template <typename T, typename Function>
+auto transformOptional(const Optional<T> &O, const Function &F)
+    -> Optional<decltype(F(O.value()))> {
+  if (O)
+    return F(O.value());
+  return std::nullopt;
+}
+
+// TODO: Remove this once the migration from llvm::Optional to std::optional is
+// complete.
+template <typename T, typename Function>
+auto transformOptional(Optional<T> &&O, const Function &F)
+    -> Optional<decltype(F(std::move(O).value()))> {
+  if (O)
+    return F(std::move(O).value());
+  return std::nullopt;
+}
+
 } // namespace llvm
 
 #endif // LLVM_ADT_STLFORWARDCOMPAT_H

llvm/unittests/ADT/STLForwardCompatTest.cpp

 }
 
 TYPED_TEST(STLForwardCompatRemoveCVRefTest, RemoveCVRefT) {
   using From = typename TypeParam::first_type;
   EXPECT_TRUE((std::is_same<typename llvm::remove_cvref<From>::type,
                             llvm::remove_cvref_t<From>>::value));
 }
 
+namespace {
+
+struct MoveOnly {
+  static unsigned MoveConstructions;
+  static unsigned Destructions;
+  static unsigned MoveAssignments;
+  int val;
+  explicit MoveOnly(int val) : val(val) {
+  }
+  MoveOnly(MoveOnly&& other) {
+    val = other.val;
+    ++MoveConstructions;
+  }
+  MoveOnly &operator=(MoveOnly&& other) {
+    val = other.val;
+    ++MoveAssignments;
+    return *this;
+  }
+  ~MoveOnly() {
+    ++Destructions;
+  }
+  static void ResetCounts() {
+    MoveConstructions = 0;
+    Destructions = 0;
+    MoveAssignments = 0;
+  }
+};
+
+unsigned MoveOnly::MoveConstructions = 0;
+unsigned MoveOnly::Destructions = 0;
+unsigned MoveOnly::MoveAssignments = 0;
+
+} // end anonymous namespace
+
+TEST(TransformOptionalTest, TransformStd) {
+  std::optional<int> A;
+
+  std::optional<int> B =
+      llvm::transformOptional(A, [&](int N) { return N + 1; });
+  EXPECT_FALSE(B.has_value());
+
+  A = 3;
+  std::optional<int> C =
+      llvm::transformOptional(A, [&](int N) { return N + 1; });
+  EXPECT_TRUE(C.has_value());
+  EXPECT_EQ(4, C.value());
+}
+
+TEST(TransformOptionalTest, MoveTransformStd) {
+  std::optional<MoveOnly> A;
+
+  MoveOnly::ResetCounts();
+  std::optional<int> B = llvm::transformOptional(
+      std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
+  EXPECT_FALSE(B.has_value());
+  EXPECT_EQ(0u, MoveOnly::MoveConstructions);
+  EXPECT_EQ(0u, MoveOnly::MoveAssignments);
+  EXPECT_EQ(0u, MoveOnly::Destructions);
+
+  A = MoveOnly(5);
+  MoveOnly::ResetCounts();
+  std::optional<int> C = llvm::transformOptional(
+      std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
+  EXPECT_TRUE(C.has_value());
+  EXPECT_EQ(7, C.value());
+  EXPECT_EQ(0u, MoveOnly::MoveConstructions);
+  EXPECT_EQ(0u, MoveOnly::MoveAssignments);
+  EXPECT_EQ(0u, MoveOnly::Destructions);
+}
+
+TEST(TransformOptionalTest, TransformLlvm) {
+  llvm::Optional<int> A;
+
+  llvm::Optional<int> B =
+      llvm::transformOptional(A, [&](int N) { return N + 1; });
+  EXPECT_FALSE(B.has_value());
+
+  A = 3;
+  llvm::Optional<int> C =
+      llvm::transformOptional(A, [&](int N) { return N + 1; });
+  EXPECT_TRUE(C.has_value());
+  EXPECT_EQ(4, C.value());
+}
+
+TEST(TransformOptionalTest, MoveTransformLlvm) {
+  llvm::Optional<MoveOnly> A;
+
+  MoveOnly::ResetCounts();
+  llvm::Optional<int> B = llvm::transformOptional(
+      std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
+  EXPECT_FALSE(B.has_value());
+  EXPECT_EQ(0u, MoveOnly::MoveConstructions);
+  EXPECT_EQ(0u, MoveOnly::MoveAssignments);
+  EXPECT_EQ(0u, MoveOnly::Destructions);
+
+  A = MoveOnly(5);
+  MoveOnly::ResetCounts();
+  llvm::Optional<int> C = llvm::transformOptional(
+      std::move(A), [&](const MoveOnly &M) { return M.val + 2; });
+  EXPECT_TRUE(C.has_value());
+  EXPECT_EQ(7, C.value());
+  EXPECT_EQ(0u, MoveOnly::MoveConstructions);
+  EXPECT_EQ(0u, MoveOnly::MoveAssignments);
+  EXPECT_EQ(0u, MoveOnly::Destructions);
+}
+
 } // namespace