[flang][driver] Add support for `-J/-module-dir`

[arnamoy10]

Summary

Add support for option -J/-module-dir in the new Flang driver.
This will allow for including module files in other directories, as the default search path is currently the working folder. This also provides an option of storing the output module in the specified folder.

[awarzynski]

@arnamoy10, thank you for this patch and for working on this! I have a few high-level suggestions (+ some inline comments):

Q1
-module-dir and -J in Options.td should be aliases - otherwise we need to duplicate some code. I've not used Aliases myself, but perhaps this example could be helpful. You might discover that supporting 2 different spellings for one options is currently not possible. In such case we should start with one spelling.

Q2
Could you try moving your changes from FrontendActions.cpp to CompilerInvocation.cpp/CompilerInstance.cpp? Ideally, CompilerInvocation should encapsulate all compiler and langauge options relevant to the current invocation. Once we enter FrontendActions::ExecuteAction, all of them should be set and ready. This way ExecuteAction focuses on the action itself rather than setting it up. Also, adding Fortran::semantics::SemanticsContext to CompilerInstance could help with encapsulation.

Q3
What about help text for -J?

Thank you, this is looking really good and it's great to see more people working on the new driver!

clang/include/clang/Driver/Options.td

1006–1007

As we are trying to follow gfortran, I suggest that we copy the help message from there:

$ gfortran --help=separate | grep '\-J'
  -J<directory>               Put MODULE files in 'directory'

Also, we can add the long version (via DocBrief field) from here https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html:

This option specifies where to put .mod files for compiled modules. It is also added to the list of directories to searched by an USE statement.

The default is the current directory.

I appreciate that this patch only implements the 2nd part of what the option is intended to offer (i.e. updates the search patch for module files). But I think that it's worthwhile to make the intent behind this option clear from the very beginning. We can use the commit message to document the current limitations.

Also, please keep in mind that this help message is going to be re-used by -J, which belongs to gfortran_Group. So the description needs to be valid for both.

clang/lib/Driver/ToolChains/Flang.cpp

24

Are -J and -module-dir really preprocessor options? Wouldn't OPT_J and OPT_module_dir be better suited in ConstructJob (or some other method for other options)?

92

This is an unrelated change. I'm fine with this, but ideally as a separate NFC patch (otherwise the history is distorted).

flang/include/flang/Frontend/PreprocessorOptions.h

34

IMHO searchDirectoryFromDashJ would be::

• more consistent (matches searchDirectoryFromDashI)
• more accurate (internally this is only used for defining search directories)

flang/include/flang/Parser/parsing.h

35

This is merely module _search_ directory, right? Perhaps worth renaming as moduleSearchDirectory?

Also, is it required by the parser? IIUC, it's only used when calling set_moduleDirectory, which is part of Fortran::semantics::SemanticsContext.

flang/lib/Frontend/CompilerInvocation.cpp

186

searchDirectoriesFromDashI contains search directories specified with -I. If we add things from -J then the name is no longer valid :) One option is to rename the variable. Personally I think that we can skip this line.

205

Unrelated change

flang/lib/Frontend/FrontendActions.cpp

104

I think that we can safely set a default value for moduleDirectory and skip this check. From https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html:

The default is the current directory.

flang/test/Flang-Driver/include-module.f90

11

What about:

• -J %S/Inputs -J %S/Inputs/module-dir (i.e. -J + -J)
• -J %S/Inputs -module-dir %S/Inputs/module-dir (i.e. -J + -module-dir)
• -module-dir %S/Inputs -J%S/Inputs/module-dir (i.e. -module-dir + -J)
• -module-dir %S/Inputs -I%S/Inputs/module-dir (.e. -module-dir + -I)

I appreciate that this is a bit tedious, but IMO it is worthwhile to add a few more cases here to avoid any unpleasant breakage in the future. Also - what should the relation between -I and -J be here? As in, which ought to have higher priority?

[awarzynski]

@arnamoy10 , could you also add tests that show that -J/-module-dir is taken into account when deciding where to put module files? Thank you!

[arnamoy10]

Addressing reviewers' comments with the following changes:

1. Aliasing of -module-dir and -J to avoid code duplication
2. Moving the code to set the module and search directories from FrontendActions.cpp to CompilerInvocation.cpp
3. Data structures updated/ variables added to separate Preprocessor options from Compiler Options
4. Added more test cases.

[arnamoy10]

Added test for the driver-help, also contains all the changes that was done in the previous diff (Aliasing -J and -module-dir, changing data structures etc).

[tskeith]

clang/include/clang/Driver/Options.td

1010

It would be better to make -module-dir the main option and -J the alias. -J is only there for gfortran compatibility, not because it is a good name for the option.

flang/include/flang/Frontend/CompilerInstance.h

103

semanticsContext would be a better name for this function.

flang/include/flang/Frontend/CompilerInvocation.h

67 ↗

(On Diff #320184)

moduleDir_ would be a better name.

flang/lib/Frontend/CompilerInstance.cpp

29 ↗

(On Diff #320184)

Why is semantics_ a shared_ptr rather than a simple data member of type SemanticsContext? It's owned by only CompilerInstance, not shared.
The same question probably applies to the other fields too.

[arnamoy10]

Addressing reviewers' comments, adding -module-dir as the default option instead of -J

[awarzynski]

@arnamoy10 Thank you for addressing my comments!

As for testing that -J/-module-dir are taken into account when specifying the output directory for modules, could try adding the following:

! RUN: mkdir -p %t/dir-f18 && %f18 -fparse-only -I tools/flang/include/flang -module %t/dir-f18 %s  2>&1
! RUN: ls %t/dir/testmodule.mod && not ls %t/testmodule.mod

! RUN: mkdir -p %t/dir-flang-new && %flang-new -fsyntax-only -module-dir %t/dir-flang-new %s  2>&1
! RUN: ls %t/dir/testmodule.mod && not ls %t/testmodule.mod

module testmodule
  type::t2
  end type
end

It's possible that flang-new doesn't support writing modules yet, but IMHO this is the right moment to try and understand what might be missing. Thank you!

clang/include/clang/Driver/Options.td

1006–1007

No indentation in DocBrief, see this example

Also, Put MODULE files in 'directory' -> Put MODULE files in <dir> (the option is displayed as -module-dir <dir>).

4105

There's no need to move this, is there? I feel that it's better to keep all gfortran options together.

flang/include/flang/Frontend/CompilerInstance.h

103

We should follow Flang's coding style here:

Accessor member functions are named with the non-public data member's name, less the trailing underscore.

i.e. semantics() rather than semanticsContext(). If we were to diverge from that, then I suggest that we follow the style prevalent in LLVM/Clang, see e.g. getSema.

@tskeith, I'm guessing that you wanted the member variable to be updated too:

• semantics_ -> semanticsContext_

Makes sense to me.

flang/lib/Frontend/CompilerInstance.cpp

29 ↗

(On Diff #320184)

@tskeith You raise two important points here:

Why shared_ptr if the resource is not shared?
From what I can see, at this point the SemanticsContext is not shared and we can safely use unique_ptr instead.

Why are semantics_ and other members of CompilerInstance pointers?
CompilerInstance doesn't really own much - it just encapsulates all classes/structs that are required for creating a _compiler instance_. It's kept lightweight and written in a way that makes it easy to _inject_ custom instances of these classes. This approach is expected to be helpful when creating new frontend actions (I expect that there will be a lot) and when compiling projects with many source files.

@tskeith, I intend to document the design of the new driver soon and suggest that that's when we re-open the discussion on the design of CompilerInstance.

IMO this change is consistent with the current design and I think that we should accept it as is.

Small suggestion
@arnamoy10 , I think that you can safely add IntrinsicTypeDefaultKinds and LanguageFeatureControl members too. We will need them shortly and this way this constructor becomes much cleaner. I'm fine either way!

flang/lib/Frontend/CompilerInvocation.cpp

302

The argument is not needed here, is it? You could just write:

auto &semaCtx = semanticsContext()

Or am I missing something?

flang/lib/Frontend/FrontendActions.cpp

101–107

[nit] Unrelated change

flang/test/Flang-Driver/include-module.f90

15

Why --check-prefix=SINGLEINCLUDE here and below? Both directories are included, so there should be no errors.

[awarzynski]

flang/test/Flang-Driver/include-module.f90

15

Apologies, I was wrong with regard to how -J/-module-dir should work:

$ gfortran -J test-dir/ -J test-dir/ test.f
f951: Fatal Error: gfortran: Only one ‘-J’ option allowed
compilation terminated.

gfortran behavior makes a lot of sense to me and I suggest that we replicate that. This means that we should issue a diagnostic when -J/-module-dir is used twice.

[tskeith]

flang/include/flang/Frontend/CompilerInstance.h

103

@tskeith, I'm guessing that you wanted the member variable to be updated too:

• semantics_ -> semanticsContext_

Right.

flang/lib/Frontend/CompilerInstance.cpp

29 ↗

(On Diff #320184)

Why are semantics_ and other members of CompilerInstance pointers?
CompilerInstance doesn't really own much - it just encapsulates all classes/structs that are required for creating a _compiler instance_.

As it stands it does own the instance of SemanticsContext etc. No one else does.

@tskeith, I intend to document the design of the new driver soon and suggest that that's when we re-open the discussion on the design of CompilerInstance.

OK

[arnamoy10]

A few more comments addressed and a new test case added for write-module check.

[awarzynski]

LGTM!

Thank you for addressing my comments, (DELETEME can be fixed when pushing upstream)! From what I can see you've also addressed all of Tim's comments, but could you wait a day or two before merging this? Just in case I missed something, or Tim or somebody else has further comments.

flang/lib/Frontend/CompilerInvocation.cpp

202–203

DELETEME

flang/lib/Frontend/FrontendActions.cpp

82–83

DELETEME

[arnamoy10]

Sounds good to me, thanks for the help. In the meantime I will work on the fdefault-* family of flags, which will be dependent on this patch I think.

PS: Please disregard the below comments, those were drafts, some of them are invalid, sorry about that.

clang/include/clang/Driver/Options.td

1010

Sure, we can do that. I just chose -J to be default as it is easier to type for the user :)

4105

This needs to be moved, as we are using Aliases. The way Aliases work is (in this order) (1) you create the base option (that

flang/lib/Frontend/CompilerInstance.cpp

29 ↗

(On Diff #320184)

No idea about this design decision. I have not found any other DS that is "sharing" these pointers. I can take them out.

flang/lib/Frontend/CompilerInvocation.cpp

302

semanticsContext_ belongs to CompilerInstance, not CompilerInvocation, so unfortunately that is not possible.

flang/test/Flang-Driver/include-module.f90

11

Done

[MaskRay]

clang/include/clang/Driver/Options.td

1006–1007

Is the clang file change needed?

clang -help now has -module-dir <dir> Put MODULE files in <dir> while I think the option only makes sense for flang.

clang/include/clang/Driver/Options.td

def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>,
   HelpText<"Filename (or -) to write dependency output to">,
   MarshallingInfoString<DependencyOutputOpts<"OutputFile">>;
 def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
   HelpText<"Filename to write DOT-formatted header dependencies to">,
   MarshallingInfoString<DependencyOutputOpts<"DOTOutputFile">>;
 def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
   Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">,
   MarshallingInfoString<DependencyOutputOpts<"ModuleDependencyOutputDir">>;
+def module_dir : Separate<["-"], "module-dir">,
+  Flags<[FlangOption,FC1Option]>, HelpText<"Add to the list of directories to be searched by an USE statement">;
 def dsym_dir : JoinedOrSeparate<["-"], "dsym-dir">,
   Flags<[NoXarchOption, RenderAsInput]>,
   HelpText<"Directory to output dSYM's (if any) to">, MetaVarName<"<dir>">;
 def dumpmachine : Flag<["-"], "dumpmachine">;
 def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
 def dumpversion : Flag<["-"], "dumpversion">;
 def dylib__file : Separate<["-"], "dylib_file">;
 def dylinker__install__name : JoinedOrSeparate<["-"], "dylinker_install_name">;
 def dylinker : Flag<["-"], "dylinker">;
 def dynamiclib : Flag<["-"], "dynamiclib">;
 def dynamic : Flag<["-"], "dynamic">, Flags<[NoArgumentUnused]>;

 defm web : BooleanFFlag<"web">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm whole_program : BooleanFFlag<"whole-program">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm devirtualize : BooleanFFlag<"devirtualize">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm devirtualize_speculatively : BooleanFFlag<"devirtualize-speculatively">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 
 // Generic gfortran options.
 def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>;
-def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Group<gfortran_Group>;
+def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined,FlangOption,FC1Option]>, Group<gfortran_Group>;
 def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>;
 def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>;
 def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>;
 
 // "f" options with values for gfortran.
 def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>;
 def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>;
 def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>;

clang/lib/Driver/ToolChains/Flang.cpp

 //===-- Flang.cpp - Flang+LLVM ToolChain Implementations --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "Flang.h"
 #include "CommonArgs.h"
 
 #include "clang/Driver/Options.h"
 
 #include <cassert>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 void Flang::AddPreprocessingOptions(const ArgList &Args,
                                     ArgStringList &CmdArgs) const {
-  Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
+  Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I,
+                            options::OPT_J, options::OPT_module_dir});
 }
 
 void Flang::ConstructJob(Compilation &C, const JobAction &JA,
                          const InputInfo &Output, const InputInfoList &Inputs,
                          const ArgList &Args, const char *LinkingOutput) const {
   const auto &TC = getToolChain();
   // TODO: Once code-generation is available, this will need to be commented
   // out.
if (Output.isFilename()) {
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
-  const auto& D = C.getDriver();
+  const auto &D = C.getDriver();
   // TODO: Replace flang-new with flang once the new driver replaces the
   // throwaway driver
   const char *Exec = Args.MakeArgString(D.GetProgramPath("flang-new", TC));
   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileUTF8(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 Flang::Flang(const ToolChain &TC) : Tool("flang-new", "flang frontend", TC) {}
 
 Flang::~Flang() {}

flang/include/flang/Frontend/CompilerInstance.h

public:
   /// {
 
   /// Return parsing to be used by Actions.
   Fortran::parser::Parsing &parsing() const { return *parsing_; }
 
   /// }
   /// @name Semantic analysis
   /// {
 
   /// Replace the current stream for verbose output.
   void set_semaOutputStream(llvm::raw_ostream &Value);
 
   /// Replace the current stream for verbose output.
   void set_semaOutputStream(std::unique_ptr<llvm::raw_ostream> Value);
 
   /// Get the current stream for verbose output.
   llvm::raw_ostream &semaOutputStream() { return *semaOutputStream_; }
const clang::DiagnosticOptions &GetDiagnosticOpts() const {
     return invocation_->GetDiagnosticOpts();
   }
 
   FrontendOptions &frontendOpts() { return invocation_->frontendOpts(); }
   const FrontendOptions &frontendOpts() const {
     return invocation_->frontendOpts();
   }
 
+  Fortran::parser::Options &fortranOpts() { return invocation_->fortranOpts(); }
+  const Fortran::parser::Options &fortranOpts() const {
+    return invocation_->fortranOpts();
+  }
+
   PreprocessorOptions &preprocessorOpts() {
     return invocation_->preprocessorOpts();
   }
   const PreprocessorOptions &preprocessorOpts() const {
     return invocation_->preprocessorOpts();
   }
 
   /// }

flang/include/flang/Frontend/PreprocessorOptions.h

 public:
   std::vector<std::pair<std::string, /*isUndef*/ bool>> macros;
   // Search directories specified by the user with -I
   // TODO: When adding support for more options related to search paths,
   // consider collecting them in a separate aggregate. For now we keep it here
   // as there is no point creating a class for just one field.
   std::vector<std::string> searchDirectoriesFromDashI;
 
+  // Module directory specified by -J
+  std::string moduleDirJ;
+
 public:
   PreprocessorOptions() {}
 
   void addMacroDef(llvm::StringRef name) {
     macros.emplace_back(std::string(name), false);
   }
 
   void addMacroUndef(llvm::StringRef name) {
     macros.emplace_back(std::string(name), true);
   }
 };
 
 } // namespace Fortran::frontend
 
-#endif // LLVM_FLANG_PREPROCESSOROPTIONS_H
+#endif // LLVM_FLANG_PREPROCESSOROPTIONS_H
 

flang/include/flang/Parser/parsing.h

struct Options {
   Options() {}
 
   using Predefinition = std::pair<std::string, std::optional<std::string>>;
 
   bool isFixedForm{false};
   int fixedFormColumns{72};
   common::LanguageFeatureControl features;
   std::vector<std::string> searchDirectories;
+  std::string moduleDirectory;
   std::vector<Predefinition> predefinitions;
   bool instrumentedParse{false};
   bool isModuleFile{false};
   bool needProvenanceRangeToCharBlockMappings{false};
 };
 
 class Parsing {
 public:

flang/lib/Frontend/CompilerInvocation.cpp

for (const auto *currentArg : args.filtered(
            clang::driver::options::OPT_D, clang::driver::options::OPT_U)) {
     if (currentArg->getOption().matches(clang::driver::options::OPT_D)) {
       opts.addMacroDef(currentArg->getValue());
     } else {
       opts.addMacroUndef(currentArg->getValue());
     }
   }
 
-  // Add the ordered list of -I's.
+  // Add the ordered list of -I's and -J to the search directories.
   for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I))
     opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
+  for (const auto *currentArg : args.filtered(clang::driver::options::OPT_J)) {
+    opts.moduleDirJ = currentArg->getValue();
+    opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
+  }
+
+  // Add the -J to the output module directory.
+  for (const auto *currentArg :
+      args.filtered(clang::driver::options::OPT_module_dir)) {
+    opts.moduleDirJ = currentArg->getValue();
+    opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
+  }
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
     llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
 
   // Parse the arguments
   const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable();
-  const unsigned includedFlagsBitmask =
-      clang::driver::options::FC1Option;
+  const unsigned includedFlagsBitmask = clang::driver::options::FC1Option;
   unsigned missingArgIndex, missingArgCount;
   llvm::opt::InputArgList args = opts.ParseArgs(
       commandLineArgs, missingArgIndex, missingArgCount, includedFlagsBitmask);
 
   // Issue errors on unknown arguments
   for (const auto *a : args.filtered(clang::driver::options::OPT_UNKNOWN)) {
     auto argString = a->getAsString(args);
     std::string nearest;

 }
 
 void CompilerInvocation::setFortranOpts() {
   auto &fortranOptions = fortranOpts();
   const auto &preprocessorOptions = preprocessorOpts();
 
   collectMacroDefinitions(preprocessorOptions, fortranOptions);
 
+  // Set up the search directories and output module directory properly.
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromDashI.begin(),
       preprocessorOptions.searchDirectoriesFromDashI.end());
+  fortranOptions.moduleDirectory = preprocessorOptions.moduleDirJ;
 }

flang/lib/Frontend/FrontendActions.cpp

void PrintPreprocessedAction::ExecuteAction() {
   }
 }
 
 void ParseSyntaxOnlyAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
 
   // TODO: These should be specifiable by users. For now just use the defaults.
   common::LanguageFeatureControl features;
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
 
   // Parse. In case of failure, report and return.
   ci.parsing().Parse(llvm::outs());
 
   if (ci.parsing().messages().AnyFatalError()) {
     unsigned diagID = ci.diagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "Could not parse %0");
     ci.diagnostics().Report(diagID) << GetCurrentFileOrBufferName();
 
     ci.parsing().messages().Emit(
         llvm::errs(), this->instance().allCookedSources());
     return;
   }
 
   auto &parseTree{*ci.parsing().parseTree()};
 
   // Prepare semantics
   Fortran::semantics::SemanticsContext semanticsContext{
       defaultKinds, features, ci.allCookedSources()};
+  // Check if we have a module search directory, add it
+  // Also add the search directories
+  if (!ci.fortranOpts().moduleDirectory.empty())
+    semanticsContext.set_moduleDirectory(ci.fortranOpts().moduleDirectory)
+        .set_searchDirectories(ci.fortranOpts().searchDirectories);
+
   Fortran::semantics::Semantics semantics{
       semanticsContext, parseTree, ci.parsing().cooked().AsCharBlock()};
 
   // Run semantic checks
   semantics.Perform();
 
   // Report the diagnostics from the semantic checks
   semantics.EmitMessages(ci.semaOutputStream());

flang/test/Flang-Driver/driver-help-hidden.f90

 ! CHECK-NEXT: -###      Print (but do not run) the commands to run for this compilation
 ! CHECK-NEXT: -c        Only run preprocess, compile, and assemble steps
 ! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! CHECK-NEXT: -E        Only run the preprocessor
 ! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
 ! CHECK-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
+! CHECK-NEXT: -module-dir <value> Add to the list of directories to be searched by an USE statement
 ! CHECK-NEXT: -o <file> Write output to <file>
 ! CHECK-NEXT: -test-io  Run the InputOuputTest action. Use for development and testing only.
 ! CHECK-NEXT: -U <macro>             Undefine macro <macro>
 ! CHECK-NEXT: --version Print version information
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG DRIVER (flang-new)
 !-------------------------------------------------------------
 ! ERROR-FLANG: error: unknown argument '-help-hidden'; did you mean '--help-hidden'?
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
 !-------------------------------------------------------------
 ! Frontend driver -help-hidden is not supported
 ! ERROR-FLANG-FC1: error: unknown argument: '{{.*}}'
 

flang/test/Flang-Driver/driver-help.f90

 ! HELP-NEXT: -###                   Print (but do not run) the commands to run for this compilation
 ! HELP-NEXT: -c                     Only run preprocess, compile, and assemble steps
 ! HELP-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-NEXT: -E                     Only run the preprocessor
 ! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
 ! HELP-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! HELP-NEXT: -help                  Display available options
 ! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
+! HELP-NEXT: -module-dir <value> Add to the list of directories to be searched by an USE statement
 ! HELP-NEXT: -o <file>              Write output to <file>
 ! HELP-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-NEXT: --version              Print version information
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
 !-------------------------------------------------------------
 ! HELP-FC1:USAGE: flang-new
 ! HELP-FC1-EMPTY:
 ! HELP-FC1-NEXT:OPTIONS:
 ! HELP-FC1-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E                     Only run the preprocessor
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
+! HELP-FC1-NEXT: -module-dir <value> Add to the list of directories to be searched by an USE statement
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Flang-Driver/include-module.f90

-! Ensure argument -I works as expected with module files.
+! Ensure argument -I, -J and -module-dir works as expected with module files.
 ! The module files for this test are not real module files.
 
 ! REQUIRES: new-flang-driver
 
 !--------------------------
 ! FLANG DRIVER (flang-new)
 !--------------------------
 ! RUN: not %flang-new -fsyntax-only -I %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
 ! RUN: not %flang-new -fsyntax-only -I %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
+! RUN: not %flang-new -fsyntax-only -J %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
+! RUN: not %flang-new -fsyntax-only -J %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
+! RUN: not %flang-new -fsyntax-only -module-dir %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
+! RUN: not %flang-new -fsyntax-only -module-dir %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
 
 !-----------------------------------------
 ! FRONTEND FLANG DRIVER (flang-new -fc1)
 !-----------------------------------------
 ! RUN: not %flang-new -fc1 -fsyntax-only -I %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
 ! RUN: not %flang-new -fc1 -fsyntax-only -I %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
+! RUN: not %flang-new -fc1 -fsyntax-only -J %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
+! RUN: not %flang-new -fc1 -fsyntax-only -J %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
+! RUN: not %flang-new -fc1 -fsyntax-only -module-dir %S/Inputs -I %S/Inputs/module-dir %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
+! RUN: not %flang-new -fc1 -fsyntax-only -module-dir %S/Inputs %s  2>&1 | FileCheck %s --check-prefix=SINGLEINCLUDE
 
 !-----------------------------------------
 ! EXPECTED OUTPUT FOR MISSING MODULE FILE
 !-----------------------------------------
 ! SINGLEINCLUDE:No such file or directory
 ! SINGLEINCLUDE-NOT:Error reading module file for module 'basictestmoduletwo'
 
 !---------------------------------------
 ! EXPECTED OUTPUT FOR ALL MODULES FOUND
 !---------------------------------------
 ! INCLUDED-NOT:No such file or directory
 
 program test_dash_I_with_mod_files
     USE basictestmoduleone
     USE basictestmoduletwo
 end