On Wed, 7 Dec 2022, 02:30 chuanqi.xcq via Gcc, <gcc@gcc.gnu.org> wrote:

> Hi Nathan,
> > 1) 'save' -- does it *cause* the bmi to be saved, or is that actually
> controlled
> by other options? (I suspect the latter)
> Yes, it causes the bmi to be saved. In fact, when we add `-save-temps`
> option in clang and we compile a module unit, we'll see the preprocessed
> output, the bmi, the LLVM IR and the assembly code. So the semantics of the
> option `-fsave-std-cxx-module-file=` is to save the bmi to the specified
> output.
> > 2) 'std' -- why is this there. There's only one C++ std, with different
> variants thereof being temporally selectable.
> Since in clang we have clang c++ modules extension. It is not std one. And
> we have objective C modules in clang too. So we said `std-cxx`.
> > 3) 'cxx' -- why not 'c++'? Let's not let this transliteration of + to x
> get
> into the options -- it hasn't in '-std=c++20' for example.
> `c++` should be good advice.
> > Might I suggest something more like '-fmodule-output='? That collates
> nicely with other -fmodule-$FOO options, and the 'output' part is similar
> to the mnemonic '-o' for the regular output file naming.
> My previous concern was there were tons of `-fmodule-*` options in clang,
> which are not standard c++ modules. So I was afraid the name
> `-fmodule-output` may be confusing.
> So I proposed `-fsave-std-cxx-module-file=`. But I didn't recognize we
> need to keep the option consistency between gcc and clang until Iain
> mentioned it.
> It is obviously redundant for gcc to keep the `-std-cxx` prefix in the
> name. Personally, I feel the clearity of the option name is more important
> than the length.
>

I disagree. I can easily remember "module output" but I would have to check
the manual every time to see if it's "std c++ module save file" or some
other permutation of those words

And if the flag is not consistent between clang and GCC that's even worse.

Since I think such flags will be mainly used by build systems/build scripts
> so such flags wouldn't be typed frequently.
> But command line interface consistency is very important too. I know tools
> writer will hate to write tons of codes like:
> ```
> if compiler == gcc
>  ...
> elif compiler == clang
>  ...
> ```
> So I think the conclusion may be:
> (1) If gcc can tolerate the lengthy `-fsave-std-c++-module-file=` name, it
> would be best for clang.
>

IMHO that's unacceptable for GCC.


(2) If (1) is not acceptable and we love to keep the command line
> consistency, I think clang can use '-fmodule-output=' as long as we make it
> clear in the document. It will be confusing but it may be the cost clang
> need to pay for the extension (so I'll vote against strongly if someone
> want to add some other extensions)
>

Given that C++20 modules are in an ISO standard and clang modules aren't, I
think it's right that the "simple" name refers to C++20 modules, without
requiring "std-c++-modules". It also seems right that the difficulty of
distinguishing clang modules from std modules should be dealt with by
clang, not by other compilers.