Revert "Revert "[libcxx][module-map] creates submodules for private headers""

[cjdb]

Summary

This reverts commit d9633f229c36f292dab0e5f510ac635cfaf3a798 as a
workaround was discovered.

[cjdb]

adds missing inclusion (not reproing locally for some reason)

[cjdb]

another failure not caught locally

[cjdb]

another failure not caught locally (not sure what's going on there)

[cjdb]

Finally managed to repro test failures locally. Still not confident this will pass: building with modules seemed to segfault, but it was also segfaulting when compiling vanilla ToT.

[cjdb]

Uncomments code that was commented out for debugging (tonight's not my night).

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI (runtimes build expected to fail since the addressof operator hasn't been moved around yet)

[cjdb]

moves addressof operator deletion

[cjdb]

adds addressof operators back, turns on XFAILs

[ldionne]

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/special_function.compile.pass.cpp

12 ↗

(On Diff #352228)

Those should be

// XFAIL: clang-11 && modules-build
// XFAIL: clang-12 && modules-build

[cjdb]

corrects XFAILs

[cjdb]

fixes test case that was failing

[cjdb]

fixes build failure

libcxx/include/__iterator/advance.h

 #ifndef _LIBCPP___ITERATOR_ADVANCE_H
 #define _LIBCPP___ITERATOR_ADVANCE_H
 
 #include <__config>
 #include <__debug>
 #include <__function_like.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <concepts>
 #include <limits>
 #include <type_traits>
 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/__iterator/next.h

 #ifndef _LIBCPP___ITERATOR_NEXT_H
 #define _LIBCPP___ITERATOR_NEXT_H
 
 #include <__config>
 #include <__function_like.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__iterator/prev.h

 #ifndef _LIBCPP___ITERATOR_PREV_H
 #define _LIBCPP___ITERATOR_PREV_H
 
 #include <__config>
 #include <__function_like.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/iterator_traits.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/allocation_guard.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_ALLOCATION_GUARD_H
 #define _LIBCPP___MEMORY_ALLOCATION_GUARD_H
 
 #include <__config>
 #include <__memory/allocator_traits.h>
 #include <cstddef>
+#include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/allocator.h

 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
 
+template <class _Tp>
+struct __is_default_allocator<allocator<_Tp> > : true_type { };
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___MEMORY_ALLOCATOR_H

libcxx/include/__memory/allocator_traits.h

#else
     using type = typename _Traits::template rebind_alloc<_Tp>::other;
 #endif
 };
 
 // __is_default_allocator
 template <class _Tp>
 struct __is_default_allocator : false_type { };
 
-template <class _Tp>
-struct __is_default_allocator<allocator<_Tp> > : true_type { };
-
 // __is_cpp17_move_insertable
 template <class _Alloc, class = void>
 struct __is_cpp17_move_insertable
     : is_move_constructible<typename _Alloc::value_type>
 { };
 
 template <class _Alloc>
 struct __is_cpp17_move_insertable<_Alloc, _EnableIf<

libcxx/include/__memory/pointer_safety.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_POINTER_SAFETY_H
 #define _LIBCPP___MEMORY_POINTER_SAFETY_H
 
 #include <__config>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__memory/pointer_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_POINTER_TRAITS_H
 #define _LIBCPP___MEMORY_POINTER_TRAITS_H
 
 #include <__config>
+#include <__memory/addressof.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

libcxx/include/module.modulemap

module chrono {
     header "chrono"
     export *
   }
   module codecvt {
     header "codecvt"
     export *
   }
   module compare {
+    requires cplusplus20
     header "compare"
     export *
   }
   module complex {
     header "complex"
     export *
   }
   module concepts {
+    requires cplusplus20
     header "concepts"
     export *
   }
   module condition_variable {
     header "condition_variable"
     export *
   }
   module deque {
module execution {
     header "execution"
     export *
   }
   module filesystem {
     header "filesystem"
     export *
   }
   module format {
+    requires cplusplus20
     header "format"
     export *
+
+    module __format {
+      module format_error         { header "__format/format_error.h"         }
+      module format_parse_context { header "__format/format_parse_context.h" }
+    }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {
     header "fstream"
module std [system] {
   module istream {
     header "istream"
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module iterator {
     header "iterator"
     export *
+
+    module __iterator {
+      module advance              { header "__iterator/advance.h"              }
+      module concepts             { header "__iterator/concepts.h"             }
+      module default_sentinel     { header "__iterator/default_sentinel.h"     }
+      module incrementable_traits { header "__iterator/incrementable_traits.h" }
+      module iter_move            { header "__iterator/iter_move.h"            }
+      module iterator_traits      { header "__iterator/iterator_traits.h"      }
+      module next                 { header "__iterator/next.h"                 }
+      module prev                 { header "__iterator/prev.h"                 }
+      module projected            { header "__iterator/projected.h"            }
+      module readable_traits      { header "__iterator/readable_traits.h"      }
+    }
   }
   module latch {
     requires cplusplus14
     header "latch"
     export *
   }
   module limits {
     header "limits"
module std [system] {
   module map {
     header "map"
     export initializer_list
     export *
   }
   module memory {
     header "memory"
     export *
+
+    module __memory {
+      module addressof                { header "__memory/addressof.h"                }
+      module allocation_guard         { header "__memory/allocation_guard.h"         }
+      module allocator_traits         { header "__memory/allocator_traits.h"         }
+      module allocator                { header "__memory/allocator.h"                }
+      module auto_ptr                 { header "__memory/auto_ptr.h"                 }
+      module compressed_pair          { header "__memory/compressed_pair.h"          }
+      module construct_at             { header "__memory/construct_at.h"             }
+      module pointer_safety           { header "__memory/pointer_safety.h"           }
+      module pointer_traits           { header "__memory/pointer_traits.h"           }
+      module raw_storage_iterator     { header "__memory/raw_storage_iterator.h"     }
+      module shared_ptr               { header "__memory/shared_ptr.h"               }
+      module temporary_buffer         { header "__memory/temporary_buffer.h"         }
+      module uninitialized_algorithms { header "__memory/uninitialized_algorithms.h" }
+      module unique_ptr               { header "__memory/unique_ptr.h"               }
+    }
   }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
     export *
module queue {
     export *
   }
   module random {
     header "random"
     export initializer_list
     export *
   }
   module ranges {
+    requires cplusplus20
     header "ranges"
     export compare
     export initializer_list
     export iterator
     export *
+
+    module __ranges {
+      module access                 { header "__ranges/access.h"                 }
+      module concepts               { header "__ranges/concepts.h"               }
+      module data                   { header "__ranges/data.h"                   }
+      module empty                  { header "__ranges/empty.h"                  }
+      module enabled_borrowed_range { header "__ranges/enabled_borrowed_range.h" }
+      module size                   { header "__ranges/size.h"                   }
+      module view_interface         { header "__ranges/view_interface.h"         }
+      module view                   { header "__ranges/view.h"                   }
+    }
   }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
     header "regex"
     export initializer_list
module unordered_set {
     header "unordered_set"
     export initializer_list
     export *
   }
   module utility {
     header "utility"
     export initializer_list
     export *
+
+    module __utility {
+      module to_underlying {
+        header "__utility/to_underlying.h"
+      }
+    }
   }
   module valarray {
     header "valarray"
     export initializer_list
     export *
   }
   module variant {
     header "variant"
     export *
   }
   module vector {
     header "vector"
     export initializer_list
     export *
   }
   module version {
     header "version"
     export *
   }
 
+  // __config not modularised due to a bug in Clang
+  // __functional(_03)?_base not modularised since it's designed for textual inclusion
+  // libcpp_version not modularised since it's just a version number
   // FIXME: These should be private.
-  module __bit_reference { header "__bit_reference" export * }
-  module __bits { header "__bits" export * }
-  module __debug { header "__debug" export * }
-  module __errc { header "__errc" export * }
-  module __functional_base { header "__functional_base" export * }
-  module __hash_table { header "__hash_table" export * }
-  module __locale { header "__locale" export * }
-  module __mutex_base { header "__mutex_base" export * }
-  module __node_handle { header "__node_handle" export * }
-  module __split_buffer { header "__split_buffer" export * }
-  module __std_stream { header "__std_stream" export * }
-  module __string { header "__string" export * }
+  module __availability      { header "__availability"      export * }
+  module __bit_reference     { header "__bit_reference"     export * }
+  module __bits              { header "__bits"              export * }
+  module __debug             { header "__debug"             export * }
+  module __errc              { header "__errc"              export * }
+  module __function_like     { header "__function_like.h"   export * }
+  module __functional_base   { header "__functional_base"   export * }
+  module __hash_table        { header "__hash_table"        export * }
+  module __locale            { header "__locale"            export * }
+  module __mutex_base        { header "__mutex_base"        export * }
+  module __node_handle       { header "__node_handle"       export * }
+  module __nullptr           { header "__nullptr"           export * }
+  module __split_buffer      { header "__split_buffer"      export * }
+  module __std_stream        { header "__std_stream"        export * }
+  module __string            { header "__string"            export * }
   module __threading_support { header "__threading_support" export * }
-  module __tree { header "__tree" export * }
-  module __tuple { header "__tuple" export * }
-  module __undef_macros { header "__undef_macros" export * }
+  module __tree              { header "__tree"              export * }
+  module __tuple             { header "__tuple"             export * }
+  module __undef_macros      { header "__undef_macros"      export * }
 
   module experimental {
     requires cplusplus11
 
     module algorithm {
       header "experimental/algorithm"
       export *
     }