[libc++] [LIBCXX-DEBUG-FIXME] Iterating a string::iterator "off the end" is UB.

[• Quuxplusone]

Summary

The range of char pointers [data, data+size] is a valid closed range,
but the range [begin, end) is valid only half-open.

[• Quuxplusone]

poke buildkite

[krisb]

LGTM, but it may be worth adding a comment since it really looks like a valid case until realizing that dereferencing end() is UB.

[ldionne]

Explanation of the change for others who might not have understood it (Arthur explained it to me offline cause I didn't get it):

In3 is an iterator equal to In2.begin(). We're using overload (5) from https://en.cppreference.com/w/cpp/filesystem/path/path , which expects "a pointer or an input iterator to a null-terminated character/wide character sequence". In2.data() fits that description, because it's a raw char*; but In2.begin() doesn't, because it's an iterator to a character sequence that is not null-terminated. Getting to the null terminator requires iterating "off the end" of the valid range and dereferencing In2.begin() + In2.size(), which is In2.end(), which is not dereferenceable.

So, with debug iterators, that "off the end" iteration fails a _LIBCPP_ASSERT; but even without debug iterators, technically, it's library UB for the test case to be trying to do it.

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: LIBCXX-DEBUG-FIXME
-
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // <filesystem>
 
 // template <class Source>
 //    path u8path(Source const&);
 // template <class InputIter>
const auto In3End = In2.end();
     path p = fs::u8path(In1);
     assert(p == In1);
   }
   {
     path p = fs::u8path(In2);
     assert(p == In1);
   }
   {
-    path p = fs::u8path(In3);
+    path p = fs::u8path(In2.data());
     assert(p == In1);
   }
   {
     path p = fs::u8path(In3, In3End);
     assert(p == In1);
   }
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t) && defined(_LIBCPP_VERSION) && \
     !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   const char8_t* u8In1 = u8"abcd/efg";
   const std::u8string u8In2(u8In1);
   const auto u8In3 = u8In2.begin();
   const auto u8In3End = u8In2.end();
   // Proposed in P1423, marked tested only for libc++
   {
     path p = fs::u8path(u8In1);
     assert(p == In1);
   }
   {
     path p = fs::u8path(u8In2);
     assert(p == In1);
   }
   {
-    path p = fs::u8path(u8In3);
+    path p = fs::u8path(u8In2.data());
     assert(p == In1);
   }
   {
     path p = fs::u8path(u8In3, u8In3End);
     assert(p == In1);
   }
 #endif
 
   return 0;
 }