Recent searches
Search options
modules addict) @DanielaKEngert@hachyderm.ioCool, cool!
After a long fight with CMake, Clang, and gcc, I can report progress on the C++ modules front. 
The argparse library is a good subject because it is not too large and has an extensive test suite. With my changes, it can be used as header, module, or both! It can use a modularized standard library, too, if present.
- Clang passes the tests but fails with merging a few definitions
- gcc can merge, but falls apart when using it as module
- MSVC passes all tests
![Mixed mode test code:
#include <doctest.hpp>
// this must work according to [basic.def.odr]/15
// the same definitions come from *two different* TUs:
// - this TU by means of #include <argparse.hpp>
// - another TU that's creating module 'argparse'
//
// the definitions must *both* be attached to the global module!
#if defined(__clang__)
// the test fails to compile on Clang 18
constexpr bool included = false;
#else
constexpr bool included = true;
#include <argparse/argparse.hpp>
#endif
import argparse;
using doctest::skip;
using doctest::test_suite;
TEST_CASE("Module is usable in mixed mode" * test_suite("module") *
skip(not included)) {
REQUIRE(requires {
typename argparse::nargs_pattern;
typename argparse::default_arguments;
{argparse::default_arguments::none & argparse::default_arguments::all};
typename argparse::ArgumentParser;
typename argparse::Argument;
});
}
#if defined(__GNUC__) && !defined(__clang__)
// the following tests confuse gcc, causing an internal compiler error
#else
TEST_CASE("Module can build and execute a test program in mixed mode" *
test_suite("module") * skip(not included)) {
int argc = 2;
const char *argv[] = {"test", "--foo"};
ArgumentParser program(
"test", "1.0", default_arguments::all & default_arguments::help, false);
program.add_argument("--foo")
.implicit_value(true)
.default_value(false)
.action([&](const auto &) { ++argc; });
....
}
#endif](https://media.hachyderm.io/media_attachments/files/112/876/191/815/875/337/original/ac3665e70e61d0d8.png "Mixed mode test code:
#include <doctest.hpp>
// this must work according to [basic.def.odr]/15
// the same definitions come from *two different* TUs:
// - this TU by means of #include <argparse.hpp>
// - another TU that's creating module 'argparse'
//
// the definitions must *both* be attached to the global module!
#if defined(__clang__)
// the test fails to compile on Clang 18
constexpr bool included = false;
#else
constexpr bool included = true;
#include <argparse/argparse.hpp>
#endif
import argparse;
using doctest::skip;
using doctest::test_suite;
TEST_CASE(\"Module is usable in mixed mode\" * test_suite(\"module\") *
skip(not included)) {
REQUIRE(requires {
typename argparse::nargs_pattern;
typename argparse::default_arguments;
{argparse::default_arguments::none & argparse::default_arguments::all};
typename argparse::ArgumentParser;
typename argparse::Argument;
});
}
#if defined(__GNUC__) && !defined(__clang__)
// the following tests confuse gcc, causing an internal compiler error
#else
TEST_CASE(\"Module can build and execute a test program in mixed mode\" *
test_suite(\"module\") * skip(not included)) {
int argc = 2;
const char *argv[] = {\"test\", \"--foo\"};
ArgumentParser program(
\"test\", \"1.0\", default_arguments::all & default_arguments::help, false);
program.add_argument(\"--foo\")
.implicit_value(true)
.default_value(false)
.action([&](const auto &) { ++argc; });
....
}
#endif")
You usually build the argparse module in 'attached' mode, i.e. all entities are attached to the named module.
The tests use two module builds: attached and detached. The latter detaches the entities from the module and glues them to the so-called global module. This allows for mixing the module with the traditional #include like I do in the module mixed mode test. It is supposed to work because compilers are required to do definition merging if the same entities come from more than one TU.
This is where both Clang 18 and gcc 14 have a hard time.
Clang is mostly there but fails in three test cases where it can't merge the definitions. Hence no mixed mode tests for Clang.
Gcc can merge, but is utterly confused when asked to use its own built module 
MSVC does exactly what it is supposed to do.
All three compilers fail to #include standard library headers *after* importing their modularized standard library, but that's expected - unfortunately. More love needed to merge...
What does this mean?
As we all know, modules have *two* interfaces, not just *one* like with #include.
All three compilers can build interface one (the *inward* looking) that's built during compilation of the primary module interface unit.
Interface two (the *outward* looking one) is the interesting one: can it be used by consumers of a module?
- Clang 18.1: 
- Gcc 14.1: 
- MSVC 17.10:
Both Clang and MSVC also have a usable modularized standard library.