[ArrayRef] Provide constructors from any type with a data() member #145735
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
The assumption here is that if data() returns a pointer and size() exists this is something representing a contiguous storage. This is modeled after the behavior of C++20 std::span and enables two-way conversion between std::span (or really any span-like type) and ArrayRef. Add a unit test that verifies this if std::span is around. This also means we can get rid of specific conversions for std::vector and SmallVector.
|
@llvm/pr-subscribers-llvm-adt Author: Benjamin Kramer (d0k) ChangesThe assumption here is that if data() returns a pointer and size() Modeled after the behavior of C++20 std::span and enables two-way This also means we can get rid of specific conversions for std::vector Full diff: https://github.com/llvm/llvm-project/pull/145735.diff 2 Files Affected:
diff --git a/llvm/include/llvm/ADT/ArrayRef.h b/llvm/include/llvm/ADT/ArrayRef.h
index 4819c88471345..ddd2c7ce68c83 100644
--- a/llvm/include/llvm/ADT/ArrayRef.h
+++ b/llvm/include/llvm/ADT/ArrayRef.h
@@ -84,18 +84,19 @@ namespace llvm {
assert(begin <= end);
}
- /// Construct an ArrayRef from a SmallVector. This is templated in order to
- /// avoid instantiating SmallVectorTemplateCommon<T> whenever we
- /// copy-construct an ArrayRef.
- template<typename U>
- /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
- : Data(Vec.data()), Length(Vec.size()) {
- }
-
- /// Construct an ArrayRef from a std::vector.
- template<typename A>
- /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
- : Data(Vec.data()), Length(Vec.size()) {}
+ /// Construct an ArrayRef from a type that has a data() method that returns
+ /// a pointer convertible to const T *.
+ template <
+ typename C,
+ typename = std::enable_if_t<
+ std::conjunction_v<
+ std::is_convertible<
+ decltype(std::declval<const C &>().data()) *,
+ const T *const *>,
+ std::is_integral<decltype(std::declval<const C &>().size())>>,
+ void>>
+ /*implicit*/ constexpr ArrayRef(const C &V)
+ : Data(V.data()), Length(V.size()) {}
/// Construct an ArrayRef from a std::array
template <size_t N>
@@ -123,32 +124,6 @@ namespace llvm {
#pragma GCC diagnostic pop
#endif
- /// Construct an ArrayRef<const T*> from ArrayRef<T*>. This uses SFINAE to
- /// ensure that only ArrayRefs of pointers can be converted.
- template <typename U>
- ArrayRef(const ArrayRef<U *> &A,
- std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
- * = nullptr)
- : Data(A.data()), Length(A.size()) {}
-
- /// Construct an ArrayRef<const T*> from a SmallVector<T*>. This is
- /// templated in order to avoid instantiating SmallVectorTemplateCommon<T>
- /// whenever we copy-construct an ArrayRef.
- template <typename U, typename DummyT>
- /*implicit*/ ArrayRef(
- const SmallVectorTemplateCommon<U *, DummyT> &Vec,
- std::enable_if_t<std::is_convertible<U *const *, T const *>::value> * =
- nullptr)
- : Data(Vec.data()), Length(Vec.size()) {}
-
- /// Construct an ArrayRef<const T*> from std::vector<T*>. This uses SFINAE
- /// to ensure that only vectors of pointers can be converted.
- template <typename U, typename A>
- ArrayRef(const std::vector<U *, A> &Vec,
- std::enable_if_t<std::is_convertible<U *const *, T const *>::value>
- * = nullptr)
- : Data(Vec.data()), Length(Vec.size()) {}
-
/// Construct an ArrayRef<T> from iterator_range<U*>. This uses SFINAE
/// to ensure that this is only used for iterator ranges over plain pointer
/// iterators.
diff --git a/llvm/unittests/ADT/ArrayRefTest.cpp b/llvm/unittests/ADT/ArrayRefTest.cpp
index 39a4a9b6a178c..3858d9064f9ca 100644
--- a/llvm/unittests/ADT/ArrayRefTest.cpp
+++ b/llvm/unittests/ADT/ArrayRefTest.cpp
@@ -8,10 +8,16 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Allocator.h"
-#include "llvm/Support/raw_ostream.h"
#include "gtest/gtest.h"
#include <limits>
#include <vector>
+#if __has_include(<version>)
+#include <version>
+#endif
+#ifdef __cpp_lib_span
+#include <span>
+#endif
+
using namespace llvm;
// Check that the ArrayRef-of-pointer converting constructor only allows adding
@@ -406,4 +412,15 @@ TEST(ArrayRefTest, MutableArrayRefDeductionGuides) {
}
}
+#ifdef __cpp_lib_span
+static_assert(std::is_constructible_v<ArrayRef<int>, std::span<const int>>,
+ "should be able to construct ArrayRef from const std::span");
+static_assert(std::is_constructible_v<std::span<const int>, ArrayRef<int>>,
+ "should be able to construct const std::span from ArrayRef");
+static_assert(std::is_constructible_v<ArrayRef<int>, std::span<int>>,
+ "should be able to construct ArrayRef from mutable std::span");
+static_assert(!std::is_constructible_v<std::span<int>, ArrayRef<int>>,
+ "cannot construct mutable std::span from ArrayRef");
+#endif
+
} // end anonymous namespace
|
kazutakahirata
approved these changes
Jun 25, 2025
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/18/builds/18011 Here is the relevant piece of the build log for the reference |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/92/builds/21259 Here is the relevant piece of the build log for the reference |
anthonyhatran
pushed a commit
to anthonyhatran/llvm-project
that referenced
this pull request
Jun 26, 2025
…lvm#145735) The assumption here is that if data() returns a pointer and size() exists it's something representing contiguous storage. Modeled after the behavior of C++20 std::span and enables two-way conversion between std::span (or really any span-like type) and ArrayRef. Add a unit test that verifies this if std::span is around. This also means we can get rid of specific conversions for std::vector and SmallVector.
rlavaee
pushed a commit
to rlavaee/llvm-project
that referenced
this pull request
Jul 1, 2025
…lvm#145735) The assumption here is that if data() returns a pointer and size() exists it's something representing contiguous storage. Modeled after the behavior of C++20 std::span and enables two-way conversion between std::span (or really any span-like type) and ArrayRef. Add a unit test that verifies this if std::span is around. This also means we can get rid of specific conversions for std::vector and SmallVector.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
The assumption here is that if data() returns a pointer and size()
exists it's something representing contiguous storage.
Modeled after the behavior of C++20 std::span and enables two-way
conversion between std::span (or really any span-like type) and
ArrayRef. Add a unit test that verifies this if std::span is around.
This also means we can get rid of specific conversions for std::vector
and SmallVector.