Merge pull request #175 from Kaaserne/dev

Module improvements & catch 3.9

Author: Kaaserne

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ on:
 
 env:
   CTEST_OUTPUT_ON_FAILURE: 1
-  CATCH_VERSION: '2.13.10'
+  CATCH_VERSION: '3.9.0'
 
 jobs:
   gcc:
@@ -218,4 +218,40 @@ jobs:
           -D CMAKE_BUILD_TYPE:STRING=Release
 
       - name: Build
-        run: cmake --build build/examples -j $(nproc)
+        run: cmake --build build/examples -j $(nproc)
+  
+  module_tests:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v1
+
+      - name: Install Ninja
+        uses: seanmiddleditch/gha-setup-ninja@master
+      
+      - name: Add LLVM apt repo and install Clang 18
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y wget lsb-release gnupg
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 18
+          clang++-18 --version
+
+      - name: Configure tests
+        env:
+          CC: clang-18
+          CXX: clang++-18
+        run: cmake -S tests/module_tests -B tests/module_tests/build -G Ninja
+          -D CMAKE_CXX_STANDARD:STRING=20
+          -D CPP-LAZY_USE_MODULES=ON
+          -D CMAKE_CXX_COMPILER=clang++-18
+          -D CMAKE_C_COMPILER=clang-18
+
+      - name: Build
+        run: cmake --build tests/module_tests/build
+      
+      - name: Run tests
+        working-directory: tests/module_tests/build
+        run: ./module_test

.github/workflows/codeql.yml

@@ -7,7 +7,7 @@ on:
     branches: [ "master" ]
 
 env:
-  CATCH_VERSION: '2.13.10'
+  CATCH_VERSION: '3.9.0'
 
 jobs:
   analyze:

CMakeLists.txt

@@ -31,11 +31,13 @@ endif()
 option(CPP-LAZY_DEBUG_ASSERTIONS "Debug assertions" ${CPP-LAZY_DEBUG_ASSERTIONS})
 
 if (CPP-LAZY_USE_MODULES)
+	message(STATUS "cpp-lazy: using C++20 modules")
 	set(CPP-LAZY_SOURCE_FILES "src/lz.cppm")
 	set(CPP-LAZY_LINK_VISIBILITY "PUBLIC")
 	set(CPP-LAZY_COMPILE_FEATURES_VISIBLITY "PUBLIC")
 	set(CPP-LAZY_COMPILE_DEFINITIONS_VISIBLITY "PRIVATE")
 	set(CPP-LAZY_COMPILE_INCLUDE_VISIBLITY "PUBLIC")
+	set(CMAKE_CXX_SCAN_FOR_MODULES ON)
 else()
 	set(CPP-LAZY_LIB_TYPE "INTERFACE")
 	set(CPP-LAZY_LINK_VISIBILITY "INTERFACE")
@@ -73,6 +75,10 @@ message(STATUS "cpp-lazy: Debug assertions: ${CPP-LAZY_DEBUG_ASSERTIONS}.")
 add_library(cpp-lazy ${CPP-LAZY_LIB_TYPE} "${CPP-LAZY_SOURCE_FILES}")
 add_library(cpp-lazy::cpp-lazy ALIAS cpp-lazy)
 
+if (CPP-LAZY_USE_MODULES)
+	target_sources(cpp-lazy PUBLIC FILE_SET cxx_modules TYPE CXX_MODULES FILES "${CPP-LAZY_SOURCE_FILES}")
+endif()
+
 # Link lib stacktrace if debug assertions are enabled, on Linux with C++23 or later
 set(IS_CXX_23 $<VERSION_GREATER_EQUAL:${CMAKE_CXX_STANDARD},23>)
 set(IS_LINUX_COMPILER $<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>)
@@ -89,25 +95,6 @@ target_compile_definitions(cpp-lazy
 		$<$<BOOL:${CPP-LAZY_USE_STANDALONE}>:LZ_STANDALONE>
 		$<$<BOOL:${CPP-LAZY_DEBUG_ASSERTIONS}>:LZ_DEBUG_ASSERTIONS>
 )
-if (CPP-LAZY_USE_MODULES)
-	set(FMT_MODULE "ON" CACHE STRING "")
-	if (MSVC)
-		set(BMI "${CMAKE_CURRENT_BINARY_DIR}/lz.ifc")
-		target_compile_options(cpp-lazy
-			PRIVATE
-				/interface /ifcOutput "${BMI}"
-			INTERFACE
-				/reference lz="${BMI}"
-		)
-	endif()
-	set_target_properties(cpp-lazy 
-		PROPERTIES 
-			ADDITIONAL_CLEAN_FILES "${BMI}"
-		DEBUG_POSTFIX
-			"d"
-	)
-	set_source_files_properties("${BMI}" PROPERTIES GENERATED ON)
-endif()
 
 target_compile_features(cpp-lazy 
 	${CPP-LAZY_COMPILE_FEATURES_VISIBLITY} 
@@ -127,10 +114,19 @@ set(cpp-lazy_directory "cpp-lazy")
 set(cpp-lazy_include_directory "${CMAKE_INSTALL_INCLUDEDIR}/${cpp-lazy_directory}")
 set(cpp-lazy_install_cmakedir "${CMAKE_INSTALL_LIBDIR}/cmake/${cpp-lazy_directory}")
 
-install(TARGETS cpp-lazy
+if (CPP-LAZY_USE_MODULES)
+	install(TARGETS cpp-lazy
         EXPORT cpp-lazyTargets
         INCLUDES
-        DESTINATION "${cpp-lazy_include_directory}")
+        DESTINATION "${cpp-lazy_include_directory}"
+        FILE_SET cxx_modules DESTINATION "${cpp-lazy_include_directory}"
+)
+else ()
+	install(TARGETS cpp-lazy
+			EXPORT cpp-lazyTargets
+			INCLUDES
+			DESTINATION "${cpp-lazy_include_directory}")
+endif ()
 
 write_basic_package_version_file(
         cpp-lazyConfigVersion.cmake
@@ -164,4 +160,4 @@ if (CPP-LAZY_BUILD_ESSENTIALS_ZIP)
 		DEPENDS include/;CMakeLists.txt;LICENSE.md;cmake/
 	)
 	add_custom_target(${PROJECT_NAME}_package DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-src.zip")
-endif ()
+endif ()

README.md

@@ -13,15 +13,23 @@ The library uses one optional dependency: the library `{fmt}`, more of which can
 
 # Features
 - C++11/14/17/20 compatible
+- C++20's module compatible
 - Easy printing/formatting using `lz::format`, `fmt::print` or `std::cout`
-- Tested with `-Wpedantic -Wextra -Wall -Wshadow -Wno-unused-function -Werror -Wconversion` and `/WX` for MSVC
 - One optional dependency ([`{fmt}`](https://github.com/fmtlib/fmt)), can be turned off by using option `CPP-LAZY_USE_STANDALONE=TRUE`/`set(CPP-LAZY_USE_STANDALONE TRUE)` in CMake
 - STL compatible (if the input iterable is not sentinelled, otherwise use `lz::*` equivalents)
 - Little overhead, as little data usage as possible
 - Any compiler with at least C++11 support should be suitable
 - [Easy installation](https://github.com/Kaaserne/cpp-lazy#installation)
 - [Clear Examples](https://github.com/Kaaserne/cpp-lazy/tree/master/examples)
 - Piping/chaining using `|` operator
+<details>
+<summary>Tested with GCC's warning flags</summary>
+
+```
+-Wpedantic -Wextra -Wall -Wshadow -Werror -Wconversion -Wcast-qual -Wcomma-subscript -Wctor-dtor-privacy -Wdeprecated-copy-dtor -Wdouble-promotion -Wduplicated-branches -Wduplicated-cond -Wenum-conversion -Wextra-semi -Wfloat-equal -Wformat-overflow=2 -Wformat-signedness -Wformat=2 -Wlogical-op -Wmismatched-tags -Wmultichar -Wnon-virtual-dtor -Woverloaded-virtual -Wpointer-arith -Wrange-loop-construct -Wrestrict -Wstrict-null-sentinel -Wsuggest-attribute=format -Wsuggest-attribute=malloc -Wuninitialized -Wvla -Wvolatile -Wwrite-strings
+```
+
+</details>
 
 # What is lazy?
 Lazy evaluation is an evaluation strategy which holds the evaluation of an expression until its value is needed. In this library, all the iterators are lazy evaluated. Suppose you want to have a sequence of `n` random numbers. You could write a for loop:
@@ -103,11 +111,13 @@ int main() {
   // the sequence will be traversed to get the size using lz::eager_size. The iterable will be documented
   // appropriately if this requires a sized iterable. Example:
   auto zipper1 = lz::zip(lz::c_string("ab"), lz::c_string("cd")); // Calling .end() will take O(n) time
-  auto zipper2 = lz::zip(sized, sized); // Takes O(1) time
+  auto zipper2 = lz::zip(sized, sized); // Calling .end() will take O(1) time
 
-  // You can cache the size if you need to (more about when to do that in the appropriate iterable documentation):
-  auto cached_sizes = lz::zip(lz::c_string("ab") | lz::cache_size, lz::c_string("cd") | lz::cache_size); // Takes O(n) time
-  // However cached_sizes.end() will now take O(1) time
+  // You can cache the size if you need to.
+  // More about when to do that in the appropriate iterable documentation
+  // lz:c_string isn't sized, so in order to make it sized, we can use lz::cache_size:
+  auto cached_sizes = lz::zip(lz::c_string("ab") | lz::cache_size, lz::c_string("cd") | lz::cache_size);
+  // cached_sizes.end() will now take O(1) time, instead of zipper1's O(n) time.
 }
 ```
 

include/Lz/algorithm.hpp

@@ -13,9 +13,7 @@
 #include <numeric> // std::accumulate
 #endif             // LZ_HAS_CXX_20
 
-namespace lz {
-
-LZ_MODULE_EXPORT_SCOPE_BEGIN
+LZ_MODULE_EXPORT namespace lz {
 
 /**
  * Checks whether [begin, end) is empty.
@@ -739,8 +737,6 @@ LZ_NODISCARD LZ_CONSTEXPR_CXX_14 bool is_sorted(Iterable&& iterable, BinaryPredi
                      std::forward<BinaryPredicate>(binary_predicate));
 }
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 } // namespace lz
 
 #endif // LZ_ALGORITHM_HPP

include/Lz/basic_iterable.hpp

@@ -114,9 +114,9 @@ class sized_iterable_impl : public lazy_view {
     }
 };
 } // namespace detail
+} // namespace lz
 
-LZ_MODULE_EXPORT_SCOPE_BEGIN
-
+LZ_MODULE_EXPORT namespace lz {
 /**
  * @brief A class that can be converted to any container. It only contains the iterators and
  * can be used in pipe expressions, converted to a container with `to<Container>()`, used in algorithms, for-each loops, etc...
@@ -148,10 +148,11 @@ template<class I, class S>
 LZ_NODISCARD constexpr basic_iterable<I, S> make_basic_iterable(I begin, S end) {
     return { std::move(begin), std::move(end) };
 }
+}
 
-LZ_MODULE_EXPORT_SCOPE_END
-
+namespace lz {
 namespace detail {
+
 template<LZ_CONCEPT_ITERABLE Iterable, class Container, class = void>
 struct prealloc_container {
     LZ_CONSTEXPR_CXX_14 void try_reserve(const Iterable&, const Container&) const noexcept {
@@ -227,11 +228,11 @@ struct has_push<Container, void_t<decltype(0, std::declval<Container>().push(std
  * };
  * ```
  */
-template<class Container, class = void>
+LZ_MODULE_EXPORT template<class Container, class = void>
 struct custom_copier_for;
 
 // std::array doesnt have push_back, insert, insert_after... etc, so just use copy
-template<class T, std::size_t N>
+LZ_MODULE_EXPORT template<class T, std::size_t N>
 struct custom_copier_for<std::array<T, N>> {
     template<class Iterable>
     LZ_CONSTEXPR_CXX_14 void copy(Iterable&& iterable, std::array<T, N>& container) const {
@@ -409,8 +410,9 @@ struct template_combiner {
     }
 };
 } // namespace detail
+} // namespace lz
 
-LZ_MODULE_EXPORT_SCOPE_BEGIN
+LZ_MODULE_EXPORT namespace lz {
 
 // clang-format off
 
@@ -623,20 +625,14 @@ to(Iterable&& iterable, Args&&... args) {
  */
 using detail::custom_copier_for;
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 } // namespace lz
 
-LZ_MODULE_EXPORT_SCOPE_BEGIN
-
-template<class Iterable, class Adaptor>
+LZ_MODULE_EXPORT template<class Iterable, class Adaptor>
 constexpr auto operator|(Iterable&& iterable, Adaptor&& adaptor)
     -> lz::detail::enable_if<lz::detail::is_adaptor<lz::detail::remove_cvref<Adaptor>>::value &&
                                  lz::detail::is_iterable<Iterable>::value,
                              decltype(std::forward<Adaptor>(adaptor)(std::forward<Iterable>(iterable)))> {
     return std::forward<Adaptor>(adaptor)(std::forward<Iterable>(iterable));
 }
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 #endif // LZ_BASIC_ITERATOR_VIEW_HPP

include/Lz/c_string.hpp

@@ -6,10 +6,7 @@
 #include <Lz/basic_iterable.hpp>
 #include <Lz/detail/adaptors/c_string.hpp>
 
-namespace lz {
-
-LZ_MODULE_EXPORT_SCOPE_BEGIN
-
+LZ_MODULE_EXPORT namespace lz {
 /**
  * @brief This adaptor is used to create a c forward iterable cstring iterable object. Its end() function will return a sentinel,
  * rather than an actual iterator. This iterable does not contain a .size() method. Example:
@@ -34,8 +31,6 @@ LZ_INLINE_VAR constexpr detail::c_string_adaptor c_string{};
 template<class CharT>
 using c_string_iterable = detail::c_string_iterable<CharT>;
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 } // namespace lz
 
 #endif

include/Lz/cached_size.hpp

@@ -6,9 +6,7 @@
 #include <Lz/basic_iterable.hpp>
 #include <Lz/detail/adaptors/cached_size.hpp>
 
-namespace lz {
-
-LZ_MODULE_EXPORT_SCOPE_BEGIN
+LZ_MODULE_EXPORT namespace lz {
 
 /**
  * @brief Creates an iterable with a size method. Gets the size eagerly (using `lz::eager_size`). Some iterables will traverse
@@ -57,8 +55,6 @@ LZ_INLINE_VAR constexpr detail::cached_size_adaptor cache_size{};
 template<class Iterable>
 using cached_size_iterable = detail::cached_size_iterable<Iterable>;
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 } // namespace lz
 
 #endif

include/Lz/cartesian_product.hpp

@@ -6,9 +6,7 @@
 #include <Lz/basic_iterable.hpp>
 #include <Lz/detail/adaptors/cartesian_product.hpp>
 
-namespace lz {
-
-LZ_MODULE_EXPORT_SCOPE_BEGIN
+LZ_MODULE_EXPORT namespace lz {
 
 /**
  * @brief Performs a cartesian product on the given iterables. This means that it will return all possible combinations
@@ -38,8 +36,6 @@ LZ_INLINE_VAR constexpr detail::cartesian_product_adaptor cartesian_product{};
 template<class... Iterables>
 using cartesian_product_iterable = detail::cartesian_product_iterable<Iterables...>;
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 } // namespace lz
 
 #endif // LZ_CARTESIAN_PRODUCT_HPP

include/Lz/chunk_if.hpp

@@ -7,9 +7,7 @@
 #include <Lz/detail/adaptors/chunk_if.hpp>
 #include <Lz/string_view.hpp>
 
-namespace lz {
-
-LZ_MODULE_EXPORT_SCOPE_BEGIN
+LZ_MODULE_EXPORT namespace lz {
 
 #ifdef LZ_HAS_CXX_11
 
@@ -134,8 +132,6 @@ using chunk_if_iterable = detail::chunk_if_iterable<basic_iterable<iter_t<Iterab
 template<class ValueType, class Iterable, class UnaryPredicate>
 using t_chunk_if_iterable = detail::chunk_if_iterable<ValueType, Iterable, UnaryPredicate>;
 
-LZ_MODULE_EXPORT_SCOPE_END
-
 } // namespace lz
 
 #endif // LZ_CHUNK_IF_HPP