[libc++] Diagnose null inputs in std::string using _LIBCPP_DIAGNOSE_WARNING

[EricWF]

Summary

This patch uses diagnose_if to attempt to catch null inputs in std::string. Note that unlike __attribute__((non_null)) diagnose_if does not affect codegen.

[grandinj]

would it be better to internally treat attribute((non_null)) like diagnose_if ? then you get all the warnings for free?

[EricWF]

In D28716#646274, @grandinj wrote:

would it be better to internally treat attribute((non_null)) like diagnose_if ? then you get all the warnings for free?

There were previous objections about using non_null within libc++ due to the affect on code gen. That's why I choose to use diagose_if here.
However the previous objections weren't about std::string, so maybe the consensus would be different here? I'll ping @mclow.lists about this.

Note: Some of these non-null diagnostics depend on the second condition size > 0, which can't be done with non-null.

include/string

#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     basic_string& operator=(const basic_string& __str);
     _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(__self_view __sv)  {return assign(__sv);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(basic_string&& __str)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
 #endif
-    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
+    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s)
+      _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
+    {return assign(__s);}
     basic_string& operator=(value_type __c);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 #if _LIBCPP_DEBUG_LEVEL >= 2
     _LIBCPP_INLINE_VISIBILITY
basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __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)
 {
+    // FIXME: Add _LIBCPP_DIAGNOSE_WARNING
     _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 value_type* __s,
+                                                        const allocator_type& __a)
     : __r_(__a)
 {
+    // FIXME: Add _LIBCPP_DIAGNOSE_WARNING
     _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 value_type* __s,
+                                                        size_type __n)
 {
+    // FIXME: Add _LIBCPP_DIAGNOSE_WARNING
     _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 value_type* __s,
+                                                        size_type __n,
+                                                        const allocator_type& __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
 }
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
basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
     __set_long_cap(__cap+1);
 }
 
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
     size_type __cap = capacity();
     if (__cap >= __n)
     {
         value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
         traits_type::move(__p, __s, __n);
         traits_type::assign(__p[__n], value_type());
if (__pos > __sz)
         this->__throw_out_of_range();
     return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
 }
 
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
     return assign(__s, traits_type::length(__s));
 }
 
 // append
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
     size_type __cap = capacity();
     size_type __sz = size();
     if (__cap - __sz >= __n)
     {
         if (__n)
         {
basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
         if ( __ptr_in_range(&*__first, data(), data() + size()))
         {
             const basic_string __temp (__first, __last, __alloc());
             append(__temp.data(), __temp.size());
         }
-        else 
+        else
         {
             if (__cap - __sz < __n)
                 __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
             pointer __p = __get_pointer() + __sz;
             for (; __first != __last; ++__p, ++__first)
                 traits_type::assign(*__p, *__first);
             traits_type::assign(*__p, value_type());
             __set_size(__sz + __n);
basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
     if (__pos > __sz)
         this->__throw_out_of_range();
     return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
     return append(__s, traits_type::length(__s));
 }
 
 // insert
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos,
+                                                  const value_type* __s,
+                                                  size_type __n)
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
     size_type __cap = capacity();
     if (__cap - __sz >= __n)
     {
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
     if (__pos2 > __str_sz)
         this->__throw_out_of_range();
     return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
     return insert(__pos, __s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
#endif
     insert(static_cast<size_type>(__p), __n, __c);
     return begin() + __p;
 }
 
 // replace
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
+basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos,
+                                                   size_type __n1,
+                                                   const value_type* __s,
+                                                   size_type __n2)
+  _LIBCPP_DIAGNOSE_WARNING(__n2 > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
     __n1 = _VSTD::min(__n1, __sz - __pos);
     size_type __cap = capacity();
     if (__cap - __sz + __n1 >= __n2)
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
     size_type __str_sz = __sv.size();
     if (__pos2 > __str_sz)
         this->__throw_out_of_range();
     return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
+basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos,
+                                                   size_type __n1,
+                                                   const value_type* __s)
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
     return replace(__pos, __n1, __s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _Traits, _Allocator>&
bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
         {return _Traits::eq(__x, __y);}
 };
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos,
                                                 size_type __n) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
     return __str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
return __str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
                                                 size_type __pos) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
     return __str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
                                                 size_type __pos) const _NOEXCEPT
 {
     return __str_find<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // rfind
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos,
                                                  size_type __n) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
     return __str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
return __str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
                                                  size_type __pos) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
     return __str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
                                                  size_type __pos) const _NOEXCEPT
 {
     return __str_rfind<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // find_first_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos,
                                                          size_type __n) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
     return __str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
return __str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
                                                          size_type __pos) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
     return __str_find_first_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
                                                          size_type __pos) const _NOEXCEPT
 {
     return find(__c, __pos);
 }
 
 // find_last_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos,
                                                         size_type __n) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
     return __str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
return __str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
                                                         size_type __pos) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
     return __str_find_last_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
                                                         size_type __pos) const _NOEXCEPT
 {
     return rfind(__c, __pos);
 }
 
 // find_first_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos,
                                                              size_type __n) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
return __str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
                                                              size_type __pos) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
                                                              size_type __pos) const _NOEXCEPT
 {
     return __str_find_first_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __c, __pos);
 }
 
 // find_last_not_of
 
 template<class _CharT, class _Traits, class _Allocator>
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos,
                                                             size_type __n) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__n > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
     return __str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, __n);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
return __str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __sv.data(), __pos, __sv.size());
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
                                                             size_type __pos) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
     return __str_find_last_not_of<value_type, size_type, traits_type, npos>
         (data(), size(), __s, __pos, traits_type::length(__s));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY

 }
 
 template <class _CharT, class _Traits, class _Allocator>
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
                                                    const value_type* __s,
                                                    size_type __n2) const
+  _LIBCPP_DIAGNOSE_WARNING(__n2 > 0 && __s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
     size_type __sz = size();
     if (__pos1 > __sz || __n2 == npos)
         this->__throw_out_of_range();
     size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
     int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
     if (__r == 0)
basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n2) const
 {
         return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
     return compare(0, npos, __s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 int
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
                                                    const value_type* __s) const
+  _LIBCPP_DIAGNOSE_WARNING(__s == nullptr, "pointer cannot be null")
 {
     _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
     return compare(__pos1, __n1, __s, traits_type::length(__s));
 }
 
 // __invariants
 
 template<class _CharT, class _Traits, class _Allocator>
operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
     return true;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__lhs == nullptr, "pointer cannot be null")
 {
     typedef basic_string<_CharT, _Traits, _Allocator> _String;
     _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
     size_t __lhs_len = _Traits::length(__lhs);
     if (__lhs_len != __rhs.size()) return false;
     return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__rhs == nullptr, "pointer cannot be null")
 {
     typedef basic_string<_CharT, _Traits, _Allocator> _String;
     _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
     size_t __rhs_len = _Traits::length(__rhs);
     if (__rhs_len != __lhs.size()) return false;
     return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return !(__lhs == __rhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__lhs == nullptr, "pointer cannot be null")
 {
     return !(__lhs == __rhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__rhs == nullptr, "pointer cannot be null")
 {
     return !(__lhs == __rhs);
 }
 
 // operator<
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return __lhs.compare(__rhs) < 0;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__rhs == nullptr, "pointer cannot be null")
 {
     return __lhs.compare(__rhs) < 0;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__lhs == nullptr, "pointer cannot be null")
 {
     return __rhs.compare(__lhs) > 0;
 }
 
 // operator>
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return __rhs < __lhs;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__rhs == nullptr, "pointer cannot be null")
 {
     return __rhs < __lhs;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__lhs == nullptr, "pointer cannot be null")
 {
     return __rhs < __lhs;
 }
 
 // operator<=
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return !(__rhs < __lhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__rhs == nullptr, "pointer cannot be null")
 {
     return !(__rhs < __lhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__lhs == nullptr, "pointer cannot be null")
 {
     return !(__rhs < __lhs);
 }
 
 // operator>=
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
 {
     return !(__lhs < __rhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
            const _CharT* __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__rhs == nullptr, "pointer cannot be null")
 {
     return !(__lhs < __rhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const _CharT* __lhs,
            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
+  _LIBCPP_DIAGNOSE_WARNING(__lhs == nullptr, "pointer cannot be null")
 {
     return !(__lhs < __rhs);
 }
 
 // operator +
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>

test/libcxx/strings/diagnose_null_pointer.fail.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
+// REQUIRES: diagnose-if-support, verify-support
+
+// Test that libc++ generates a warning diagnostic when the container is
+// provided a non-const callable comparator.
+
+#include <string>
+#include <memory>
+
+void test_constructors() {
+#if 0 // FIXME: Add diagnose_if to string constructors
+  std::string s1(nullptr); // expected-warning 1+ {{cannot construct string from a null pointer}}
+  std::string s2(nullptr, std::allocator<char>()); // expected-warning 1+ {{cannot construct string from a null pointer}}
+  std::string s3(nullptr, 0);
+  std::string s4(nullptr, 1); // expected-warning 1+ {{cannot construct string from a null pointer}}
+  std::string s5(nullptr, 0, std::allocator<char>());
+  std::string s6(nullptr, 1, std::allocator<char>()); // expected-warning 1+ {{cannot construct string from a null pointer}}
+#endif
+}
+
+void test_assignment() {
+  std::string s1;
+  s1 = nullptr; // expected-warning 1+ {{pointer cannot be null}}
+  s1.assign(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+  s1.assign(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_append() {
+  std::string s;
+  s.append(nullptr, 0);
+  s.append(nullptr, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.append(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_insert() {
+  std::string s;
+  s.insert(0, nullptr, 0); // OK
+  s.insert(0, nullptr, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.insert(0, nullptr); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_replace() {
+  std::string s;
+  s.replace(0, 0, nullptr, 0);
+  s.replace(0, 0, nullptr, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.replace(0, 0, nullptr); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_find() {
+  std::string s;
+  s.find(nullptr, 0, 0);
+  s.find(nullptr, 0, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.find(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_rfind() {
+  std::string s;
+  s.rfind(nullptr, 0, 0);
+  s.rfind(nullptr, 0, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.rfind(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_find_first_of() {
+  std::string s;
+  s.find_first_of(nullptr, 0, 0);
+  s.find_first_of(nullptr, 0, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.find_first_of(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_find_last_of() {
+  std::string s;
+  s.find_last_of(nullptr, 0, 0);
+  s.find_last_of(nullptr, 0, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.find_last_of(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+
+void test_find_first_not_of() {
+  std::string s;
+  s.find_first_not_of(nullptr, 0, 0);
+  s.find_first_not_of(nullptr, 0, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.find_first_not_of(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_find_last_not_of() {
+  std::string s;
+  s.find_last_not_of(nullptr, 0, 0);
+  s.find_last_not_of(nullptr, 0, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.find_last_not_of(nullptr, 0); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+void test_compare() {
+  std::string s;
+  s.compare(0, 0, nullptr, 0);
+  s.compare(0, 0, nullptr, 1); // expected-warning 1+ {{pointer cannot be null}}
+  s.compare(0, 0, nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  s.compare(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+}
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-comparison"
+#endif
+
+void test_comparison_operators() {
+  std::string s;
+  s == static_cast<char const*>(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  static_cast<char const*>(nullptr) == s; // expected-warning 1+ {{pointer cannot be null}}
+  s != static_cast<char const*>(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  static_cast<char const*>(nullptr) != s; // expected-warning 1+ {{pointer cannot be null}}
+  s < static_cast<char const*>(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  static_cast<char const*>(nullptr) < s; // expected-warning 1+ {{pointer cannot be null}}
+  s <= static_cast<char const*>(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  static_cast<char const*>(nullptr) <= s; // expected-warning 1+ {{pointer cannot be null}}
+  s > static_cast<char const*>(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  static_cast<char const*>(nullptr) > s; // expected-warning 1+ {{pointer cannot be null}}
+  s >= static_cast<char const*>(nullptr); // expected-warning 1+ {{pointer cannot be null}}
+  static_cast<char const*>(nullptr) >= s; // expected-warning 1+ {{pointer cannot be null}}
+}
+
+int main() {
+  test_constructors();
+  test_assignment();
+  test_append();
+  test_insert();
+  test_replace();
+  test_find();
+  test_rfind();
+  test_find_first_of();
+  test_find_last_of();
+  test_find_first_not_of();
+  test_find_last_not_of();
+  test_compare();
+  test_comparison_operators();
+}