[ADT] Add PropagateConst from LFTS2

[jbcoe]

Summary

PropagateConst wraps a pointer-type and allows only const access to the pointee when the pointer is accessed through a const-access path. PropagateConst is useful when writing const-correct component-based classes.

PropagateConst is part of Library Fundamentals Technical Specification 2 and has been implemented in libcxx and libstdcxx. The implementation in this patch is based on my implementation from libcxx.

[grandinj]

llvm/include/llvm/ADT/PropagateConst.h

14

experiemental -> experimental

[jbcoe]

Fix typo

[aaron.ballman]

What is the use case within LLVM and Clang, if you have a specific use in mind?

[jbcoe]

I was planning on deferring application (some instances of unique_ptr member data) to a follow-up patch. Would you prefer that I conflate them?

[jbcoe]

I'll put another patch together showing how PropagateConst might be used in llvm/clang.

llvm/include/llvm/ADT/PropagateConst.h

+//==- llvm/ADT/PropagateConst.h - propagate const to pointees ----*- C++ -*-==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// PropagateConst is a wrapper around pointer types that allows only const
+// access to the pointee when the pointer is accessed through a const-access
+// path.
+//
+// llvm::PropagateConst is based on std::experiemental::propagate_const from
+// Library Fundamentals Technical Specification 2 as implemented in libcxx.
+
+#include "llvm/Support/Compiler.h"
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+template <typename PointerLike> class PropagateConst;
+
+template <typename PointerLike>
+inline const PointerLike &get_underlying(const PropagateConst<PointerLike> &P);
+
+template <typename PointerLike>
+inline PointerLike &get_underlying(PropagateConst<PointerLike> &P);
+
+template <typename PointerLike> class PropagateConst {
+public:
+  typedef typename std::remove_reference<decltype(
+      *std::declval<PointerLike &>())>::type element_type;
+
+  static_assert(
+      !std::is_array<PointerLike>::value,
+      "Instantiation of PropagateConst with an array type is ill-formed.");
+  static_assert(
+      !std::is_reference<PointerLike>::value,
+      "Instantiation of PropagateConst with a reference type is ill-formed.");
+  static_assert(!(std::is_pointer<PointerLike>::value &&
+                  std::is_function<
+                      typename std::remove_pointer<PointerLike>::type>::value),
+                "Instantiation of PropagateConst with a function-pointer type "
+                "is ill-formed.");
+  static_assert(
+      !(std::is_pointer<PointerLike>::value &&
+        std::is_same<typename std::remove_cv<
+                         typename std::remove_pointer<PointerLike>::type>::type,
+                     void>::value),
+      "Instantiation of PropagateConst with a pointer to (possibly "
+      "cv-qualified) void is ill-formed.");
+
+private:
+  template <class OtherPointerLike>
+  static element_type *getPointer(OtherPointerLike *U) {
+    return U;
+  }
+
+  template <class OtherPointerLike>
+  static element_type *getPointer(OtherPointerLike &U) {
+    return getPointer(U.get());
+  }
+
+  template <class OtherPointerLike>
+  static const element_type *getPointer(const OtherPointerLike *U) {
+    return U;
+  }
+
+  template <class OtherPointerLike>
+  static const element_type *getPointer(const OtherPointerLike &U) {
+    return getPointer(U.get());
+  }
+
+  template <class OtherPointerLike>
+  struct isPropagateConst : std::false_type {};
+
+  template <class OtherPointerLike>
+  struct isPropagateConst<PropagateConst<OtherPointerLike>> : std::true_type {};
+
+  PointerLike Ptr_;
+
+public:
+  template <class OtherPointerLike>
+  friend const OtherPointerLike & ::llvm::get_underlying(
+      const PropagateConst<OtherPointerLike> &U);
+  template <class OtherPointerLike>
+  friend OtherPointerLike & ::llvm::get_underlying(
+      PropagateConst<OtherPointerLike> &U);
+
+  PropagateConst() = default;
+
+  PropagateConst(const PropagateConst &) = delete;
+
+  PropagateConst(PropagateConst &&) = default;
+
+  template <
+      class OtherPointerLike,
+      typename std::enable_if<
+          !std::is_convertible<OtherPointerLike, PointerLike>::value &&
+              std::is_constructible<PointerLike, OtherPointerLike &&>::value,
+          bool>::type = true>
+  explicit PropagateConst(PropagateConst<OtherPointerLike> &&U)
+      : Ptr_(std::move(llvm::get_underlying(U))) {}
+
+  template <
+      class OtherPointerLike,
+      typename std::enable_if<
+          std::is_convertible<OtherPointerLike, PointerLike>::value &&
+              std::is_constructible<PointerLike, OtherPointerLike &&>::value,
+          bool>::type = false>
+  PropagateConst(PropagateConst<OtherPointerLike> &&U)
+      : Ptr_(std::move(llvm::get_underlying(U))) {}
+
+  template <
+      class OtherPointerLike,
+      typename std::enable_if<
+          !std::is_convertible<OtherPointerLike, PointerLike>::value &&
+              std::is_constructible<PointerLike, OtherPointerLike>::value &&
+              !isPropagateConst<
+                  typename std::decay<OtherPointerLike>::type>::value,
+          bool>::type = true>
+  explicit PropagateConst(OtherPointerLike &&__u)
+      : Ptr_(std::forward<OtherPointerLike>(__u)) {}
+
+  template <
+      class OtherPointerLike,
+      typename std::enable_if<
+          std::is_convertible<OtherPointerLike, PointerLike>::value &&
+              std::is_constructible<PointerLike, OtherPointerLike>::value &&
+              !isPropagateConst<
+                  typename std::decay<OtherPointerLike>::type>::value,
+          bool>::type = false>
+  PropagateConst(OtherPointerLike &&__u)
+      : Ptr_(std::forward<OtherPointerLike>(__u)) {}
+
+  PropagateConst &operator=(const PropagateConst &) = delete;
+
+  PropagateConst &operator=(PropagateConst &&) = default;
+
+  template <class OtherPointerLike>
+  PropagateConst &operator=(PropagateConst<OtherPointerLike> &&U) {
+    Ptr_ = std::move(llvm::get_underlying(U));
+    return *this;
+  }
+
+  template <class OtherPointerLike,
+            class = std::enable_if<!isPropagateConst<
+                typename std::decay<OtherPointerLike>::type>::value>>
+  PropagateConst &operator=(OtherPointerLike &&__u) {
+    Ptr_ = std::forward<OtherPointerLike>(__u);
+    return *this;
+  }
+
+  const element_type *get() const { return getPointer(Ptr_); }
+
+  element_type *get() { return getPointer(Ptr_); }
+
+  explicit operator bool() const { return get() != nullptr; }
+
+  const element_type *operator->() const { return get(); }
+
+  template <class PointerLike_ = PointerLike,
+            class OtherPointerLike = std::enable_if<std::is_convertible<
+                const PointerLike_, const element_type *>::value>>
+  operator const element_type *() const {
+    return get();
+  }
+
+  const element_type &operator*() const { return *get(); }
+
+  element_type *operator->() { return get(); }
+
+  template <class PointerLike_ = PointerLike,
+            class OtherPointerLike = std::enable_if<
+                std::is_convertible<PointerLike_, element_type *>::value>>
+  operator element_type *() {
+    return get();
+  }
+
+  element_type &operator*() { return *get(); }
+
+  void swap(PropagateConst &P) {
+    using std::swap;
+    swap(Ptr_, P.Ptr_);
+  }
+
+  friend void swap(PropagateConst& lhs, PropagateConst& rhs)
+  {
+    using std::swap;
+    swap(lhs.Ptr_, rhs.Ptr_);
+  }
+};
+
+} // namespace llvm

llvm/unittests/ADT/CMakeLists.txt

set(ADTSources
   OptionalTest.cpp
   PackedVectorTest.cpp
   PointerEmbeddedIntTest.cpp
   PointerIntPairTest.cpp
   PointerSumTypeTest.cpp
   PointerUnionTest.cpp
   PostOrderIteratorTest.cpp
   PriorityWorklistTest.cpp
+  PropagateConstTest.cpp
   RangeAdapterTest.cpp
   SCCIteratorTest.cpp
   STLExtrasTest.cpp
   ScopeExitTest.cpp
   SequenceTest.cpp
   SetVectorTest.cpp
   SimpleIListTest.cpp
   SmallPtrSetTest.cpp

llvm/unittests/ADT/PropagateConstTest.cpp

+//===-*- C++ -*-===//
+//=- llvm/unittest/ADT/PropagateConstTest.cpp - PropagateConst unit tests -===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/PropagateConst.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+enum class ConstQualifier { Const, NonConst };
+
+struct A {
+  ConstQualifier foo() const { return ConstQualifier::Const; }
+
+  ConstQualifier foo() { return ConstQualifier::NonConst; }
+};
+  
+struct B : A {};
+
+TEST(PropagateConst, NonConstPropagation) {
+  A a;
+  llvm::PropagateConst<A *> pc(&a);
+
+  EXPECT_EQ(pc->foo(), ConstQualifier::NonConst);
+  EXPECT_EQ(pc.get()->foo(), ConstQualifier::NonConst);
+  EXPECT_EQ((*pc).foo(), ConstQualifier::NonConst);
+}
+
+TEST(PropagateConst, ConstPropagation) {
+  A a;
+  const llvm::PropagateConst<A *> pc(&a);
+
+  EXPECT_EQ(pc->foo(), ConstQualifier::Const);
+  EXPECT_EQ(pc.get()->foo(), ConstQualifier::Const);
+  EXPECT_EQ((*pc).foo(), ConstQualifier::Const);
+}
+
+TEST(PropagateConst, DefaultConstruction) {
+  // Use std::unique_ptr as the default constructor of PropagateConst<A*> does
+  // not zero-initialise the member pointer.
+  llvm::PropagateConst<std::unique_ptr<A>> pc;
+
+  EXPECT_FALSE(pc);
+}
+
+TEST(PropagateConst, OperatorBool) {
+  A a;
+  llvm::PropagateConst<A *> pc(&a);
+
+  EXPECT_TRUE(pc);
+}
+
+TEST(PropagateConst, MoveConstruction) {
+  PropagateConst<std::unique_ptr<A>> pc1(llvm::make_unique<A>());
+  PropagateConst<std::unique_ptr<A>> pc2(std::move(pc1));
+
+  EXPECT_FALSE(pc1);
+  EXPECT_TRUE(pc2);
+}
+
+TEST(PropagateConst, MoveAssignment) {
+  PropagateConst<std::unique_ptr<A>> pc1(llvm::make_unique<A>());
+  PropagateConst<std::unique_ptr<A>> pc2;
+  pc2 = std::move(pc1);
+
+  EXPECT_FALSE(pc1);
+  EXPECT_TRUE(pc2);
+}
+
+TEST(PropagateConst, ConvertingConstructor) {
+  B b;
+
+  PropagateConst<A*> pc(&b);
+
+  EXPECT_TRUE(pc);
+}
+
+TEST(PropagateConst, ExplicitConvertingConstructor) {
+  PropagateConst<std::unique_ptr<A>> pc(new A());
+
+  EXPECT_TRUE(pc);
+}
+
+TEST(PropagateConst, MemberSwap) {
+  PropagateConst<std::unique_ptr<A>> pc1;
+  PropagateConst<std::unique_ptr<A>> pc2(new A());
+
+  A* p = pc2.get();
+
+  pc1.swap(pc2);
+
+  EXPECT_EQ(pc1.get(), p);
+}
+
+TEST(PropagateConst, Swap) {
+  PropagateConst<std::unique_ptr<A>> pc1;
+  PropagateConst<std::unique_ptr<A>> pc2(new A());
+
+  A* p = pc2.get();
+
+  using std::swap;
+  swap(pc1, pc2);
+
+  EXPECT_EQ(pc1.get(), p);
+}
+
+} // end anonymous namespace
+