On this page about the C++20 module feature, I discovered this statement:
Thanks to a private module fragment, you can implement a module in one file and declare its last part as its implementation using
module :private;. Consequently, a modification of the private module fragment does not cause recompilation.
Emphasis added.
Is that statement accurate? Do changes to a private module fragment cause "recompilation?"
This question is a lot more complicated than it seems, as "recompilation" could mean a lot of things and the website doesn't go into detail.
Where the website is potentially correct is this: do changes to a module's private fragment cause code which imports that module to be recompiled? The answer here is "maybe".
Because the module interface did not change, the module file representing this interface is identical to what it was under the last compilation. So a smart implementation of modules could do a quick comparison between the newly generated module file and the previous one. If they are the same, then it could choose not to overwrite the old file, thereby avoiding causing recompilation of dependent files.
But that is mere possibility; a better question is whether actual implementations do that. Visual Studio 2022 is probably the build system with the most mature module support.
From what I can tell, the native build functionality of VS2022 does not attempt to detect if a compiled module interface matches the one already on disk. If it detects that it needs to recompile any part of a file that contributes to a module's interface, then it presumes that the interface itself has changed. And therefore, all files importing that module need to be rebuilt.
Note that this does not happen when using a module implementation unit. If you change the contents of an implementation unit, that does not provoke the rebuilding of the module interface, so it does not provoke the recompilation of code which includes that interface.
If the question is whether changes to a module's private fragment causes the module interface to be recompiled, the answer is almost certainly "yes" (and certainly for VC2022).
Sure, it is theoretically possible for a build system to detect that only the private module fragment has changed. But it would involve either compiling the interface portion anyway (to compare it against the one on-disk) or storing the textual version of the interface on-disk and comparing that to the file's version. Neither is a particularly good idea.
