[Clang] Emit warning for -x option without effects

[qiucf]

Summary

Things might be confusing for people not familiar with how this option works. Add this warning like GCC.

[qiucf]

gentle ping

[hans]

clang/lib/Driver/Driver.cpp

2416

Could we end up here in clang-cl mode with InputTypeArg pointing to a '/TC' or '/TP' option? (Set near the top of the function.) In that case, emitting a diagnostic that talks about -x would be misleading.

What if you initialized InputsBeforeOptX to a sentinel value instead (e.g. SIZE_MAX)? Could the if statement then be simplified to just

if (Inputs.size() == InputsBeforeX)

?

clang/test/Driver/redundant-args.c

2

These two lines seem to test pretty different things (and I find the first test a bit confusing). Maybe there's a better test to add the new warning to, or it could go in its own file?

[awarzynski]

clang/test/Driver/redundant-args.c

2

I second @hans here - this is confusing. I suggest the following:

// RUN: %clang  -Werror -x c -fsyntax-only %s
// RUN: not %clang  -Werror %s -x c -fsyntax-only  2>&1 | FileCheck %s

Basically:

• IIUC, -target is not relevant here
• -x -c and -x -c -x -c are identical (so -x -c should be sufficient)
• both lines should be almost identical and the difference triggering the warning should be made clear

[qiucf]

Abandon this since we have rGe2a1f8ec27b88be670cd867c43588f24516d2bbf.

clang/include/clang/Basic/DiagnosticDriverKinds.td

 def warn_drv_moutline_unsupported_opt : Warning<
   "'%0' does not support '-moutline'; flag ignored">,
   InGroup<OptionIgnored>;
 
 def warn_drv_moutline_atomics_unsupported_opt : Warning<
   "'%0' does not support '-%1'; flag ignored">,
   InGroup<OptionIgnored>;
 
+def warn_drv_ignored_option_x : Warning<
+  "'-x %0' after last input file has no effect">, InGroup<OptionIgnored>;
+
 def warn_drv_darwin_sdk_invalid_settings : Warning<
   "SDK settings were ignored as 'SDKSettings.json' could not be parsed">,
   InGroup<DiagGroup<"darwin-sdk-settings">>;
 
 def err_drv_trivial_auto_var_init_zero_disabled : Error<
   "'-ftrivial-auto-var-init=zero' hasn't been enabled; enable it at your own "
   "peril for benchmarking purpose only with "
   "'-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang'">;

clang/lib/Driver/Driver.cpp

     }
     if (ShowNote)
       Diag(clang::diag::note_drv_t_option_is_global);
 
     // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
     assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
   }
 
+  size_t InputsBeforeOptX = 0;
   for (Arg *A : Args) {
     if (A->getOption().getKind() == Option::InputClass) {
       const char *Value = A->getValue();
       types::ID Ty = types::TY_INVALID;
 
       // Infer the input type if necessary.
       if (InputType == types::TY_Nothing) {
         // If there was an explicit arg for this, claim it.

       // Just treat as object type, we could make a special type for this if
       // necessary.
       Inputs.push_back(std::make_pair(types::TY_Object, A));
 
     } else if (A->getOption().matches(options::OPT_x)) {
       InputTypeArg = A;
       InputType = types::lookupTypeForTypeSpecifier(A->getValue());
       A->claim();
+      InputsBeforeOptX = Inputs.size();
 
       // Follow gcc behavior and treat as linker input for invalid -x
       // options. Its not clear why we shouldn't just revert to unknown; but
       // this isn't very important, we might as well be bug compatible.
       if (!InputType) {
         Diag(clang::diag::err_drv_unknown_language) << A->getValue();
         InputType = types::TY_Object;
       }
     } else if (A->getOption().getID() == options::OPT_U) {
       assert(A->getNumValues() == 1 && "The /U option has one value.");
       StringRef Val = A->getValue(0);
       if (Val.find_first_of("/\\") != StringRef::npos) {
         // Warn about e.g. "/Users/me/myfile.c".
         Diag(diag::warn_slash_u_filename) << Val;
         Diag(diag::note_use_dashdash);
       }
     }
   }
   if (CCCIsCPP() && Inputs.empty()) {
     // If called as standalone preprocessor, stdin is processed
     // if no other input is present.
     Arg *A = MakeInputArg(Args, Opts, "-");
     Inputs.push_back(std::make_pair(types::TY_C, A));
   }
+  if (Inputs.size() == InputsBeforeOptX && InputTypeArg != nullptr)
+    Diag(diag::warn_drv_ignored_option_x) << InputTypeArg->getValue(0);
 }
 
 namespace {
 /// Provides a convenient interface for different programming models to generate
 /// the required device actions.
 class OffloadingActionBuilder final {
   /// Flag used to trace errors in the builder.
   bool IsValid = false;

clang/test/Driver/redundant-args.c

-// RUN: %clang -target x86_64-apple-darwin10 \
-// RUN:   -Werror -x c -x c -fsyntax-only %s
+// RUN: %clang -target x86_64-apple-darwin10 -Werror -x c -x c -fsyntax-only %s
+// RUN: %clang -target x86_64-apple-darwin10 %s -### -x c 2>&1 | FileCheck %s
+
+// CHECK: warning: '-x c' after last input file has no effect