[C++20][Modules][Driver][HU 3/N] Handle foo.h with -fmodule-header and/or C++ invocation.

[iains]

Summary

Allow an invocation like clang -fmodule-header bar.h (which will be a C++
compilation, but using a header which will be recognised as a C one).

Also we do not want to produce:
"treating 'c-header' input as 'c++-header' when in C++ mode"
diagnostics when the user has been specific about the intent.

[ChuanqiXu]

This looks a little bit odd. Is this consistent with GCC too?

[iains]

In D121590#3381344, @ChuanqiXu wrote:

This looks a little bit odd. Is this consistent with GCC too?

It is consistent, GCC does not warm for this - but that was not the primary motivation in this case.

This is simply a convenience feature - considering that there are many C++ projects that use ".h" headers it saves the user from having to add "-xc++-header" in each case.

(since it is a convenience feature, it is non-essential, of course - but IMO useful even now)

[iains]

rebased.

[urnathan]

looks resonable, 1 nit.

clang/lib/Driver/Driver.cpp

2467–2471

extra whitespace 'are[spc][spc]counted'

[iains]

rebased, addrssed review comment, amend testcase for windows.

[iains]

another testcase ajustment for windows.

clang/lib/Driver/Driver.cpp

if (A->getOption().getKind() == Option::InputClass) {
           }
 
           // If the driver is invoked as C++ compiler (like clang++ or c++) it
           // should autodetect some input files as C++ for g++ compatibility.
           if (CCCIsCXX()) {
             types::ID OldTy = Ty;
             Ty = types::lookupCXXTypeForCType(Ty);
 
-            if (Ty != OldTy)
+            // Do not complain about foo.h, when we are known to be processing
+            // it as a C++20 header unit.
+            if (Ty != OldTy && !(OldTy == types::TY_CHeader && hasHeaderMode()))
               Diag(clang::diag::warn_drv_treating_input_as_cxx)
                   << getTypeName(OldTy) << getTypeName(Ty);
           }
 
           // If running with -fthinlto-index=, extensions that normally identify
           // native object files actually identify LLVM bitcode files.
           if (Args.hasArgNoClaim(options::OPT_fthinlto_index_EQ) &&
               Ty == types::TY_Object)
             Ty = types::TY_LLVM_BC;
         }
 
         // -ObjC and -ObjC++ override the default language, but only for "source
         // files". We just treat everything that isn't a linker input as a
         // source file.
         //
         // FIXME: Clean this up if we move the phase sequence into the type.
         if (Ty != types::TY_Object) {
           if (Args.hasArg(options::OPT_ObjC))
             Ty = types::TY_ObjC;
           else if (Args.hasArg(options::OPT_ObjCXX))
             Ty = types::TY_ObjCXX;
         }
 
         // Disambiguate headers that are meant to be header units from those
-        // intended to be PCH.
-        if (Ty == types::TY_CXXHeader && hasHeaderMode())
+        // intended to be PCH.  Avoid missing '.h' cases that are counted as
+        // C headers by default - we know we are in C++ mode and we do not
+        // want to issue a complaint about compiling things in the wrong mode.
+        if ((Ty == types::TY_CXXHeader || Ty == types::TY_CHeader) &&
+            hasHeaderMode())
           Ty = CXXHeaderUnitType(CXX20HeaderType);
       } else {
         assert(InputTypeArg && "InputType set w/o InputTypeArg");
         if (!InputTypeArg->getOption().matches(options::OPT_x)) {
           // If emulating cl.exe, make sure that /TC and /TP don't affect input
           // object files.
           const char *Ext = strrchr(Value, '.');
           if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)

clang/test/Driver/cxx20-header-units-02.cpp

 // Test user-facing command line options to generate C++20 header units.
 
 // RUN: %clang -### -std=c++20 -fmodule-header=user foo.hh  2>&1 | \
 // RUN:   FileCheck -check-prefix=CHECK-USER %s
 
+// RUN: %clang -### -std=c++20 -fmodule-header=user foo.h  2>&1 | \
+// RUN:   FileCheck -check-prefix=CHECK-USER1 %s
+
 // RUN: %clang -### -std=c++20 -fmodule-header=system foo.hh 2>&1 | \
 // RUN:   FileCheck -check-prefix=CHECK-SYS1 %s
 
 // RUN: %clang -### -std=c++20 -fmodule-header=system \
 // RUN: -xc++-system-header vector 2>&1 | FileCheck -check-prefix=CHECK-SYS2 %s
 
 // RUN: %clang -### -std=c++20 -fmodule-header=system \
 // RUN: -xc++-header vector 2>&1 | FileCheck -check-prefix=CHECK-SYS2 %s
 
 // RUN: %clang -### -std=c++20 -fmodule-header %/S/Inputs/header-unit-01.hh \
 // RUN: 2>&1 | FileCheck -check-prefix=CHECK-ABS %s -DTDIR=%/S/Inputs
 
 // CHECK-USER: "-emit-header-unit"
 // CHECK-USER-SAME: "-o" "foo.pcm"
 // CHECK-USER-SAME: "-x" "c++-user-header" "foo.hh"
 
+// CHECK-USER1: "-emit-header-unit"
+// CHECK-USER1-SAME: "-o" "foo.pcm"
+// CHECK-USER1-SAME: "-x" "c++-user-header" "foo.h"
+
 // CHECK-SYS1: "-emit-header-unit"
 // CHECK-SYS1-SAME: "-o" "foo.pcm"
 // CHECK-SYS1-SAME: "-x" "c++-system-header" "foo.hh"
 
 // CHECK-SYS2: "-emit-header-unit"
 // CHECK-SYS2-SAME: "-o" "vector.pcm"
 // CHECK-SYS2-SAME: "-x" "c++-system-header" "vector"
 
 // CHECK-ABS: "-emit-header-unit"
 // CHECK-ABS-SAME: "-o" "header-unit-01.pcm"
 // CHECK-ABS-SAME: "-x" "c++-header-unit-header" "[[TDIR]]/header-unit-01.hh"