[Frontend] Add support for implicit import of _Backtracing

Once the API has gone through Swift Evolution, we will want to implicitly
import the _Backtracing module.  Add code to do that, but set it to off
by default for now.

rdar://105394140

Author: al45tair

CMakeLists.txt

@@ -575,6 +575,10 @@ option(SWIFT_IMPLICIT_CONCURRENCY_IMPORT
   "Implicitly import the Swift concurrency module"
   TRUE)
 
+option(SWIFT_IMPLICIT_BACKTRACING_IMPORT
+  "Implicitly import the Swift backtracing module"
+  FALSE)
+
 option(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY
   "Enable build of the Swift concurrency module"
   FALSE)

cmake/modules/SwiftImplicitImport.cmake

@@ -0,0 +1,20 @@
+# Test if the Swift compiler supports -disable-implicit-<module>-module-import
+function(swift_supports_implicit_module module_name out_var)
+  file(WRITE "${CMAKE_BINARY_DIR}/tmp/empty-check-${module_name}.swift" "")
+  execute_process(
+    COMMAND
+      "${CMAKE_Swift_COMPILER}"
+      -Xfrontend -disable-implicit-${module_name}-module-import
+      -c - -o /dev/null
+    INPUT_FILE
+      "${CMAKE_BINARY_DIR}/tmp/empty-check-${module_name}.swift"
+    OUTPUT_QUIET ERROR_QUIET
+    RESULT_VARIABLE
+      result
+  )
+  if(NOT result)
+    set("${out_var}" "TRUE" PARENT_SCOPE)
+  else()
+    set("${out_var}" "FALSE" PARENT_SCOPE)
+  endif()
+endfunction()

include/swift/AST/DiagnosticsFrontend.def

@@ -172,6 +172,8 @@ WARNING(warn_implicit_concurrency_import_failed,none,
         "unable to perform implicit import of \"_Concurrency\" module: no such module found", ())
 REMARK(warn_implicit_string_processing_import_failed,none,
        "unable to perform implicit import of \"_StringProcessing\" module: no such module found", ())
+REMARK(warn_implicit_backtracing_import_failed,none,
+       "unable to perform implicit import of \"_Backtracing\" module: no such module found", ())
 
 ERROR(error_module_name_required,none, "-module-name is required", ())
 ERROR(error_bad_module_name,none,

include/swift/AST/KnownIdentifiers.def

@@ -263,6 +263,9 @@ IDENTIFIER(version)
 IDENTIFIER_(StringProcessing)
 IDENTIFIER(RegexBuilder)
 
+// Backtracing
+IDENTIFIER_(Backtracing)
+
 // Distributed actors
 IDENTIFIER(ActorID)
 IDENTIFIER(ActorSystem)

include/swift/Basic/LangOptions.h

@@ -352,6 +352,10 @@ namespace swift {
     /// Disable the implicit import of the _StringProcessing module.
     bool DisableImplicitStringProcessingModuleImport = false;
 
+    /// Disable the implicit import of the _Backtracing module.
+    bool DisableImplicitBacktracingModuleImport =
+        !SWIFT_IMPLICIT_BACKTRACING_IMPORT;
+
     /// Should we check the target OSs of serialized modules to see that they're
     /// new enough?
     bool EnableTargetOSChecking = true;

include/swift/Config.h.in

@@ -10,6 +10,8 @@
 
 #cmakedefine01 SWIFT_IMPLICIT_CONCURRENCY_IMPORT
 
+#cmakedefine01 SWIFT_IMPLICIT_BACKTRACING_IMPORT
+
 #cmakedefine01 SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
 
 #cmakedefine01 SWIFT_ENABLE_GLOBAL_ISEL_ARM64

include/swift/Frontend/Frontend.h

@@ -380,6 +380,10 @@ class CompilerInvocation {
   /// imported.
   bool shouldImportSwiftStringProcessing() const;
 
+  /// Whether the Swift Backtracing support library should be implicitly
+  /// imported.
+  bool shouldImportSwiftBacktracing() const;
+
   /// Performs input setup common to these tools:
   /// sil-opt, sil-func-extractor, sil-llvm-gen, and sil-nm.
   /// Return value includes the buffer so caller can keep it alive.
@@ -575,6 +579,14 @@ class CompilerInstance {
   /// i.e. if it can be found.
   bool canImportSwiftStringProcessing() const;
 
+  /// Verify that if an implicit import of the `Backtracing` module if
+  /// expected, it can actually be imported. Emit a warning, otherwise.
+  void verifyImplicitBacktracingImport();
+
+  /// Whether the Swift Backtracing support library can be imported
+  /// i.e. if it can be found.
+  bool canImportSwiftBacktracing() const;
+
   /// Whether the CxxShim library can be imported
   /// i.e. if it can be found.
   bool canImportCxxShim() const;

include/swift/Option/FrontendOptions.td

@@ -441,6 +441,14 @@ def disable_implicit_string_processing_module_import : Flag<["-"],
   "disable-implicit-string-processing-module-import">,
   HelpText<"Disable the implicit import of the _StringProcessing module.">;
 
+def enable_implicit_backtracing_module_import : Flag<["-"],
+  "enable-implicit-backtracing-module-import">,
+  HelpText<"Enable the implicit import of the _Backtracing module.">;
+
+def disable_implicit_backtracing_module_import : Flag<["-"],
+  "disable-implicit-backtracing-module-import">,
+  HelpText<"Disable the implicit import of the _Backtracing module.">;
+
 def disable_arc_opts : Flag<["-"], "disable-arc-opts">,
   HelpText<"Don't run SIL ARC optimization passes.">;
 def disable_ossa_opts : Flag<["-"], "disable-ossa-opts">,

include/swift/Strings.h

@@ -30,6 +30,8 @@ constexpr static const StringLiteral SWIFT_CONCURRENCY_SHIMS_NAME = "_SwiftConcu
 constexpr static const StringLiteral SWIFT_DISTRIBUTED_NAME = "Distributed";
 /// The name of the StringProcessing module, which supports that extension.
 constexpr static const StringLiteral SWIFT_STRING_PROCESSING_NAME = "_StringProcessing";
+/// The name of the Backtracing module, which supports that extension.
+constexpr static const StringLiteral SWIFT_BACKTRACING_NAME = "_Backtracing";
 /// The name of the SwiftShims module, which contains private stdlib decls.
 constexpr static const StringLiteral SWIFT_SHIMS_NAME = "SwiftShims";
 /// The name of the CxxShim module, which contains a cxx casting utility.

lib/AST/NameLookup.cpp

@@ -662,6 +662,22 @@ static void recordShadowedDeclsAfterTypeMatch(
         }
       }
 
+      // Next, prefer any other module over the _Backtracing module.
+      if (auto spModule = ctx.getLoadedModule(ctx.Id_Backtracing)) {
+        if ((firstModule == spModule) != (secondModule == spModule)) {
+          // If second module is _StringProcessing, then it is shadowed by
+          // first.
+          if (secondModule == spModule) {
+            shadowed.insert(secondDecl);
+            continue;
+          }
+
+          // Otherwise, the first declaration is shadowed by the second.
+          shadowed.insert(firstDecl);
+          break;
+        }
+      }
+
       // The Foundation overlay introduced Data.withUnsafeBytes, which is
       // treated as being ambiguous with SwiftNIO's Data.withUnsafeBytes
       // extension. Apply a special-case name shadowing rule to use the