You also can end up needing to rebuild the world, if touching a header that is part of the PCH, even if it isn’t really needed by all the targets.
Modules and header units were supposed to solve these a lot more cleanly, but is still not well supported.
I'm just going to ignore the part where Clang apparently sabotages itself by requiring `-include-pch`. You really shouldn't be using Clang in production because it has all sorts of hard limitations so I am not at all surprised at hitting another one; even if this particular one gets fixed, you'll still run into several others, whether you realize it or not (since usually it silently does the wrong thing). Your `./configure` should already be detecting "is this an actually-working GCC" anyway, so you can use that as the condition before you enable the PCH logic at all.
The "can only use one PCH per compilation" limitation also exists in GCC and is well-documented there since I started using it (maybe in 2010?), but as noted it is not a major limitation. Assuming you're practicing sufficient rigor for your build process, you basically have 3 options: only one PCH for the whole project, one PCH per directory-ish (assuming each directory is a semi-independent part of the project; this is probably sanest), or try to precompile all headers (this has performance implications for whenever you edit a header).
The "build vs src" purity problem has a simple solution - just use `-I` to specify an "overlay" include directory that is in the build directory, and have your PCH-making rule specify that in the first place. That's it.
Wait, do you mean you shouldn't be using Clang PCHs in production, or shouldn't be using Clang in production at all?
Remember, the whole point of Clang is so that people can make their proprietary compiler forks. Everything else, including quality, is secondary.
While no compiler is perfect (e.g., pointer provenance), one could just as easily argue that Clang has higher quality—most modern C/++ tooling is built on it, sanitizers are brought up in Clang and sometimes ported to GCC later, all of the modern safety work is in Clang (-Wbounds-safety, the various thread safety approaches, lifetime analysis, Sean’s borrow checked C++, Fil-C). The Clang static analyzer has also been used in production for over a decade, whereas -fanalyzer is still experimental and limited to C, …
I have the feeling that the bugs that aren’t being fixed are either because the bug report is unactionable (3yr old Ubuntu Franken-clang is slower than than 3yr old franken-gcc) or because the problem is very non-trivial (e.g., you can find recent discussion about enabling dependence analysis by default, the aforementioned pointer provenance issues stemming from C, ABI/lowering warts around large _BitInt)
Traditionally they always sucked on UNIX systems, the only place I have been able to fully enjoy the improvements they bring to the table has been in PC systems, since Windows 3.x, across OS/2, and Borland/Microsoft compilers ever since.
Additionally, on my C++ hobby coding, since I am on Windows, I am fully into modules.
VS IDE tooling is stil kind of broken because they rely on EDG instead of VC++, and fixing module intelisense has been low priority for EDG, and MS as well as I would assume a $4 trillion valued company would care about their suppliers.
Clion has better support on that regard.
GCC is still not fully there, and Apple clang, well Apple is happy with module header maps for their Swift/Objective-C integration, so lets see.
Article also misses: comparing speed of full rebuilds. Pch gives massive speedup on edit-compile-debug cycle or when several modules can share a single pch.