[driver] Prune module-map related flags, if they are not going to be needed

[akyrtzi]

Summary

This is follow-up from https://reviews.llvm.org/D132801, but taking into account the conditions
where the module-map flags are still used even when -fmodules is disabled.

This useful for removing unnecessary input dependencies from the cc1 invocation.

[rsmith]

I've landed some tests for the specific functionality that intends to use modules info under -fno-modules in b484256f59850e702df4d4532c5f31f478879bb9.

I think the approach you're taking here is probably doomed -- too many things in Clang depend on whether we've read module map files, and it seems unlikely to me that you'll be able to catch all of them from the driver. For example:

$ touch a.h
$ echo 'module a { private header "a.h" }' > module.modulemap
$ echo '#include "a.h"' > b.cc
$ clang -fmodule-map-file=module.modulemap b.cc
b.cc:1:10: error: use of private header from outside its module: 'a.h' [-Wprivate-header]
#include "a.h"
         ^
1 error generated.

(and that error can be controlled by a #pragma, so you can't even do this if the driver sees -Wno-private-header).

I wonder if we could mark a Module as "used" whenever we use information from it, and treat module map files as dependencies of the current compilation only if they're used?

[akyrtzi]

In D133229#3768101, @rsmith wrote:

I think the approach you're taking here is probably doomed -- too many things in Clang depend on whether we've read module map files, and it seems unlikely to me that you'll be able to catch all of them from the driver.

I see, the driver approach does seem like a non-starter, thank you for the feedback! This needs reevaluation.

clang/lib/Driver/ToolChains/Clang.cpp

if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules,
                      options::OPT_fno_prebuilt_implicit_modules, false))
       CmdArgs.push_back("-fprebuilt-implicit-modules");
     if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content,
                      options::OPT_fno_modules_validate_input_files_content,
                      false))
       CmdArgs.push_back("-fvalidate-ast-input-files-content");
   }
 
+  // Check whether any "-fmodule-map-file=" flags are relevant or not. This is
+  // useful for pruning the cc1 arguments and removing unnecessary input
+  // dependencies.
+  bool ModuleMapsAreRelevant = [&]() -> bool {
+    if (HaveModules)
+      return true;
+    if (Args.hasFlag(options::OPT_fmodules_decluse,
+                     options::OPT_fno_modules_decluse, false) ||
+        Args.hasFlag(options::OPT_fmodules_strict_decluse,
+                     options::OPT_fno_modules_strict_decluse, false))
+      return true;
+    for (auto Arg : Args.filtered(options::OPT_Xclang)) {
+      if (StringRef(Arg->getValue()) == "-fmodules-local-submodule-visibility")
+        return true;
+    }
+    return false;
+  }();
+
+  if (ModuleMapsAreRelevant) {
     // -fmodule-name specifies the module that is currently being built (or
     // used for header checking by -fmodule-maps).
     Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ);
 
     // -fmodule-map-file can be used to specify files containing module
     // definitions.
     Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
 
     // -fbuiltin-module-map can be used to load the clang
     // builtin headers modulemap file.
     if (Args.hasArg(options::OPT_fbuiltin_module_map)) {
       SmallString<128> BuiltinModuleMap(D.ResourceDir);
       llvm::sys::path::append(BuiltinModuleMap, "include");
       llvm::sys::path::append(BuiltinModuleMap, "module.modulemap");
       if (llvm::sys::fs::exists(BuiltinModuleMap))
         CmdArgs.push_back(
             Args.MakeArgString("-fmodule-map-file=" + BuiltinModuleMap));
     }
+  } else {
+    Args.ClaimAllArgs(options::OPT_fmodule_name_EQ);
+    Args.ClaimAllArgs(options::OPT_fmodule_map_file);
+    Args.ClaimAllArgs(options::OPT_fbuiltin_module_map);
+  }
 
   // The -fmodule-file=<name>=<file> form specifies the mapping of module
   // names to precompiled module files (the module is loaded only if used).
   // The -fmodule-file=<file> form can be used to unconditionally load
   // precompiled module files (whether used or not).
   if (HaveModules)
     Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
   else

clang/test/Driver/modules.m

 // CHECK-NO-MODULE-FILES-NOT: "-fmodules"
 // CHECK-NO-MODULE-FILES-NOT: "-fmodule-file=foo.pcm"
 // CHECK-NO-MODULE-FILES-NOT: "-fmodule-file=bar.pcm"
 
 // RUN: %clang -fno-modules -fbuild-session-file=%t.build-session-file -### %s 2>&1 | FileCheck -check-prefix=SESSION_FLAG %s
 // RUN: %clang -fno-modules -fbuild-session-timestamp=123 -### %s 2>&1 | FileCheck -check-prefix=SESSION_FLAG %s
 // SESSION_FLAG-NOT: -fbuild-session-timestamp
 
-// RUN: %clang -fno-modules -fmodules-validate-once-per-build-session -### %s 2>&1 | FileCheck -check-prefix=VALIDATE_ONCE_FLAG %s
-// VALIDATE_ONCE_FLAG-NOT: -fmodules-validate-once-per-build-session
-
-// RUN: %clang -fno-modules -fmodules-validate-system-headers -### %s 2>&1 | FileCheck -check-prefix=VALIDATE_SYSTEM_FLAG %s
-// VALIDATE_SYSTEM_FLAG-NOT: -fmodules-validate-system-headers
+// RUN: %clang -fno-modules -fmodules-validate-once-per-build-session -fmodules-validate-system-headers -fmodule-map-file=module.modulemap \
+// RUN:   -### %s 2>&1 | FileCheck -check-prefix=IGNORED_FLAGS %s
+// IGNORED_FLAGS-NOT: -fmodules-validate-once-per-build-session
+// IGNORED_FLAGS-NOT: -fmodules-validate-system-headers
+// IGNORED_FLAGS-NOT: -fmodule-map-file
+
+// RUN: %clang -fno-modules -fmodules-decluse -fmodule-map-file=module.modulemap -### %s 2>&1 | FileCheck -check-prefix=MMAPFILE %s
+// RUN: %clang -fno-modules -fmodules-strict-decluse -fmodule-map-file=module.modulemap -### %s 2>&1 | FileCheck -check-prefix=MMAPFILE %s
+// RUN: %clang -fno-modules -Xclang -fmodules-local-submodule-visibility -fmodule-map-file=module.modulemap -### %s 2>&1 | FileCheck -check-prefix=MMAPFILE %s
+// MMAPFILE: -fmodule-map-file