Frontend: Inherit compiler debugging options during module interface actions.

When building a module interface for the -typecheck-module-from-interface or
-compile-module-from-interface actions, inherit and honor compiler debugging
options and emit debugging output at the end of the interface build.

Author: tshortli

include/swift/Frontend/Frontend.h

@@ -798,6 +798,9 @@ class CompilerInstance {
   /// \returns true if any errors occurred.
   bool performSILProcessing(SILModule *silModule);
 
+  /// Dumps any debugging output for the compilation, if requested.
+  void emitEndOfPipelineDebuggingOutput();
+
 private:
   /// Creates a new source file for the main module.
   SourceFile *createSourceFileForMainModule(ModuleDecl *mod,

include/swift/Frontend/FrontendOptions.h

@@ -35,6 +35,21 @@ namespace llvm {
 namespace swift {
 enum class IntermoduleDepTrackingMode;
 
+/// Options for debugging the behavior of the frontend.
+struct CompilerDebuggingOptions {
+  /// Indicates whether or not the Clang importer should print statistics upon
+  /// termination.
+  bool PrintClangStats = false;
+
+  /// Indicates whether or not the availability scope trees built during
+  /// compilation should be dumped upon termination.
+  bool DumpAvailabilityScopes = false;
+
+  /// Indicates whether or not the Clang importer should dump lookup tables
+  /// upon termination.
+  bool DumpClangLookupTables = false;
+};
+
 /// Options for controlling the behavior of the frontend.
 class FrontendOptions {
   friend class ArgsToFrontendOptionsConverter;
@@ -124,6 +139,9 @@ class FrontendOptions {
   /// A set of modules allowed to import this module.
   std::set<std::string> AllowableClients;
 
+  /// Options for debugging the compiler.
+  CompilerDebuggingOptions CompilerDebuggingOpts;
+
   /// Emit index data for imported serialized swift system modules.
   bool IndexSystemModules = false;
 
@@ -302,18 +320,6 @@ class FrontendOptions {
   /// termination.
   bool PrintStats = false;
 
-  /// Indicates whether or not the Clang importer should print statistics upon
-  /// termination.
-  bool PrintClangStats = false;
-
-  /// Indicates whether or not the Clang importer should dump lookup tables
-  /// upon termination.
-  bool DumpClangLookupTables = false;
-
-  /// Indicates whether or not availability scopes should be dumped upon
-  /// termination.
-  bool DumpAvailabilityScopes = false;
-
   /// Indicates whether standard help should be shown.
   bool PrintHelp = false;
 

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -455,7 +455,8 @@ class ExplicitModuleMapParser {
   llvm::StringSaver Saver;
 };
 
-struct ModuleInterfaceLoaderOptions {
+class ModuleInterfaceLoaderOptions {
+public:
   FrontendOptions::ActionType requestedAction =
       FrontendOptions::ActionType::EmitModuleOnly;
   bool remarkOnRebuildFromInterface = false;
@@ -464,28 +465,11 @@ struct ModuleInterfaceLoaderOptions {
   bool disableBuildingInterface = false;
   bool downgradeInterfaceVerificationError = false;
   bool strictImplicitModuleContext = false;
+  CompilerDebuggingOptions compilerDebuggingOptions;
   std::string mainExecutablePath;
-  ModuleInterfaceLoaderOptions(const FrontendOptions &Opts):
-    remarkOnRebuildFromInterface(Opts.RemarkOnRebuildFromModuleInterface),
-    disableInterfaceLock(Opts.DisableInterfaceFileLock),
-    disableImplicitSwiftModule(Opts.DisableImplicitModules),
-    disableBuildingInterface(Opts.DisableBuildingInterface),
-    downgradeInterfaceVerificationError(Opts.DowngradeInterfaceVerificationError),
-    strictImplicitModuleContext(Opts.StrictImplicitModuleContext),
-    mainExecutablePath(Opts.MainExecutablePath)
-  {
-    switch (Opts.RequestedAction) {
-    case FrontendOptions::ActionType::TypecheckModuleFromInterface:
-      requestedAction = FrontendOptions::ActionType::Typecheck;
-      break;
-    case FrontendOptions::ActionType::ScanDependencies:
-      requestedAction = Opts.RequestedAction;
-      break;
-    default:
-      requestedAction = FrontendOptions::ActionType::EmitModuleOnly;
-      break;
-    }
-  }
+
+  ModuleInterfaceLoaderOptions(const FrontendOptions &Opts,
+                               bool inheritDebuggingOpts = false);
   ModuleInterfaceLoaderOptions() = default;
 };
 

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -197,8 +197,11 @@ bool ArgsToFrontendOptionsConverter::convert(
   computeDebugTimeOptions();
   computeTBDOptions();
 
-  Opts.DumpClangLookupTables |= Args.hasArg(OPT_dump_clang_lookup_tables);
-  Opts.DumpAvailabilityScopes |= Args.hasArg(OPT_dump_availability_scopes);
+  Opts.CompilerDebuggingOpts.DumpAvailabilityScopes |=
+      Args.hasArg(OPT_dump_availability_scopes);
+
+  Opts.CompilerDebuggingOpts.DumpClangLookupTables |=
+      Args.hasArg(OPT_dump_clang_lookup_tables);
 
   Opts.CheckOnoneSupportCompleteness = Args.hasArg(OPT_check_onone_completeness);
 
@@ -472,7 +475,8 @@ void ArgsToFrontendOptionsConverter::handleDebugCrashGroupArguments() {
 void ArgsToFrontendOptionsConverter::computePrintStatsOptions() {
   using namespace options;
   Opts.PrintStats |= Args.hasArg(OPT_print_stats);
-  Opts.PrintClangStats |= Args.hasArg(OPT_print_clang_stats);
+  Opts.CompilerDebuggingOpts.PrintClangStats |=
+      Args.hasArg(OPT_print_clang_stats);
   Opts.PrintZeroStats |= Args.hasArg(OPT_print_zero_stats);
 #if defined(NDEBUG) && !LLVM_ENABLE_STATS
   if (Opts.PrintStats || Opts.PrintClangStats)

lib/Frontend/Frontend.cpp

@@ -18,6 +18,7 @@
 #include "swift/Frontend/Frontend.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/AvailabilityDomain.h"
+#include "swift/AST/AvailabilityScope.h"
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/FileSystem.h"
@@ -1867,6 +1868,23 @@ bool CompilerInstance::performSILProcessing(SILModule *silModule) {
   return false;
 }
 
+void CompilerInstance::emitEndOfPipelineDebuggingOutput() {
+  assert(hasASTContext());
+  auto &ctx = getASTContext();
+  const auto &Invocation = getInvocation();
+  const auto &opts = Invocation.getFrontendOptions().CompilerDebuggingOpts;
+
+  if (opts.PrintClangStats && ctx.getClangModuleLoader())
+    ctx.getClangModuleLoader()->printStatistics();
+
+  if (opts.DumpAvailabilityScopes)
+    getPrimaryOrMainSourceFile().getAvailabilityScope()->dump(llvm::errs(),
+                                                              ctx.SourceMgr);
+
+  if (opts.DumpClangLookupTables && ctx.getClangModuleLoader())
+    ctx.getClangModuleLoader()->dumpSwiftLookupTables();
+}
+
 bool CompilerInstance::isCancellationRequested() const {
   auto flag = getASTContext().CancellationFlag;
   return flag && flag->load(std::memory_order_relaxed);

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -203,6 +203,7 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
     ArrayRef<std::string> CompiledCandidates,
     StringRef CompilerVersion) {
   auto Invocation = Instance.getInvocation();
+
   // Try building forwarding module first. If succeed, return.
   if (Instance.getASTContext()
           .getModuleInterfaceChecker()
@@ -254,6 +255,9 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
                  builtByCompiler);
       }
     }
+
+    // If requested, dump debugging output before exiting.
+    Instance.emitEndOfPipelineDebuggingOutput();
   };
 
   Instance.performSema();

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -1294,6 +1294,34 @@ bool ModuleInterfaceCheckerImpl::isCached(StringRef DepPath) {
   return !PrebuiltCacheDir.empty() && DepPath.starts_with(PrebuiltCacheDir);
 }
 
+static FrontendOptions::ActionType
+reqestedModuleLoaderActionForFrontendOpts(const FrontendOptions &Opts) {
+  switch (Opts.RequestedAction) {
+  case FrontendOptions::ActionType::TypecheckModuleFromInterface:
+    return FrontendOptions::ActionType::Typecheck;
+  case FrontendOptions::ActionType::ScanDependencies:
+    return Opts.RequestedAction;
+  default:
+    return FrontendOptions::ActionType::EmitModuleOnly;
+  }
+}
+
+ModuleInterfaceLoaderOptions::ModuleInterfaceLoaderOptions(
+    const FrontendOptions &Opts, bool inheritDebuggingOpts)
+    : requestedAction(reqestedModuleLoaderActionForFrontendOpts(Opts)),
+      remarkOnRebuildFromInterface(Opts.RemarkOnRebuildFromModuleInterface),
+      disableInterfaceLock(Opts.DisableInterfaceFileLock),
+      disableImplicitSwiftModule(Opts.DisableImplicitModules),
+      disableBuildingInterface(Opts.DisableBuildingInterface),
+      downgradeInterfaceVerificationError(
+          Opts.DowngradeInterfaceVerificationError),
+      strictImplicitModuleContext(Opts.StrictImplicitModuleContext),
+      mainExecutablePath(Opts.MainExecutablePath) {
+  if (inheritDebuggingOpts) {
+    compilerDebuggingOptions = Opts.CompilerDebuggingOpts;
+  }
+}
+
 bool ModuleInterfaceLoader::isCached(StringRef DepPath) {
   return InterfaceChecker.isCached(DepPath);
 }
@@ -1870,6 +1898,7 @@ InterfaceSubContextDelegateImpl::InterfaceSubContextDelegateImpl(
   SubFEOpts.RequestedAction = LoaderOpts.requestedAction;
   SubFEOpts.StrictImplicitModuleContext =
       LoaderOpts.strictImplicitModuleContext;
+  SubFEOpts.CompilerDebuggingOpts = LoaderOpts.compilerDebuggingOptions;
   if (!moduleCachePath.empty()) {
     genericSubInvocation.setClangModuleCachePath(moduleCachePath);
   }

lib/FrontendTool/FrontendTool.cpp

@@ -353,7 +353,8 @@ static bool buildModuleFromInterface(CompilerInstance &Instance) {
   assert(FEOpts.InputsAndOutputs.hasSingleInput());
   StringRef InputPath = FEOpts.InputsAndOutputs.getFilenameOfFirstInput();
   StringRef PrebuiltCachePath = FEOpts.PrebuiltModuleCachePath;
-  ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
+  ModuleInterfaceLoaderOptions LoaderOpts(FEOpts,
+                                          /*inheritDebuggingOpts=*/true);
   StringRef ABIPath = Instance.getPrimarySpecificPathsForAtMostOnePrimary()
                           .SupplementaryOutputs.ABIDescriptorOutputPath;
   bool IgnoreAdjacentModules = Instance.hasASTContext() &&
@@ -1021,25 +1022,16 @@ static void performEndOfPipelineActions(CompilerInstance &Instance) {
   const auto &Invocation = Instance.getInvocation();
   const auto &opts = Invocation.getFrontendOptions();
 
-  // If we were asked to print Clang stats, do so.
-  if (opts.PrintClangStats && ctx.getClangModuleLoader())
-    ctx.getClangModuleLoader()->printStatistics();
-
   // Report AST stats if needed.
   if (auto *stats = ctx.Stats)
     countASTStats(*stats, Instance);
 
-  if (opts.DumpClangLookupTables && ctx.getClangModuleLoader())
-    ctx.getClangModuleLoader()->dumpSwiftLookupTables();
-
-  if (opts.DumpAvailabilityScopes)
-    Instance.getPrimaryOrMainSourceFile().getAvailabilityScope()->dump(
-        llvm::errs(), Instance.getASTContext().SourceMgr);
-
   // Report mangling stats if there was no error.
   if (!ctx.hadError())
     Mangle::printManglingStats();
 
+  Instance.emitEndOfPipelineDebuggingOutput();
+
   // Make sure we didn't load a module during a parse-only invocation, unless
   // it's -emit-imported-modules, which can load modules.
   auto action = opts.RequestedAction;

test/ModuleInterface/availability-scopes.swift

@@ -0,0 +1,10 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-emit-module-interface(%t/Test.swiftinterface) %s -module-name Test
+// RUN: %target-swift-typecheck-module-from-interface(%t/Test.swiftinterface) -module-name Test -dump-availability-scopes 2>&1 | %FileCheck --strict-whitespace %s
+// RUN: %target-swift-frontend -compile-module-from-interface %t/Test.swiftinterface -o /dev/null -module-name Test -dump-availability-scopes 2>&1 | %FileCheck --strict-whitespace %s
+
+// CHECK: {{^}}(root {{.*}} file={{.*}}{{/|\\}}availability-scopes.swift.tmp{{/|\\}}Test.swiftinterface
+// CHECK: {{^}}  (decl {{.*}}unavailable=* decl=unavailable()
+@available(*, unavailable)
+public func unavailable() { }