[libc++] Fix PR 31938 - std::basic_string constructors use non-deductible parameter types.

[EricWF]

Summary

This patch fixes http://llvm.org/PR31938. The description below is copy/pasted from the bug:

The standard says:

template<class charT, class traits = char_traits<charT>,

class Allocator = allocator<charT>>

class basic_string {

using value_type = typename traits::char_type;
// ...
basic_string(const charT* s, const Allocator& a = Allocator());

};

libc++ actually chooses to declare the constructor as

basic_string(const value_type* s, const Allocator& a = Allocator());

The implicit deduction guides from class template argument deduction make what was previously an implementation detail visible:

std::basic_string s = "foo"; // error, can't deduce charT.

The constructor in question is in the libc++ DSO, but fortunately it looks like fixing this will not result in an ABI break.

@rsmith How does this look? I did more than just the constructors mentioned in the PR, but IDK how far to take it.

[rsmith]

Looks good, though there are some value_type constructors left. I've not checked the standard to see if they are all declared with charT.

include/string

782

Did you skip this one intentionally?

788

Likewise these two.

812

And these

[EricWF]

include/string

782

Yes. size_type is a typedef for allocator_traits<Allocator>::size_type, This causes the basic_string(CharT*, Allocator const&) to always be chosen instead, resulting in a incorrect allocator type.

788

I thought they would suffer the same fate as the above overload but that is not the case. I'll update after reviewing each constructor.

812

Just making sure I was on the right track first.

[EricWF]

• Fix the initializer list constructors.
• Add tests for almost every constructor.

The following two examples still do not work:

std::basic_string s1("hello world", 2); // deduces Allocator = int
std::basic_string s2("hello world", 0, 2); // deduces Allocator = int

This is because the Allocator argument is not normally deduced, and
therefore would not normally accept an integer argument.

[rsmith]

include/string

782

I don't think it will always be chosen instead; if the argument is of type size_t, the (const CharT*, size_type) overload should be chosen.

[EricWF]

include/string

782

OK, so it's not that it should always be taken. Instead I think any attempt to form the implicit deduction guide overloads for such a call will end up attempting to evaluate std::basic_string<char, char_traits<char>, unsigned long long> which is an ill-formed instantiation of basic_string.

So if building the overload set were to succeed then yes, the (const CharT*, size_type) would be callable with an argument of size_type. However it seems that the overload set is poisoned by (const CharT*, Allocator)

[EricWF]

• Enumerate and test each constructor.

[rsmith]

Other than (5), all the failing cases look like they should fail per the current basic_string spec.

test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

58

I think that at least matches the standard as-is. I'm not sure this case is worth adding an explicit deduction guide for. *shrug*

108

Do you know why not?

292

I think the inability to deduce using this overload matches the standard. I don't think there's any way in general to map the type T to a charT.

[EricWF]

test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

58

I agree this probably matches the standard as-is, and that it's probably not worth adding an explicit guide for.
In general I don't think libc++ should add *any* explicit guides until the are required by the standard.

I'll remove the FIXME and clarify the comment before committing.

108

Yeah. It seems to choose the basic_string(size_type, CharT, const Allocator&) overload after deducing CharT and Allocator to be unsigned long.

The compiler diagnostics produced are:

/home/eric/workspace/libcxx/include/memory:1494:22: error: type 'allocator_type' (aka 'unsigned long') cannot be used prior to '::' because it has no members
    typedef typename allocator_type::value_type value_type;
                     ^
/home/eric/workspace/libcxx/include/string:788:28: note: in instantiation of template class 'std::__1::allocator_traits<unsigned long>' requested here
    basic_string(size_type __n, _CharT __c, const _Allocator& __a);
                           ^
/home/eric/workspace/libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp:111:23: note: while substituting deduced template arguments into function template '<deduction guide for basic_string>' [with _CharT = unsigned long, _Traits = (no value), _Allocator = unsigned long]
    std::basic_string s(sin, (size_t)1, (size_t)3);

292

OK. I'll update the comment before committing.

[EricWF]

• Clarify comments about conforming constructors that still don't support guides.

include/string

#if _LIBCPP_STD_VER <= 14
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #else
         _NOEXCEPT;
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     basic_string(basic_string&& __str, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY basic_string(const value_type* __s);
+    _LIBCPP_INLINE_VISIBILITY basic_string(const _CharT* __s);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(const value_type* __s, const allocator_type& __a);
+    basic_string(const _CharT* __s, const _Allocator& __a);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(const value_type* __s, size_type __n);
+    basic_string(const _CharT* __s, size_type __n);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(const value_type* __s, size_type __n, const allocator_type& __a);
+    basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(size_type __n, value_type __c);
+    basic_string(size_type __n, _CharT __c);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(size_type __n, value_type __c, const allocator_type& __a);
+    basic_string(size_type __n, _CharT __c, const _Allocator& __a);
     basic_string(const basic_string& __str, size_type __pos, size_type __n,
-                 const allocator_type& __a = allocator_type());
+                 const _Allocator& __a = _Allocator());
     _LIBCPP_INLINE_VISIBILITY
     basic_string(const basic_string& __str, size_type __pos,
-                 const allocator_type& __a = allocator_type());
+                 const _Allocator& __a = _Allocator());
     template<class _Tp>
-        basic_string(const _Tp& __t, size_type __pos, size_type __n, 
+        basic_string(const _Tp& __t, size_type __pos, size_type __n,
                      const allocator_type& __a = allocator_type(),
                      typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type* = 0);
     _LIBCPP_INLINE_VISIBILITY explicit
     basic_string(__self_view __sv);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(__self_view __sv, const allocator_type& __a);
+    basic_string(__self_view __sv, const _Allocator& __a);
     template<class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         basic_string(_InputIterator __first, _InputIterator __last);
     template<class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(initializer_list<value_type> __il);
+    basic_string(initializer_list<_CharT> __il);
     _LIBCPP_INLINE_VISIBILITY
-    basic_string(initializer_list<value_type> __il, const allocator_type& __a);
+    basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     inline ~basic_string();
 
     _LIBCPP_INLINE_VISIBILITY
     operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
 
     basic_string& operator=(const basic_string& __str);
else
         __set_long_size(__sz);
     }
     traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
     __init(__s, traits_type::length(__s));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
     : __r_(__a)
 {
     _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const value_type* __s, size_type __n, const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
     : __r_(__a)
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
     __init(__s, __n);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
     : __r_(__alloc_traits::select_on_container_copy_construction(__str.__alloc()))
 {
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(
+    const basic_string& __str, const allocator_type& __a)
     : __r_(__a)
 {
     if (!__str.__is_long())
         __r_.first().__r = __str.__r_.first().__r;
     else
         __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
else
         __set_long_size(__n);
     }
     traits_type::assign(_VSTD::__to_raw_pointer(__p), __n, __c);
     traits_type::assign(__p[__n], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
 {
     __init(__n, __c);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, value_type __c, const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
     : __r_(__a)
 {
     __init(__n, __c);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, size_type __n,
-                                                        const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
+                                                        size_type __pos, size_type __n,
+                                                        const _Allocator& __a)
     : __r_(__a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
-                                                        const allocator_type& __a)
+                                                        const _Allocator& __a)
     : __r_(__a)
 {
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
     __init(__str.data() + __pos, __str_sz - __pos);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
              const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a,
        typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type *)
     : __r_(__a)
 {
   __self_view __sv = __self_view(__t).substr(__pos, __n);
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
-#endif  
+#endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv)
 {
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv, const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv, const _Allocator& __a)
     : __r_(__a)
 {
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
#if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(
+    initializer_list<_CharT> __il)
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il, const allocator_type& __a)
+basic_string<_CharT, _Traits, _Allocator>::basic_string(
+    initializer_list<_CharT> __il, const _Allocator& __a)
+
     : __r_(__a)
 {
     __init(__il.begin(), __il.end());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 

test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// <string>
+
+// Test that the constructors offered by std::basic_string are formulated
+// so they're compatible with implicit deduction guides.
+
+#include <string>
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "constexpr_char_traits.hpp"
+
+template <class T, class Alloc = std::allocator<T>>
+using BStr = std::basic_string<T, std::char_traits<T>, Alloc>;
+
+// Overloads
+//  using A = Allocator;
+//  using BS = basic_string
+//  using BSV = basic_string_view
+// ---------------
+// (1)  basic_string() - NOT TESTED
+// (2)  basic_string(A const&) - BROKEN
+// (3)  basic_string(size_type, CharT, const A& = A())
+// (4)  basic_string(BS const&, size_type, A const& = A())
+// (5)  basic_string(BS const&, size_type, size_type, A const& = A()) - PARTIALLY BROKEN
+// (6)  basic_string(const CharT*, size_type, A const& = A())
+// (7)  basic_string(const CharT*, A const& = A())
+// (8)  basic_string(InputIt, InputIt, A const& = A()) - BROKEN
+// (9)  basic_string(BS const&)
+// (10) basic_string(BS const&, A const&)
+// (11) basic_string(BS&&)
+// (12) basic_string(BS&&, A const&)
+// (13) basic_string(initializer_list<CharT>, A const& = A())
+// (14) basic_string(BSV, A const& = A())
+// (15) basic_string(const T&, size_type, size_type, A const& = A()) - BROKEN
+int main()
+{
+  using TestSizeT = test_allocator<char>::size_type;
+  { // Testing (1)
+    // Nothing TODO. Cannot deduce without any arguments.
+  }
+  { // Testing (2)
+    // This overload isn't compatible with implicit deduction guides as
+    // specified in the standard.
+    // const test_allocator<char> alloc{};
+    // std::basic_string s(alloc);
+  }
+  { // Testing (3) w/o allocator
+    std::basic_string s(6ull, 'a');
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "aaaaaa");
+
+    std::basic_string w(2ull, L'b');
+    ASSERT_SAME_TYPE(decltype(w), std::wstring);
+    assert(w == L"bb");
+  }
+  { // Testing (3) w/ allocator
+    std::basic_string s(6ull, 'a', test_allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), BStr<char,test_allocator<char>>);
+    assert(s == "aaaaaa");
+
+    std::basic_string w(2ull, L'b', test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t>>);
+    assert(w == L"bb");
+  }
+  { // Testing (4) w/o allocator
+    const std::string sin("abc");
+    std::basic_string s(sin, (size_t)1);
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "bc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    const WStr win(L"abcdef");
+    std::basic_string w(win, (TestSizeT)3);
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"def");
+  }
+  { // Testing (4) w/ allocator
+    const std::string sin("abc");
+    std::basic_string s(sin, (size_t)1, std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "bc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    const WStr win(L"abcdef");
+    std::basic_string w(win, (TestSizeT)3, test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"def");
+  }
+  { // Testing (5) w/o allocator
+#if 0 // FIXME: This doesn't work
+    const std::string sin("abc");
+    std::basic_string s(sin, (size_t)1, (size_t)3);
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "bc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    const WStr win(L"abcdef");
+    std::basic_string w(win, (TestSizeT)2, (TestSizeT)3);
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"cde");
+#endif
+  }
+  { // Testing (5) w/ allocator
+    const std::string sin("abc");
+    std::basic_string s(sin, (size_t)1, (size_t)3, std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "bc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    const WStr win(L"abcdef");
+    std::basic_string w(win, (TestSizeT)2, (TestSizeT)3, test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"cde");
+  }
+  { // Testing (6) w/o allocator
+    std::basic_string s("abc", (size_t)2);
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "ab");
+
+    std::basic_string w(L"abcdef", (size_t)3);
+    ASSERT_SAME_TYPE(decltype(w), std::wstring);
+    assert(w == L"abc");
+  }
+  { // Testing (6) w/ allocator
+    std::basic_string s("abc", (size_t)2, std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "ab");
+
+    using WStr = std::basic_string<wchar_t,
+                                  std::char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    std::basic_string w(L"abcdef", (TestSizeT)3, test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"abc");
+  }
+  { // Testing (7) w/o allocator
+    std::basic_string s("abc");
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    std::basic_string w(L"abcdef");
+    ASSERT_SAME_TYPE(decltype(w), std::wstring);
+    assert(w == L"abcdef");
+  }
+  { // Testing (7) w/ allocator
+    std::basic_string s("abc", std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  std::char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    std::basic_string w(L"abcdef", test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"abcdef");
+  }
+  { // (8) w/o allocator
+    // This overload isn't compatible with implicit deduction guides as
+    // specified in the standard.
+    // FIXME: Propose adding an explicit guide to the standard?
+  }
+  { // (8) w/ allocator
+    // This overload isn't compatible with implicit deduction guides as
+    // specified in the standard.
+    // FIXME: Propose adding an explicit guide to the standard?
+#if 0
+    using It = input_iterator<const char*>;
+    const char* input = "abcdef";
+    std::basic_string s(It(input), It(input + 3), std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+#endif
+  }
+  { // Testing (9)
+    const std::string sin("abc");
+    std::basic_string s(sin);
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    const WStr win(L"abcdef");
+    std::basic_string w(win);
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"abcdef");
+  }
+  { // Testing (10)
+    const std::string sin("abc");
+    std::basic_string s(sin, std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    const WStr win(L"abcdef");
+    std::basic_string w(win, test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"abcdef");
+  }
+  { // Testing (11)
+    std::string sin("abc");
+    std::basic_string s(std::move(sin));
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    WStr win(L"abcdef");
+    std::basic_string w(std::move(win));
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"abcdef");
+  }
+  { // Testing (12)
+    std::string sin("abc");
+    std::basic_string s(std::move(sin), std::allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    using WStr = std::basic_string<wchar_t,
+                                  constexpr_char_traits<wchar_t>,
+                                  test_allocator<wchar_t>>;
+    WStr win(L"abcdef");
+    std::basic_string w(std::move(win), test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), WStr);
+    assert(w == L"abcdef");
+  }
+  { // Testing (13) w/o allocator
+    std::basic_string s({'a', 'b', 'c'});
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    std::basic_string w({L'a', L'b', L'c'});
+    ASSERT_SAME_TYPE(decltype(w), std::wstring);
+    assert(w == L"abc");
+  }
+  { // Testing (13) w/ allocator
+    std::basic_string s({'a', 'b', 'c'}, test_allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), BStr<char, test_allocator<char>>);
+    assert(s == "abc");
+
+    std::basic_string w({L'a', L'b', L'c'}, test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), BStr<wchar_t, test_allocator<wchar_t>>);
+    assert(w == L"abc");
+  }
+  { // Testing (14) w/o allocator
+    std::string_view sv("abc");
+    std::basic_string s(sv);
+    ASSERT_SAME_TYPE(decltype(s), std::string);
+    assert(s == "abc");
+
+    using Expect = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>>;
+    std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>> BSV(L"abcdef");
+    std::basic_string w(BSV);
+    ASSERT_SAME_TYPE(decltype(w), Expect);
+    assert(w == L"abcdef");
+  }
+  { // Testing (14) w/ allocator
+    using ExpectS = std::basic_string<char, std::char_traits<char>, test_allocator<char>>;
+    std::string_view sv("abc");
+    std::basic_string s(sv, test_allocator<char>{});
+    ASSERT_SAME_TYPE(decltype(s), ExpectS);
+    assert(s == "abc");
+
+    using ExpectW = std::basic_string<wchar_t, constexpr_char_traits<wchar_t>,
+                                      test_allocator<wchar_t>>;
+    std::basic_string_view<wchar_t, constexpr_char_traits<wchar_t>> BSV(L"abcdef");
+    std::basic_string w(BSV, test_allocator<wchar_t>{});
+    ASSERT_SAME_TYPE(decltype(w), ExpectW);
+    assert(w == L"abcdef");
+  }
+  { // Testing (15)
+    // This overload isn't compatible with implicit deduction guides as
+    // specified in the standard.
+  }
+}

test/support/constexpr_char_traits.hpp

 // -*- C++ -*-
 //===-------------------- constexpr_char_traits ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _CONSTEXPR_CHAR_TRAITS
 #define _CONSTEXPR_CHAR_TRAITS
 
 #include <string>
+#include <cassert>
 
 #include "test_macros.h"
 
 template <class _CharT>
 struct constexpr_char_traits
 {
     typedef _CharT    char_type;
     typedef int       int_type;
constexpr_char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
     }
     return __r;
 }
 
 template <class _CharT>
 TEST_CONSTEXPR_CXX14 _CharT*
 constexpr_char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
-    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+    assert(__s2 < __s1 || __s2 >= __s1+__n);
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
 template <class _CharT>
 TEST_CONSTEXPR_CXX14 _CharT*

utils/libcxx/test/config.py

def configure_features(self):
 
         macros = self.cxx.dumpMacros()
         if '__cpp_if_constexpr' not in macros:
             self.config.available_features.add('libcpp-no-if-constexpr')
 
         if '__cpp_structured_bindings' not in macros:
             self.config.available_features.add('libcpp-no-structured-bindings')
 
+        if '__cpp_deduction_guides' not in macros:
+            self.config.available_features.add('libcpp-no-deduction-guides')
+
         if self.is_windows:
             self.config.available_features.add('windows')
 
     def configure_compile_flags(self):
         no_default_flags = self.get_lit_bool('no_default_flags', False)
         if not no_default_flags:
             self.configure_default_compile_flags()
         # This include is always needed so add so add it regardless of