[clang][cli] NFC: Remove intermediate command line parsing functions

[jansvoboda11]

Summary

Patch D96280 moved command line round-tripping from each parsing functions into single CreateFromArgs function.

This patch cleans up the individual parsing functions, essentially merging ParseXxxImpl with ParseXxx, as the distinction is not necessary anymore.

[dexonsmith]

LGTM.

clang/include/clang/Frontend/CompilerInvocation.h

public:
 
   /// @}
 
 private:
   static bool CreateFromArgsImpl(CompilerInvocation &Res,
                                  ArrayRef<const char *> CommandLineArgs,
                                  DiagnosticsEngine &Diags, const char *Argv0);
 
-  /// Parse command line options from DiagnosticOptions.
-  static bool ParseDiagnosticArgsRoundTrip(CompilerInvocation &Res,
-                                           DiagnosticOptions &Opts,
-                                           llvm::opt::ArgList &Args,
-                                           DiagnosticsEngine *Diags = nullptr,
-                                           bool DefaultDiagColor = true);
-
   /// Generate command line options from DiagnosticOptions.
   static void GenerateDiagnosticArgs(const DiagnosticOptions &Opts,
                                      SmallVectorImpl<const char *> &Args,
                                      StringAllocator SA, bool DefaultDiagColor);
 
   /// Parse command line options that map to LangOptions.
-  static bool ParseLangArgsImpl(LangOptions &Opts, llvm::opt::ArgList &Args,
-                                InputKind IK, const llvm::Triple &T,
-                                std::vector<std::string> &Includes,
-                                DiagnosticsEngine &Diags);
+  static bool ParseLangArgs(LangOptions &Opts, llvm::opt::ArgList &Args,
 
-  static bool ParseLangArgs(CompilerInvocation &Res, LangOptions &Opts,
-                            llvm::opt::ArgList &Args, InputKind IK,
-                            const llvm::Triple &T,
-                            std::vector<std::string> &Includes,
-                            DiagnosticsEngine &Diags);
-
   /// Generate command line options from LangOptions.
   static void GenerateLangArgs(const LangOptions &Opts,
                                SmallVectorImpl<const char *> &Args,
                                StringAllocator SA, const llvm::Triple &T);
 
   /// Parse command line options that map to CodeGenOptions.
-  static bool ParseCodeGenArgsImpl(CodeGenOptions &Opts,
-                                   llvm::opt::ArgList &Args, InputKind IK,
-                                   DiagnosticsEngine &Diags,
-                                   const llvm::Triple &T,
-                                   const std::string &OutputFile,
-                                   const LangOptions &LangOptsRef);
+  static bool ParseCodeGenArgs(CodeGenOptions &Opts, llvm::opt::ArgList &Args,
+                               InputKind IK, DiagnosticsEngine &Diags,
 
-  static bool ParseCodeGenArgs(CompilerInvocation &Res, CodeGenOptions &Opts,
-                               llvm::opt::ArgList &Args, InputKind IK,
-                               DiagnosticsEngine &Diags, const llvm::Triple &T,
-                               const std::string &OutputFile,
-                               const LangOptions &LangOptsRef);
-
   // Generate command line options from CodeGenOptions.
   static void GenerateCodeGenArgs(const CodeGenOptions &Opts,
                                   SmallVectorImpl<const char *> &Args,
                                   StringAllocator SA, const llvm::Triple &T,
                                   const std::string &OutputFile,
                                   const LangOptions *LangOpts);
-
-  /// Parse command line options that map to HeaderSearchOptions.
-  static void ParseHeaderSearchArgs(CompilerInvocation &Res,
-                                    HeaderSearchOptions &Opts,
-                                    llvm::opt::ArgList &Args,
-                                    DiagnosticsEngine &Diags,
-                                    const std::string &WorkingDir);
-
-  /// Generate command line options from HeaderSearchOptions.
-  static void GenerateHeaderSearchArgs(HeaderSearchOptions &Opts,
-                                       SmallVectorImpl<const char *> &Args,
-                                       CompilerInvocation::StringAllocator SA);
 };
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags);
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
 
 } // namespace clang
 
 #endif // LLVM_CLANG_FRONTEND_COMPILERINVOCATION_H

clang/lib/Frontend/CompilerInvocation.cpp

if (Entry != ConfigOpts.Config.end() && Entry->getValue() == C.getValue())
       continue;
 
     GenerateArg(Args, OPT_analyzer_config, C.getKey() + "=" + C.getValue(), SA);
   }
 
   // Nothing to generate for FullCompilerInvocation.
 }
 
-static bool ParseAnalyzerArgsImpl(AnalyzerOptions &Opts, ArgList &Args,
-                                  DiagnosticsEngine &Diags) {
+static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
   AnalyzerOptions *AnalyzerOpts = &Opts;
   bool Success = true;
 
 #define ANALYZER_OPTION_WITH_MARSHALLING(                                      \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
if (i != 0)
       os << " ";
     os << Args.getArgString(i);
   }
   os.flush();
 
   return Success;
 }
 
-static bool ParseAnalyzerArgs(CompilerInvocation &Res, AnalyzerOptions &Opts,
-                              ArgList &Args, DiagnosticsEngine &Diags) {
-  return ParseAnalyzerArgsImpl(*Res.getAnalyzerOpts(), Args, Diags);
-}
-
 static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config,
                                  StringRef OptionName, StringRef DefaultVal) {
   return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
 }
 
 static void initOption(AnalyzerOptions::ConfigTable &Config,
                        DiagnosticsEngine *Diags,
                        StringRef &OptionField, StringRef Name,
case CodeGenOptions::FiniteLoopsKind::Always:
     GenerateArg(Args, OPT_ffinite_loops, SA);
     break;
   case CodeGenOptions::FiniteLoopsKind::Never:
     GenerateArg(Args, OPT_fno_finite_loops, SA);
     break;
   }
 }
 
-bool CompilerInvocation::ParseCodeGenArgsImpl(CodeGenOptions &Opts,
-                                              ArgList &Args, InputKind IK,
-                                              DiagnosticsEngine &Diags,
-                                              const llvm::Triple &T,
-                                              const std::string &OutputFile,
-                                              const LangOptions &LangOptsRef) {
+bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
+                                          InputKind IK,
   unsigned NumErrorsBefore = Diags.getNumErrors();
 
   bool Success = true;
 
   unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
   // TODO: This could be done in Driver
   unsigned MaxOptLevel = 3;
   if (OptimizationLevel > MaxOptLevel) {
#undef CODEGEN_OPTION_WITH_MARSHALLING
   if (Args.hasArg(options::OPT_ffinite_loops))
     Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Always;
   else if (Args.hasArg(options::OPT_fno_finite_loops))
     Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Never;
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
-bool CompilerInvocation::ParseCodeGenArgs(
-    CompilerInvocation &Res, CodeGenOptions &Opts, ArgList &Args, InputKind IK,
-    DiagnosticsEngine &Diags, const llvm::Triple &T,
-    const std::string &OutputFile, const LangOptions &LangOptsRef) {
-  return ParseCodeGenArgsImpl(Res.getCodeGenOpts(), Args, IK, Diags, T,
-                              OutputFile, LangOptsRef);
-}
-
 static void
 GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts,
                              SmallVectorImpl<const char *> &Args,
                              CompilerInvocation::StringAllocator SA) {
   const DependencyOutputOptions &DependencyOutputOpts = Opts;
 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(                             \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
case EDK_ProfileList:
       continue;
     case EDK_DepFileEntry:
       GenerateArg(Args, OPT_fdepfile_entry, Dep.first, SA);
       break;
     }
   }
 }
 
-static bool ParseDependencyOutputArgsImpl(
-    DependencyOutputOptions &Opts, ArgList &Args,
-    DiagnosticsEngine &Diags,
-    frontend::ActionKind Action, bool ShowLineMarkers) {
+static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
+                                      ArgList &Args, DiagnosticsEngine &Diags,
+                                      frontend::ActionKind Action,
+                                      bool ShowLineMarkers) {
   unsigned NumErrorsBefore = Diags.getNumErrors();
   bool Success = true;
 
   DependencyOutputOptions &DependencyOutputOpts = Opts;
 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(                             \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
for (const auto *A : Args.filtered(OPT_fmodule_file)) {
     StringRef Val = A->getValue();
     if (Val.find('=') == StringRef::npos)
       Opts.ExtraDeps.emplace_back(std::string(Val), EDK_ModuleFile);
   }
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
-static bool ParseDependencyOutputArgs(CompilerInvocation &Res,
-                                      DependencyOutputOptions &Opts,
-                                      ArgList &Args, DiagnosticsEngine &Diags,
-                                      frontend::ActionKind Action,
-                                      bool ShowLineMarkers) {
-  return ParseDependencyOutputArgsImpl(Res.getDependencyOutputOpts(), Args,
-                                       Diags, Action, ShowLineMarkers);
-}
-
 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
   // Color diagnostics default to auto ("on" if terminal supports) in the driver
   // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
   // Support both clang's -f[no-]color-diagnostics and gcc's
   // -f[no-]diagnostics-colors[=never|always|auto].
   enum {
     Colors_On,
     Colors_Off,
#undef DIAG_OPTION_WITH_MARSHALLING
   }
 
   addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
   addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
 
   return Success;
 }
 
-bool CompilerInvocation::ParseDiagnosticArgsRoundTrip(CompilerInvocation &Res,
-                                                      DiagnosticOptions &Opts,
-                                                      ArgList &Args,
-                                                      DiagnosticsEngine *Diags,
-                                                      bool DefaultDiagColor) {
-  return clang::ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, Diags,
-                                    DefaultDiagColor);
-}
-
 /// Parse the argument to the -ftest-module-file-extension
 /// command-line argument.
 ///
 /// \returns true on error, false on success.
 static bool parseTestModuleFileExtensionArg(StringRef Arg,
                                             std::string &BlockName,
                                             unsigned &MajorVersion,
                                             unsigned &MinorVersion,
if (Opts.AuxTargetFeatures.hasValue())
     GenerateArg(Args, OPT_x, Lang + Header + ModuleMap + Preprocessed, SA);
   }
 
   // OPT_INPUT has a unique class, generate it directly.
   for (const auto &Input : Opts.Inputs)
     Args.push_back(SA(Input.getFile()));
 }
 
-static bool ParseFrontendArgsImpl(FrontendOptions &Opts, ArgList &Args,
-                                  DiagnosticsEngine &Diags,
-                                  bool &IsHeaderFile) {
+static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
+                              DiagnosticsEngine &Diags, bool &IsHeaderFile) {
   FrontendOptions &FrontendOpts = Opts;
   bool Success = true;
   unsigned NumErrorsBefore = Diags.getNumErrors();
 #define FRONTEND_OPTION_WITH_MARSHALLING(                                      \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
     Opts.Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
   }
 
   Opts.DashX = DashX;
 
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 
-static bool ParseFrontendArgs(CompilerInvocation &Res, FrontendOptions &Opts,
-                              ArgList &Args, DiagnosticsEngine &Diags,
-                              bool &IsHeaderFile) {
-  return ParseFrontendArgsImpl(Res.getFrontendOpts(), Args, Diags,
-                               IsHeaderFile);
-}
-
 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
                                                  void *MainAddr) {
   std::string ClangExecutable =
       llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
   return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
 }
 
-void CompilerInvocation::GenerateHeaderSearchArgs(
-    HeaderSearchOptions &Opts, SmallVectorImpl<const char *> &Args,
+static void GenerateHeaderSearchArgs(HeaderSearchOptions &Opts,
+                                     SmallVectorImpl<const char *> &Args,
                                      CompilerInvocation::StringAllocator SA) {
   const HeaderSearchOptions *HeaderSearchOpts = &Opts;
 #define HEADER_SEARCH_OPTION_WITH_MARSHALLING(                                 \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
   GENERATE_OPTION_WITH_MARSHALLING(                                            \
       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
Opts.AddSystemHeaderPrefix(
         A->getValue(), A->getOption().matches(OPT_system_header_prefix));
 
   for (const auto *A : Args.filtered(OPT_ivfsoverlay))
     Opts.AddVFSOverlayFile(A->getValue());
 
   return Success;
 }
 
-void CompilerInvocation::ParseHeaderSearchArgs(CompilerInvocation &Res,
-                                               HeaderSearchOptions &Opts,
-                                               ArgList &Args,
-                                               DiagnosticsEngine &Diags,
-                                               const std::string &WorkingDir) {
-  ::ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args, Diags, WorkingDir);
-}
-
 void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
                                          const llvm::Triple &T,
                                          std::vector<std::string> &Includes,
                                          LangStandard::Kind LangStd) {
   // Set some properties which depend solely on the input kind; it would be nice
   // to move these to the language standard, and have the driver resolve the
   // input kind + language standard.
   //
else if (Opts.getSignReturnAddressScope() ==
            LangOptions::SignReturnAddressScopeKind::NonLeaf)
     GenerateArg(Args, OPT_msign_return_address_EQ, "non-leaf", SA);
 
   if (Opts.getSignReturnAddressKey() ==
       LangOptions::SignReturnAddressKeyKind::BKey)
     GenerateArg(Args, OPT_msign_return_address_key_EQ, "b_key", SA);
 }
 
-bool CompilerInvocation::ParseLangArgsImpl(LangOptions &Opts, ArgList &Args,
-                                           InputKind IK, const llvm::Triple &T,
-                                           std::vector<std::string> &Includes,
-                                           DiagnosticsEngine &Diags) {
+bool CompilerInvocation::ParseLangArgs(LangOptions &Opts, ArgList &Args,
   unsigned NumErrorsBefore = Diags.getNumErrors();
 
   // FIXME: Cleanup per-file based stuff.
   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
     LangStd = LangStandard::getLangKind(A->getValue());
     if (LangStd == LangStandard::lang_unspecified) {
       Diags.Report(diag::err_drv_invalid_value)
if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
               << A->getAsString(Args) << SignKey;
       }
     }
   }
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
-bool CompilerInvocation::ParseLangArgs(CompilerInvocation &Res,
-                                       LangOptions &Opts,
-                                       llvm::opt::ArgList &Args, InputKind IK,
-                                       const llvm::Triple &T,
-                                       std::vector<std::string> &Includes,
-                                       DiagnosticsEngine &Diags) {
-  return ParseLangArgsImpl(*Res.getLangOpts(), Args, IK, T, Includes, Diags);
-}
-
 static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
   switch (Action) {
   case frontend::ASTDeclList:
   case frontend::ASTDump:
   case frontend::ASTPrint:
   case frontend::ASTView:
   case frontend::EmitAssembly:
   case frontend::EmitBC:
#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
 
   for (const auto &RF : Opts.RemappedFiles)
     GenerateArg(Args, OPT_remap_file, RF.first + ";" + RF.second, SA);
 
   // Don't handle LexEditorPlaceholders. It is implied by the action that is
   // generated elsewhere.
 }
 
-static bool ParsePreprocessorArgsImpl(PreprocessorOptions &Opts, ArgList &Args,
-                                      DiagnosticsEngine &Diags,
-                                      frontend::ActionKind Action,
-                                      const FrontendOptions &FrontendOpts) {
+static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
   PreprocessorOptions *PreprocessorOpts = &Opts;
   bool Success = true;
 
 #define PREPROCESSOR_OPTION_WITH_MARSHALLING(                                  \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
   // preprocessor as we never want to emit the
   // "editor placeholder in source file" error in PP only mode.
   if (isStrictlyPreprocessorAction(Action))
     Opts.LexEditorPlaceholders = false;
 
   return Success;
 }
 
-static bool ParsePreprocessorArgs(CompilerInvocation &Res,
-                                  PreprocessorOptions &Opts, ArgList &Args,
-                                  DiagnosticsEngine &Diags,
-                                  frontend::ActionKind Action,
-                                  FrontendOptions &FrontendOpts) {
-  return ParsePreprocessorArgsImpl(Res.getPreprocessorOpts(), Args, Diags,
-                                   Action, Res.getFrontendOpts());
-}
-
 static void GeneratePreprocessorOutputArgs(
     const PreprocessorOutputOptions &Opts, SmallVectorImpl<const char *> &Args,
     CompilerInvocation::StringAllocator SA, frontend::ActionKind Action) {
   const PreprocessorOutputOptions &PreprocessorOutputOpts = Opts;
 
 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(                           \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
   GENERATE_OPTION_WITH_MARSHALLING(                                            \
       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
 #include "clang/Driver/Options.inc"
 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
 
   bool Generate_dM = isStrictlyPreprocessorAction(Action) && !Opts.ShowCPP;
   if (Generate_dM)
     GenerateArg(Args, OPT_dM, SA);
   if (!Generate_dM && Opts.ShowMacros)
     GenerateArg(Args, OPT_dD, SA);
 }
 
-static bool ParsePreprocessorOutputArgsImpl(PreprocessorOutputOptions &Opts,
-                                            ArgList &Args,
-                                            DiagnosticsEngine &Diags,
-                                            frontend::ActionKind Action) {
+static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
+                                        ArgList &Args, DiagnosticsEngine &Diags,
   PreprocessorOutputOptions &PreprocessorOutputOpts = Opts;
   unsigned NumErrorsBefore = Diags.getNumErrors();
   bool Success = true;
 
 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(                           \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
   PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM,        \
                                 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,          \
                                 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER,      \
                                 MERGER, TABLE_INDEX)
 #include "clang/Driver/Options.inc"
 #undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
 
   Opts.ShowCPP = isStrictlyPreprocessorAction(Action) && !Args.hasArg(OPT_dM);
   Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
-static bool ParsePreprocessorOutputArgs(CompilerInvocation &Res,
-                                        PreprocessorOutputOptions &Opts,
-                                        ArgList &Args, DiagnosticsEngine &Diags,
-                                        frontend::ActionKind Action) {
-  return ParsePreprocessorOutputArgsImpl(Res.getPreprocessorOutputOpts(), Args,
-                                         Diags, Action);
-}
-
 static void GenerateTargetArgs(const TargetOptions &Opts,
                                SmallVectorImpl<const char *> &Args,
                                CompilerInvocation::StringAllocator SA) {
   const TargetOptions *TargetOpts = &Opts;
 #define TARGET_OPTION_WITH_MARSHALLING(                                        \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
     MERGER, EXTRACTOR, TABLE_INDEX)                                            \
   GENERATE_OPTION_WITH_MARSHALLING(                                            \
       Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,    \
       IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX)
 #include "clang/Driver/Options.inc"
 #undef TARGET_OPTION_WITH_MARSHALLING
 
   if (!Opts.SDKVersion.empty())
     GenerateArg(Args, OPT_target_sdk_version_EQ, Opts.SDKVersion.getAsString(),
                 SA);
 }
 
-static bool ParseTargetArgsImpl(TargetOptions &Opts, ArgList &Args,
-                                DiagnosticsEngine &Diags) {
+static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
   TargetOptions *TargetOpts = &Opts;
   unsigned NumErrorsBefore = Diags.getNumErrors();
   bool Success = true;
 
 #define TARGET_OPTION_WITH_MARSHALLING(                                        \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
     HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH,   \
     DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
if (Version.tryParse(A->getValue()))
           << A->getAsString(Args) << A->getValue();
     else
       Opts.SDKVersion = Version;
   }
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
-static bool ParseTargetArgs(CompilerInvocation &Res, TargetOptions &Opts,
-                            ArgList &Args, DiagnosticsEngine &Diags) {
-  return ParseTargetArgsImpl(Res.getTargetOpts(), Args, Diags);
-}
-
 bool CompilerInvocation::CreateFromArgsImpl(
     CompilerInvocation &Res, ArrayRef<const char *> CommandLineArgs,
     DiagnosticsEngine &Diags, const char *Argv0) {
   bool Success = true;
 
   // Parse the arguments.
   const OptTable &Opts = getDriverOptTable();
   const unsigned IncludedFlagsBitmask = options::CC1Option;
for (const auto *A : Args.filtered(OPT_UNKNOWN)) {
     else
       Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
           << ArgString << Nearest;
     Success = false;
   }
 
   Success &= ParseFileSystemArgs(Res.getFileSystemOpts(), Args, Diags);
   Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args, Diags);
-  Success &= ParseAnalyzerArgs(Res, *Res.getAnalyzerOpts(), Args, Diags);
-  Success &=
-      ParseDiagnosticArgsRoundTrip(Res, Res.getDiagnosticOpts(), Args, &Diags,
-                                   /*DefaultDiagColor=*/false);
-  Success &= ParseFrontendArgs(Res, Res.getFrontendOpts(), Args, Diags,
+  Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
+  Success &= ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
+  Success &= ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
                                LangOpts.IsHeaderFile);
   // FIXME: We shouldn't have to pass the DashX option around here
   InputKind DashX = Res.getFrontendOpts().DashX;
-  Success &= ParseTargetArgs(Res, Res.getTargetOpts(), Args, Diags);
+  Success &= ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
   llvm::Triple T(Res.getTargetOpts().Triple);
-  ParseHeaderSearchArgs(Res, Res.getHeaderSearchOpts(), Args, Diags,
+  ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args, Diags,
                         Res.getFileSystemOpts().WorkingDir);
   if (DashX.getFormat() == InputKind::Precompiled ||
       DashX.getLanguage() == Language::LLVM_IR) {
     // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
     // PassManager in BackendUtil.cpp. They need to be initializd no matter
     // what the input type is.
     if (Args.hasArg(OPT_fobjc_arc))
       LangOpts.ObjCAutoRefCount = 1;
     // PIClevel and PIELevel are needed during code generation and this should be
     // set regardless of the input type.
     LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
     LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
     parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
                         Diags, LangOpts.Sanitize);
   } else {
     // Other LangOpts are only initialized when the input is not AST or LLVM IR.
     // FIXME: Should we really be calling this for an Language::Asm input?
-    Success &= ParseLangArgs(Res, LangOpts, Args, DashX, T,
+    Success &= ParseLangArgs(LangOpts, Args, DashX, T,
                              Res.getPreprocessorOpts().Includes, Diags);
     if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
       LangOpts.ObjCExceptions = 1;
   }
 
   if (LangOpts.CUDA) {
     // During CUDA device-side compilation, the aux triple is the
     // triple used for host compilation.
     if (LangOpts.CUDAIsDevice)
       Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
   }
 
   // Set the triple of the host for OpenMP device compile.
   if (LangOpts.OpenMPIsDevice)
     Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
 
-  Success &= ParseCodeGenArgs(Res, Res.getCodeGenOpts(), Args, DashX, Diags, T,
+  Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags, T,
                               Res.getFrontendOpts().OutputFile, LangOpts);
 
   // FIXME: Override value name discarding when asan or msan is used because the
   // backend passes depend on the name of the alloca in order to print out
   // names.
   Res.getCodeGenOpts().DiscardValueNames &=
       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
       !LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
       !LangOpts.Sanitize.has(SanitizerKind::Memory) &&
       !LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
 
-  ParsePreprocessorArgs(Res, Res.getPreprocessorOpts(), Args, Diags,
+  ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, Diags,
                         Res.getFrontendOpts().ProgramAction,
                         Res.getFrontendOpts());
-  ParsePreprocessorOutputArgs(Res, Res.getPreprocessorOutputOpts(), Args, Diags,
+  ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args, Diags,
                               Res.getFrontendOpts().ProgramAction);
 
-  ParseDependencyOutputArgs(Res, Res.getDependencyOutputOpts(), Args, Diags,
+  ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args, Diags,
                             Res.getFrontendOpts().ProgramAction,
                             Res.getPreprocessorOutputOpts().ShowLineMarkers);
   if (!Res.getDependencyOutputOpts().OutputFile.empty() &&
       Res.getDependencyOutputOpts().Targets.empty()) {
     Diags.Report(diag::err_fe_dependency_file_requires_MT);
     Success = false;
   }