diff --git a/.bazelversion b/.bazelversion
index d87edbfc..0c277e49 100644
--- a/.bazelversion
+++ b/.bazelversion
@@ -1 +1 @@
-4.2.1
\ No newline at end of file
+5.0.0rc3
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index d34a4502..b2788155 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,4 +23,4 @@ src/build/
 /bazel-*
 binary/
 binary/appcast.xml
-.build/
\ No newline at end of file
+.build/
diff --git a/BUILD b/BUILD
index 54e9dcd6..cb6433b2 100644
--- a/BUILD
+++ b/BUILD
@@ -69,6 +69,7 @@ macos_application(
     name = "tulsi",
     additional_contents = {
         "//src/tools/bazel_cache_reader": "MacOS",
+        "//src/tools/module_cache_pruner": "MacOS",
     },
     app_icons = ["//src/Tulsi:Icon"],
     bundle_id = "com.wendyliga.TulsiPlusPlus",
diff --git a/Tulsi.tulsiproj/project.tulsiconf b/Tulsi.tulsiproj/project.tulsiconf
index a3adbb82..ae2a88c5 100644
--- a/Tulsi.tulsiproj/project.tulsiconf
+++ b/Tulsi.tulsiproj/project.tulsiconf
@@ -7,6 +7,9 @@
       "GenerateRunfiles" : {
         "p" : "YES"
       },
+      "ProjectGenerationUseRealFilePath" : {
+        "p" : "NO"
+      },
       "TreeArtifactOutputs" : {
         "p" : "NO"
       }
diff --git a/WORKSPACE b/WORKSPACE
index 91a5be4a..50b5b97e 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -11,14 +11,16 @@ http_archive(
 # TODO: Remove with next rules_swift + rules_apple release
 http_archive(
     name = "build_bazel_rules_swift",
-    sha256 = "653e8756001616500b110fd156694de7899278bb7480aba22b2f156438a1d810",
-    url = "https://github.com/bazelbuild/rules_swift/releases/download/0.22.0/rules_swift.0.22.0.tar.gz",
+    sha256 = "fff70e28e9b28a4249fbfb413f860cb9b5df567fe20a1bc4017dd89e678dd9b5",
+    strip_prefix = "rules_swift-35ddf9f6e8c0fcd8bcb521e92dd4fd11c3f181b6",
+    url = "https://github.com/bazelbuild/rules_swift/archive/35ddf9f6e8c0fcd8bcb521e92dd4fd11c3f181b6.tar.gz",
 )
 
 http_archive(
     name = "build_bazel_rules_apple",
-    sha256 = "0052d452af7742c8f3a4e0929763388a66403de363775db7e90adecb2ba4944b",
-    url = "https://github.com/bazelbuild/rules_apple/releases/download/0.31.3/rules_apple.0.31.3.tar.gz",
+    sha256 = "2e6c88b66c671b4abb7cebc5d072804d6fc42bd18aa31586b060e2629aae7251",
+    strip_prefix = "rules_apple-0bba769a9aafe9bd3349b32a326e599553886e98",
+    url = "https://github.com/bazelbuild/rules_apple/archive/0bba769a9aafe9bd3349b32a326e599553886e98.tar.gz",
 )
 
 load(
diff --git a/src/Tulsi/Base.lproj/BazelOpenSheetAccessoryView.xib b/src/Tulsi/Base.lproj/BazelOpenSheetAccessoryView.xib
index e61d02e2..d3687424 100644
--- a/src/Tulsi/Base.lproj/BazelOpenSheetAccessoryView.xib
+++ b/src/Tulsi/Base.lproj/BazelOpenSheetAccessoryView.xib
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="14313.18" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="19162" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
     <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="14313.18"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="19162"/>
         <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
     </dependencies>
     <objects>
@@ -17,7 +17,7 @@
             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
             <subviews>
                 <button fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="atU-NU-IiP">
-                    <rect key="frame" x="18" y="19" width="241" height="18"/>
+                    <rect key="frame" x="15" y="18" width="245" height="18"/>
                     <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
                     <buttonCell key="cell" type="check" title="Use as the default for other projects" bezelStyle="regularSquare" imagePosition="left" state="on" inset="2" id="ZsK-jX-81p">
                         <behavior key="behavior" changeContents="YES" doesNotDimImage="YES" lightByContents="YES"/>
diff --git a/src/Tulsi/MessageViewController.swift b/src/Tulsi/MessageViewController.swift
index 787d2d85..e5035ef1 100644
--- a/src/Tulsi/MessageViewController.swift
+++ b/src/Tulsi/MessageViewController.swift
@@ -52,7 +52,7 @@ final class MessageViewController: NSViewController, NSTableViewDelegate, NSUser
     ValueTransformer.setValueTransformer(MessageTypeToImageValueTransformer(),
                                            forName: NSValueTransformerName(rawValue: "MessageTypeToImageValueTransformer"))
     super.loadView()
-    bind(NSBindingName(rawValue: "messageCount"), to: messageArrayController, withKeyPath: "arrangedObjects.@count", options: nil)
+    bind(NSBindingName(rawValue: "messageCount"), to: messageArrayController!, withKeyPath: "arrangedObjects.@count", options: nil)
   }
 
   @IBAction func copy(_ sender: AnyObject?) {
diff --git a/src/Tulsi/ProjectEditorConfigManagerViewController.swift b/src/Tulsi/ProjectEditorConfigManagerViewController.swift
index 857db26d..9e3259be 100644
--- a/src/Tulsi/ProjectEditorConfigManagerViewController.swift
+++ b/src/Tulsi/ProjectEditorConfigManagerViewController.swift
@@ -113,7 +113,7 @@ final class ProjectEditorConfigManagerViewController: NSViewController {
                                            forName: NSValueTransformerName(rawValue: "IsOneValueTransformer"))
     super.loadView()
     bind(NSBindingName(rawValue: "numSelectedConfigs"),
-         to: configArrayController,
+         to: configArrayController!,
          withKeyPath: "selectedObjects.@count",
          options: nil)
     self.generateButton.keyEquivalent = "\r"
diff --git a/src/Tulsi/ProjectEditorPackageManagerViewController.swift b/src/Tulsi/ProjectEditorPackageManagerViewController.swift
index cbc209b8..5d7991be 100644
--- a/src/Tulsi/ProjectEditorPackageManagerViewController.swift
+++ b/src/Tulsi/ProjectEditorPackageManagerViewController.swift
@@ -48,7 +48,7 @@ final class ProjectEditorPackageManagerViewController: NSViewController, NewProj
                                            forName: NSValueTransformerName(rawValue: "PackagePathValueTransformer"))
     super.loadView()
     bind(NSBindingName(rawValue: "numSelectedPackagePaths"),
-         to: packageArrayController,
+         to: packageArrayController!,
          withKeyPath: "selectedObjects.@count",
          options: nil)
   }
diff --git a/src/TulsiGenerator/Bazel/tulsi/tulsi_aspects.bzl b/src/TulsiGenerator/Bazel/tulsi/tulsi_aspects.bzl
index e0538ea2..8ce110ec 100644
--- a/src/TulsiGenerator/Bazel/tulsi/tulsi_aspects.bzl
+++ b/src/TulsiGenerator/Bazel/tulsi/tulsi_aspects.bzl
@@ -149,7 +149,9 @@ Filtering information for this target. Only for test target, otherwise is None.
 )
 
 TulsiOutputAspectInfo = provider(
+    doc = """Provides information about an Apple target's outputs.""",
     fields = {
+        "transitive_explicit_modules": "Depset of all explicit modules built by this target.",
         "transitive_generated_files": "Depset of tulsi generated files.",
         "transitive_embedded_bundles": "Depset of all bundles embedded into this target.",
     },
@@ -649,13 +651,31 @@ def _collect_swift_modules(target):
         if module.swift
     ]
 
-def _collect_module_maps(target):
-    """Returns a list of Clang module maps found on the given target."""
-    return [
-        module.clang.module_map
-        for module in target[SwiftInfo].transitive_modules.to_list()
-        if module.clang and type(module.clang.module_map) == "File"
-    ]
+def _collect_clang_modules(target):
+    """Returns a struct with lists of Clang pcms and module maps found on the given target."""
+    if not _is_swift_target(target):
+        return struct(module_maps = [], precompiled_modules = [])
+
+    module_maps = []
+    precompiled_modules = []
+
+    for module in target[SwiftInfo].transitive_modules.to_list():
+        if module.clang == None:
+            continue
+
+        # Collect precompiled modules
+        if module.clang.precompiled_module:
+            precompiled_module = struct(
+                module = module.clang.precompiled_module,
+                name = module.name,
+            )
+            precompiled_modules.append(precompiled_module)
+
+        # Collect module maps
+        if type(module.clang.module_map) == "File":
+            module_maps.append(module.clang.module_map)
+
+    return struct(module_maps = module_maps, precompiled_modules = precompiled_modules)
 
 def _collect_objc_strict_includes(target, rule_attr):
     """Returns a depset of strict includes found on the deps of given target."""
@@ -753,8 +773,9 @@ def _tulsi_sources_aspect(target, ctx):
     is_swift_target = _is_swift_target(target)
 
     if is_swift_target:
+        clang_modules = _collect_clang_modules(target)
         swift_transitive_modules = depset([_file_metadata(f) for f in _collect_swift_modules(target)])
-        objc_module_maps = depset([_file_metadata(f) for f in _collect_module_maps(target)])
+        objc_module_maps = depset([_file_metadata(f) for f in clang_modules.module_maps])
     else:
         swift_transitive_modules = depset()
         objc_module_maps = depset()
@@ -1092,12 +1113,16 @@ def _tulsi_outputs_aspect(target, ctx):
     # A list of bundle infos corresponding to the dependencies of this target.
     direct_embedded_bundles = []
 
+    # A list of all explicit modules that have been built from this targets dependencies.
+    transitive_explicit_modules = []
+
     for attr_name in _TULSI_COMPILE_DEPS:
         deps = _collect_dependencies(rule_attr, attr_name)
         for dep in deps:
             if TulsiOutputAspectInfo in dep:
                 transitive_generated_files.append(dep[TulsiOutputAspectInfo].transitive_generated_files)
                 transitive_embedded_bundles.append(dep[TulsiOutputAspectInfo].transitive_embedded_bundles)
+                transitive_explicit_modules.append(dep[TulsiOutputAspectInfo].transitive_explicit_modules)
 
             # Retrieve the bundle info for embeddable attributes.
             if attr_name not in _TULSI_NON_EMBEDDEDABLE_ATTRS:
@@ -1162,10 +1187,11 @@ def _tulsi_outputs_aspect(target, ctx):
         if cc_info:
             all_files_depsets.append(cc_info.compilation_context.headers)
 
+    clang_modules = _collect_clang_modules(target)
     if _is_swift_target(target):
         all_files_depsets.append(_collect_swift_header(target))
         all_files_depsets.append(depset(_collect_swift_modules(target)))
-        all_files_depsets.append(depset(_collect_module_maps(target)))
+        all_files_depsets.append(depset(clang_modules.module_maps))
 
     source_files = [
         x
@@ -1187,6 +1213,11 @@ def _tulsi_outputs_aspect(target, ctx):
         transitive = transitive_generated_files,
     )
 
+    explicit_modules = depset([
+        struct(name = m.name, path = m.module.path)
+        for m in clang_modules.precompiled_modules
+    ], transitive = transitive_explicit_modules)
+
     has_dsym = _has_dsym(target)
 
     info = _struct_omitting_none(
@@ -1197,6 +1228,7 @@ def _tulsi_outputs_aspect(target, ctx):
         bundle_name = bundle_name,
         embedded_bundles = embedded_bundles.to_list(),
         has_dsym = has_dsym,
+        explicit_modules = explicit_modules.to_list(),
     )
 
     output = ctx.actions.declare_file(target.label.name + ".tulsiouts")
@@ -1205,6 +1237,7 @@ def _tulsi_outputs_aspect(target, ctx):
     return [
         OutputGroupInfo(tulsi_outputs = [output]),
         TulsiOutputAspectInfo(
+            transitive_explicit_modules = explicit_modules,
             transitive_generated_files = generated_files,
             transitive_embedded_bundles = embedded_bundles,
         ),
@@ -1222,7 +1255,6 @@ tulsi_sources_aspect = aspect(
         )),
     },
     toolchains = ["@bazel_tools//tools/cpp:toolchain_type"],
-    incompatible_use_toolchain_transition = True,
     fragments = [
         "apple",
         "cpp",
diff --git a/src/TulsiGenerator/BazelAspectInfoExtractor.swift b/src/TulsiGenerator/BazelAspectInfoExtractor.swift
index 6db19b8d..752ba5b8 100644
--- a/src/TulsiGenerator/BazelAspectInfoExtractor.swift
+++ b/src/TulsiGenerator/BazelAspectInfoExtractor.swift
@@ -231,12 +231,16 @@ final class BazelAspectInfoExtractor: QueuedLogging {
         "--features=-parse_headers",
         // Don't run validation actions during project generation; validation actions could
         // slow down the project generation or fail it.
-        "--experimental_run_validations=0",
+        // TODO: Switch to --norun_validations when we no longer need to support Bazel 4.
+        "--noexperimental_run_validations",
         // The following flags WILL affect Bazel analysis caching.
         // Keep this consistent with bazel_build.py.
         "--aspects",
         "@tulsi//:tulsi/tulsi_aspects.bzl%\(aspect)",
-        "--output_groups=tulsi_info,-_,-default",  // Build only the aspect artifacts.
+        // Build only the aspect artifacts. We explicitly disable the
+        // rules_apple `dsyms` output group since it may trigger a full build
+        // and we've seen some folks enabling it in their rc file.
+        "--output_groups=tulsi_info,-dsyms",
     ])
     arguments.append(contentsOf: targets)
 
diff --git a/src/TulsiGenerator/BazelQueryInfoExtractor.swift b/src/TulsiGenerator/BazelQueryInfoExtractor.swift
index 6ae40335..0efb2080 100644
--- a/src/TulsiGenerator/BazelQueryInfoExtractor.swift
+++ b/src/TulsiGenerator/BazelQueryInfoExtractor.swift
@@ -81,9 +81,8 @@ final class BazelQueryInfoExtractor: QueuedLogging {
     let profilingStart = localizedMessageLogger.startProfiling("extracting_skylark_files",
                                                                message: "Finding Skylark files for \(targets.count) rules")
 
-    let labelDeps = targets.map {"deps(\($0.value))"}
-    let joinedLabelDeps = labelDeps.joined(separator: "+")
-    let query = "buildfiles(\(joinedLabelDeps))"
+    let joinedLabels = targets.map { $0.value }.joined(separator: " + ")
+    let query = "buildfiles(deps(\(joinedLabels)))"
     let buildFiles: Set<BuildLabel>
     do {
       // Errors in the BUILD structure being examined should not prevent partial extraction, so this
diff --git a/src/TulsiGenerator/PBXObjects.swift b/src/TulsiGenerator/PBXObjects.swift
index 3a21885a..e9001b54 100644
--- a/src/TulsiGenerator/PBXObjects.swift
+++ b/src/TulsiGenerator/PBXObjects.swift
@@ -147,7 +147,7 @@ class PBXReference: PBXObjectProtocol {
   fileprivate weak var _parent: PBXReference?
 
   init(name: String, path: String?, sourceTree: SourceTree, parent: PBXReference? = nil) {
-    self.name = name;
+    self.name = name
     self.path = path
     self.sourceTree = sourceTree
     self._parent = parent
@@ -1330,8 +1330,8 @@ final class PBXProject: PBXObjectProtocol {
     try serializer.addField("attributes", attributes)
     try serializer.addField("buildConfigurationList", buildConfigurationList)
     try serializer.addField("compatibilityVersion", compatibilityVersion)
-    try serializer.addField("mainGroup", mainGroup);
-    try serializer.addField("targets", targetByName.values.sorted(by: {$0.name < $1.name}));
+    try serializer.addField("mainGroup", mainGroup)
+    try serializer.addField("targets", targetByName.values.sorted(by: {$0.name < $1.name}))
 
     // Hardcoded defaults to match Xcode behavior.
     try serializer.addField("developmentRegion", "English")
diff --git a/src/TulsiGenerator/RuleEntryMap.swift b/src/TulsiGenerator/RuleEntryMap.swift
index c91e01d5..2790bf56 100644
--- a/src/TulsiGenerator/RuleEntryMap.swift
+++ b/src/TulsiGenerator/RuleEntryMap.swift
@@ -23,6 +23,7 @@ import Foundation
 public class RuleEntryMap {
   private var labelToEntries = [BuildLabel: [RuleEntry]]()
   private var allEntries = [RuleEntry]()
+  private var labelsWithWarning = Set<BuildLabel>()
 
   private let localizedMessageLogger: LocalizedMessageLogger?
 
@@ -97,10 +98,13 @@ public class RuleEntryMap {
       }
     }
 
-    // Must be multiple. Shoot out a warning and return the last.
-    localizedMessageLogger?.warning("AmbiguousRuleEntryReference",
-                                    comment: "Warning when unable to resolve a RuleEntry for a given DeploymentTarget. RuleEntry's label is in %1$@.",
-                                    values: buildLabel.description)
+    if labelsWithWarning.insert(buildLabel).inserted {
+      // Must be multiple. Shoot out a warning and return the last.
+      localizedMessageLogger?.warning("AmbiguousRuleEntryReference",
+                                      comment: "Warning when unable to resolve a RuleEntry for a given DeploymentTarget. RuleEntry's label is in %1$@.",
+                                      values: buildLabel.description)
+    }
+
     return ruleEntries.last
   }
 }
diff --git a/src/TulsiGenerator/Scripts/bazel_build.py b/src/TulsiGenerator/Scripts/bazel_build.py
index ce2d08fa..61435053 100755
--- a/src/TulsiGenerator/Scripts/bazel_build.py
+++ b/src/TulsiGenerator/Scripts/bazel_build.py
@@ -54,6 +54,9 @@
     'IDEBundleInjection.framework',
     'XCTAutomationSupport.framework',
     'XCTest.framework',
+    'XCTestCore.framework',
+    'XCUnit.framework',
+    'XCUIAutomation.framework',
 ]
 
 _logger = None
@@ -427,6 +430,11 @@ class BazelBuildBridge(object):
 
   BUILD_EVENTS_FILE = 'build_events.json'
 
+  XCODE_MODULE_CACHE_DIRECTORY = os.path.expanduser(
+      '~/Library/Developer/Xcode/DerivedData/ModuleCache.noindex')
+  MODULE_CACHE_PRUNER_EXECUTABLE = os.path.expanduser(
+      '~/Library/Application Support/Tulsi/Scripts/module_cache_pruner')
+
   def __init__(self, build_settings):
     self.build_settings = build_settings
     self.verbose = 0
@@ -454,7 +462,9 @@ def __init__(self, build_settings):
     self.direct_debug_prefix_map = False
     self.normalized_prefix_map = False
 
-    self.update_symbol_cache = UpdateSymbolCache()
+    self.update_symbol_cache = None
+    if os.environ.get('TULSI_USE_BAZEL_CACHE_READER') is not None:
+      self.update_symbol_cache = UpdateSymbolCache()
 
     # Path into which generated artifacts should be copied.
     self.built_products_dir = os.environ['BUILT_PRODUCTS_DIR']
@@ -619,6 +629,7 @@ def Run(self, args):
       return exit_code
 
 
+
     exit_code, outputs_data = self._ExtractAspectOutputsData(outputs)
     if exit_code:
       return exit_code
@@ -670,6 +681,8 @@ def Run(self, args):
       if exit_code:
         return exit_code
 
+    self._PruneLLDBModuleCache(outputs)
+
     # Starting with Xcode 8, .lldbinit files are honored during Xcode debugging
     # sessions. This allows use of the target.source-map field to remap the
     # debug symbol paths encoded in the binary to the paths expected by Xcode.
@@ -1489,6 +1502,24 @@ def _ExtractSigningAttribute(self, signed_bundle, attribute):
     self.codesign_attributes[signed_bundle] = bundle_attributes
     return bundle_attributes.Get(attribute)
 
+  def _PruneLLDBModuleCache(self, output_files):
+    """Run the module cache pruner tool as a subprocess."""
+    if not os.path.exists(BazelBuildBridge.MODULE_CACHE_PRUNER_EXECUTABLE):
+      _PrintXcodeWarning(
+          'Could find module cache pruner executable at %s. '
+          'You may need to manually remove %s if lldb-rpc-server crashes.' %
+          (BazelBuildBridge.MODULE_CACHE_PRUNER_EXECUTABLE,
+           BazelBuildBridge.XCODE_MODULE_CACHE_DIRECTORY))
+      return
+
+    timer = Timer('Pruning module cache', 'prune_module_cache').Start()
+    for output_file in output_files:
+      self._RunSubprocess([
+          BazelBuildBridge.MODULE_CACHE_PRUNER_EXECUTABLE,
+          BazelBuildBridge.XCODE_MODULE_CACHE_DIRECTORY, output_file
+      ])
+    timer.End()
+
   def _UpdateLLDBInit(self, clear_source_map=False):
     """Updates lldbinit to enable debugging of Bazel binaries."""
 
@@ -1531,6 +1562,13 @@ def _UpdateLLDBInit(self, clear_source_map=False):
                 'root used by %r.\n' % project_basename)
       out.write('platform settings -w "%s"\n' % workspace_root)
 
+      out.write('# This enables implicitly loading Clang modules which can be '
+                'disabled when a Swift module was built with explicit modules '
+                'enabled.\n')
+      out.write(
+          'settings set -- target.swift-extra-clang-flags "-fimplicit-module-maps"\n'
+      )
+
       if clear_source_map:
         out.write('settings clear target.source-map\n')
         return 0
@@ -1678,13 +1716,14 @@ def _CreateUUIDPlist(self, dsym_bundle_path, uuid, arch, source_maps):
       return False
 
     # Update the dSYM symbol cache with a reference to this dSYM bundle.
-    err_msg = self.update_symbol_cache.UpdateUUID(uuid,
-                                                  dsym_bundle_path,
-                                                  arch)
-    if err_msg:
-      _PrintXcodeWarning('Attempted to save (uuid, dsym_bundle_path, arch) '
-                         'to DBGShellCommands\' dSYM cache, but got error '
-                         '\"%s\".' % err_msg)
+    if self.update_symbol_cache is not None:
+      err_msg = self.update_symbol_cache.UpdateUUID(uuid,
+                                                    dsym_bundle_path,
+                                                    arch)
+      if err_msg:
+        _PrintXcodeWarning('Attempted to save (uuid, dsym_bundle_path, arch) '
+                           'to DBGShellCommands\' dSYM cache, but got error '
+                           '\"%s\".' % err_msg)
 
     return True
 
diff --git a/src/TulsiGenerator/TulsiOption.swift b/src/TulsiGenerator/TulsiOption.swift
index ee04442e..cc4dea56 100644
--- a/src/TulsiGenerator/TulsiOption.swift
+++ b/src/TulsiGenerator/TulsiOption.swift
@@ -51,7 +51,7 @@ public class TulsiOption: Equatable, CustomStringConvertible {
     }
 
     /// An option that is handled in Tulsi's code.
-    static let Generic = OptionType(rawValue: 0)
+    static let Generic = OptionType([])
 
     /// An option that may be automatically encoded into a build setting.
     static let BuildSetting = OptionType(rawValue: 1 << 0)
diff --git a/src/TulsiGenerator/TulsiOptionSet.swift b/src/TulsiGenerator/TulsiOptionSet.swift
index 4beedf98..716ce495 100644
--- a/src/TulsiGenerator/TulsiOptionSet.swift
+++ b/src/TulsiGenerator/TulsiOptionSet.swift
@@ -90,6 +90,9 @@ public enum TulsiOptionKey: String {
       // i386.
       Use64BitWatchSimulator,
 
+      // Target the legacy build system instead of the new build system.
+      UseLegacyBuildSystem,
+
       // Option to fallback to using a global lldbinit.
       DisableCustomLLDBInit,
 
@@ -98,9 +101,9 @@ public enum TulsiOptionKey: String {
 
       // Custom build phase run script that runs after bazel build.
       PostBuildPhaseRunScript,
-      
-      // option to fallback to xcode legacy build system
-      UseLegacyBuildSystem
+
+      // Option to use a fallback approach to finding dSYMs.
+      UseBazelCacheReader
 
   // Options for build invocations.
   case BazelBuildOptionsDebug,
@@ -284,6 +287,13 @@ public class TulsiOptionSet: Equatable {
     return buildSettings
   }
 
+  // MARK: - Public Getters
+
+  /// Whether the legacy build system should be used instead of the new build system.
+  var useLegacyBuildSystem: Bool {
+    return self[.UseLegacyBuildSystem].commonValueAsBool ?? true
+  }
+
   // MARK: - Private methods.
 
   private func saveToDictionary(_ filter: (TulsiOptionKey, TulsiOption) -> Bool) -> PersistenceType {
@@ -352,6 +362,8 @@ public class TulsiOptionSet: Equatable {
     addBoolOption(.Use64BitWatchSimulator, .Generic, false)
     addBoolOption(.DisableCustomLLDBInit, .Generic, false)
     addBoolOption(.UseLegacyBuildSystem, .Generic, false)
+    addBoolOption(.UseBazelCacheReader, .Generic, false)
+    addBoolOption(.UseLegacyBuildSystem, .Generic, true)
 
     let defaultIdentifier = PlatformConfiguration.defaultConfiguration.identifier
     let platformCPUIdentifiers = PlatformConfiguration.allValidConfigurations.map { $0.identifier }
diff --git a/src/TulsiGenerator/XcodeProjectGenerator.swift b/src/TulsiGenerator/XcodeProjectGenerator.swift
index 2a1ef1cc..340b9ddc 100644
--- a/src/TulsiGenerator/XcodeProjectGenerator.swift
+++ b/src/TulsiGenerator/XcodeProjectGenerator.swift
@@ -70,6 +70,7 @@ final class XcodeProjectGenerator {
   private static let SettingsScript = "bazel_build_settings.py"
   private static let CleanScript = "bazel_clean.sh"
   private static let ShellCommandsUtil = "bazel_cache_reader"
+  private static let ModuleCachePrunerUtil = "module_cache_pruner"
   private static let ShellCommandsCleanScript = "clean_symbol_cache"
   private static let LLDBInitBootstrapScript = "bootstrap_lldbinit"
   private static let CustomLLDBInit = "lldbinit"
@@ -113,6 +114,9 @@ final class XcodeProjectGenerator {
   /// Exposed for testing. Do not attempt to update/install files related to DBGShellCommands.
   var suppressUpdatingShellCommands = false
 
+  /// Exposed for testing. Do not install the module cache pruning tool.
+  var suppressModuleCachePrunerInstallation = false
+
   /// Exposed for testing. Do not modify user defaults.
   var suppressModifyingUserDefaults = false
 
@@ -335,6 +339,10 @@ final class XcodeProjectGenerator {
 
     /// Mapping from label to top-level build target.
     let topLevelBuildTargetsByLabel: [BuildLabel: PBXNativeTarget]
+
+    /// Test targets from `test_suite` rules which were silently dropped since
+    /// their rule kind is unsupported.
+    let ignoredTestTargets: Set<BuildLabel>
   }
 
   /// Throws an exception if the Xcode project path is found to be in a forbidden location,
@@ -443,15 +451,23 @@ final class XcodeProjectGenerator {
     let ruleEntryMap = try loadRuleEntryMap()
     try validateConfigReferences(ruleEntryMap)
 
+    // Expand test_suites recursively into their respective tests, ignoring
+    // unsupported target types.
+    var ignoredTests = Set<BuildLabel>()
     var expandedTargetLabels = Set<BuildLabel>()
     var testSuiteRules = [BuildLabel: RuleEntry]()
-    func expandTargetLabels<T: Sequence>(_ labels: T) where T.Iterator.Element == BuildLabel {
+    func expandTargetLabels<T: Sequence>(_ labels: T, inTestSuite: Bool) where T.Iterator.Element == BuildLabel {
       for label in labels {
         // Effectively we will only be using the last RuleEntry in the case of duplicates.
         // We could log about duplicates here, but this would only lead to duplicate logging.
         let ruleEntries = ruleEntryMap.ruleEntries(buildLabel: label)
         for ruleEntry in ruleEntries {
           if ruleEntry.type != "test_suite" {
+            // Ignore unsupported target types in `test_suite`s.
+            guard !inTestSuite || ruleEntry.pbxTargetType != nil else {
+              ignoredTests.insert(label)
+              continue
+            }
             // Add the RuleEntry itself and any registered extensions + app clips so they are
             // automatically added as buildable schemes in the project.
             expandedTargetLabels.insert(label)
@@ -459,16 +475,16 @@ final class XcodeProjectGenerator {
             expandedTargetLabels.formUnion(ruleEntry.appClips)
 
             // Recursively expand extensions. Currently used by App -> Watch App -> Watch Extension.
-            expandTargetLabels(ruleEntry.extensions)
+            expandTargetLabels(ruleEntry.extensions, inTestSuite: false)
           } else {
             // Expand the test_suite to its set of tests.
             testSuiteRules[ruleEntry.label] = ruleEntry
-            expandTargetLabels(ruleEntry.testSuiteDependencies)
+            expandTargetLabels(ruleEntry.testSuiteDependencies, inTestSuite: true)
           }
         }
       }
     }
-    expandTargetLabels(config.buildTargetLabels)
+    expandTargetLabels(config.buildTargetLabels, inTestSuite: false)
 
     var targetRules = Set<RuleEntry>()
     var hostTargetLabels = [BuildLabel: BuildLabel]()
@@ -547,6 +563,7 @@ final class XcodeProjectGenerator {
       generator.generateBazelCleanTarget(cleanScriptPath, workingDirectory: workingDirectory,
                                          startupOptions: startupOptions)
     }
+    let useBazelCacheReader = config.options[.UseBazelCacheReader].commonValueAsBool == true
     profileAction("generating_top_level_build_configs") {
       var buildSettings = [String: String]()
       if let sdkroot = XcodeProjectGenerator.projectSDKROOT(targetRules) {
@@ -573,6 +590,10 @@ final class XcodeProjectGenerator {
         buildSettings["TULSI_LLDBINIT_FILE"] = customLLDBInitFile
       }
 
+      if useBazelCacheReader {
+        buildSettings["TULSI_USE_BAZEL_CACHE_READER"] = "YES"
+      }
+
       buildSettings["TULSI_PROJECT"] = config.projectName
       generator.generateTopLevelBuildConfigurations(buildSettings)
     }
@@ -594,7 +615,7 @@ final class XcodeProjectGenerator {
     }
     profileAction("updating_dbgshellcommands") {
       do {
-        try updateShellCommands()
+        try updateShellCommands(useBazelCacheReader: useBazelCacheReader)
       } catch {
         self.localizedMessageLogger.warning("UpdatingDBGShellCommandsFailed",
                                             comment: LocalizedMessageLogger.bugWorthyComment("Failed to update the script to find cached dSYM bundles via DBGShellCommands."),
@@ -611,11 +632,24 @@ final class XcodeProjectGenerator {
         bootstrapLLDBInit()
       }
     }
+
+    if !suppressModuleCachePrunerInstallation {
+      do {
+        _ = try installAuxiliaryExecutable(XcodeProjectGenerator.ModuleCachePrunerUtil)
+      } catch {
+        self.localizedMessageLogger.warning("InstallModuleCachePrunerFailed",
+                                            comment: LocalizedMessageLogger.bugWorthyComment("Failed to install the module cache pruner executable."),
+                                            context: self.config.projectName,
+                                            values: "\(error)")
+      }
+    }
+
     return GeneratedProjectInfo(project: xcodeProject,
                                 buildRuleEntries: targetRules,
                                 testSuiteRuleEntries: testSuiteRules,
                                 indexerTargets: indexerTargets,
-                                topLevelBuildTargetsByLabel: targetsByLabel)
+                                topLevelBuildTargetsByLabel: targetsByLabel,
+                                ignoredTestTargets: ignoredTests)
   }
 
   private func installWorkspaceSettings(_ projectURL: URL) throws {
@@ -639,14 +673,13 @@ final class XcodeProjectGenerator {
     var sharedWorkspaceSettings: [String: Any] = [
       "IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded": false as AnyObject,
     ]
-    
-    let useLegacyBuildSystem: Bool = config.options[.UseLegacyBuildSystem].commonValueAsBool ?? false
-    if useLegacyBuildSystem {
+    if config.options.useLegacyBuildSystem {
       sharedWorkspaceSettings["BuildSystemType"] = "Original"
+      // Disable legacy build system warning in Xcode 12.
       sharedWorkspaceSettings["DisableBuildSystemDeprecationWarning"] = true as AnyObject
+      // Disable legacy build system error in Xcode 13.
       sharedWorkspaceSettings["DisableBuildSystemDeprecationDiagnostic"] = true as AnyObject
     }
-    
     try writeWorkspaceSettings(sharedWorkspaceSettings,
                                toDirectoryAtURL: workspaceSharedDataURL,
                                replaceIfExists: true)
@@ -931,6 +964,11 @@ final class XcodeProjectGenerator {
       var suiteHostTarget: PBXTarget? = nil
       var validTests = Set<PBXTarget>()
       for testEntryLabel in testSuite.testSuiteDependencies {
+        // Skip over tests which were dropped since they were unsupported.
+        guard !info.ignoredTestTargets.contains(testEntryLabel) else {
+          continue
+        }
+
         if let recursiveTestSuite = info.testSuiteRuleEntries[testEntryLabel] {
           let (recursiveTests, recursiveSuiteHostTarget) = extractTestTargets(recursiveTestSuite)
           validTests.formUnion(recursiveTests)
@@ -1123,8 +1161,11 @@ final class XcodeProjectGenerator {
     }
   }
 
-  /// Copy the bazel_cache_reader to a subfolder in the user's Library, return the absolute path.
-  private func installShellCommands(atURL supportScriptsAbsoluteURL: URL) throws -> String {
+  /// Copy an auxiliary executable to a subfolder in the user's Library, return the absolute path.
+  private func installAuxiliaryExecutable(_ auxiliaryExecutable: String) throws -> String {
+    // Construct a URL to ~/Library/Application Support/Tulsi/Scripts.
+    let supportScriptsAbsoluteURL = fileManager.homeDirectoryForCurrentUser.appendingPathComponent(
+      XcodeProjectGenerator.SupportScriptsPath, isDirectory: true)
 
     // Create all intermediate directories if they aren't present.
     var isDir = ObjCBool(false)
@@ -1134,20 +1175,48 @@ final class XcodeProjectGenerator {
                                       attributes: nil)
     }
 
-    // Find bazel_cache_reader in Tulsi.app's Utilities folder.
+    // Find the executable in Tulsi.app's Utilities folder.
     let bundle = Bundle(for: type(of: self))
-    let symbolCacheSourceURL = bundle.url(forAuxiliaryExecutable: XcodeProjectGenerator.ShellCommandsUtil)!
+    let sourceURL = bundle.url(forAuxiliaryExecutable: auxiliaryExecutable)!
 
-    // Copy bazel_cache_reader to ~/Library/Application Support/Tulsi/Scripts
-    installFiles([(symbolCacheSourceURL, XcodeProjectGenerator.ShellCommandsUtil)],
-                 toDirectory: supportScriptsAbsoluteURL)
+    // Copy the executable to ~/Library/Application Support/Tulsi/Scripts
+    installFiles([(sourceURL, auxiliaryExecutable)], toDirectory: supportScriptsAbsoluteURL)
 
-    // Return the absolute path to ~/Library/Application Support/Tulsi/Scripts/bazel_cache_reader.
-    let shellCommandsURL =
-        supportScriptsAbsoluteURL.appendingPathComponent(XcodeProjectGenerator.ShellCommandsUtil,
+    // Return the absolute path to the installed executable.
+    let auxiliaryBinaryURL =
+        supportScriptsAbsoluteURL.appendingPathComponent(auxiliaryExecutable,
                                                          isDirectory: false)
 
-    return shellCommandsURL.path
+    return auxiliaryBinaryURL.path
+  }
+
+  /// Update the global user defaults to remove any reference to bazel_cache_reader
+  private func removeShellCommandsFromGlobalUserDefaults(shellCommandsBasename: String) {
+    // Find if there is an existing entry for com.apple.DebugSymbols.
+    let dbgDefaults = UserDefaults.standard.persistentDomain(forName: "com.apple.DebugSymbols")
+
+    guard var currentDBGDefaults = dbgDefaults else {
+      // No com.apple.DebugSymbols exists, nothing to remove.
+      return
+    }
+
+    var newShellCommands : [String] = []
+
+    if let currentShellCommands = currentDBGDefaults["DBGShellCommands"] as? [String] {
+      // Copy all the current shell commands to the new DBGShellCommands array excluding the
+      // bazel_cache_reader command.
+      newShellCommands = currentShellCommands.filter { !$0.contains(shellCommandsBasename) }
+    } else if let currentShellCommand = currentDBGDefaults["DBGShellCommands"] as? String {
+      // Check that the single path at DBGShellCommands contains the shellCommandsBasename.
+      guard currentShellCommand.contains(shellCommandsBasename) else {
+        // Otherwise there is no need to remove anything.
+        return
+      }
+    }
+
+    // Replace DBGShellCommands in the existing com.apple.DebugSymbols defaults.
+    currentDBGDefaults["DBGShellCommands"] = newShellCommands.isEmpty ? nil : newShellCommands
+    UserDefaults.standard.setPersistentDomain(currentDBGDefaults, forName: "com.apple.DebugSymbols")
   }
 
   /// Update the global user defaults to reference bazel_cache_reader
@@ -1200,19 +1269,19 @@ final class XcodeProjectGenerator {
     UserDefaults.standard.setPersistentDomain(currentDBGDefaults, forName: "com.apple.DebugSymbols")
   }
 
-  /// Install the latest bazel_cache_reader.
-  private func updateShellCommands() throws {
+  /// Install or remove bazel_cache_reader.
+  private func updateShellCommands(useBazelCacheReader: Bool) throws {
     guard !suppressUpdatingShellCommands else { return }
 
-    // Construct a URL to ~/Library/Application Support/Tulsi/Scripts.
-    let supportScriptsAbsoluteURL = fileManager.homeDirectoryForCurrentUser.appendingPathComponent(
-      XcodeProjectGenerator.SupportScriptsPath, isDirectory: true)
+    if useBazelCacheReader {
+      // Install the latest version of the app to ~/Library/Application Support/Tulsi/Scripts/.
+      let shellCommandsAppPath = try installAuxiliaryExecutable(XcodeProjectGenerator.ShellCommandsUtil)
 
-    // Install the latest version of the app to ~/Library/Application Support/Tulsi/Scripts/.
-    let shellCommandsAppPath = try installShellCommands(atURL: supportScriptsAbsoluteURL)
-
-    // Add a reference to it in global user defaults.
-    updateGlobalUserDefaultsWithShellCommands(shellCommandsPath: shellCommandsAppPath)
+      // Add a reference to it in global user defaults.
+      updateGlobalUserDefaultsWithShellCommands(shellCommandsPath: shellCommandsAppPath)
+    } else {
+      removeShellCommandsFromGlobalUserDefaults(shellCommandsBasename: XcodeProjectGenerator.ShellCommandsUtil)
+    }
   }
 
   private func executePythonProcess(_ scriptFileName: String, onError: @escaping (Int32, String) -> Void) {
diff --git a/src/TulsiGenerator/en.lproj/Localizable.strings b/src/TulsiGenerator/en.lproj/Localizable.strings
index 3c921d76..69563211 100644
--- a/src/TulsiGenerator/en.lproj/Localizable.strings
+++ b/src/TulsiGenerator/en.lproj/Localizable.strings
@@ -121,3 +121,8 @@
 
 /* Warning shown when failing to update the tulsi symlinks into the Bazel output files. symlink path is in %1$@, symlink destination is in %2$@, additional error context in %3$@. */
 "UpdatingTulsiSymlinksFailed" = "Failed to update the %1$@ symlink to %2$@. Additional context: %3$@";
+/* Warning shown when failing to update the tulsi-workspace symlink to the Bazel execution root. tulsi-workspace path is in %1$@, additional error context in %2$@. */
+"UpdatingTulsiWorkspaceSymlinkFailed" = "Failed to update the %1$@ symlink to the Bazel execution root. Additional context: %2$@";
+
+/* Warning when installing the module cache pruner executable to ~/Library/Application Support/Tulsi failed. */
+"InstallModuleCachePrunerFailed" = "Failed to install the module cache pruner executable used avoid an lldb crash during the explicit module migration: received error '%1$@'.";
diff --git a/src/TulsiGenerator/en.lproj/Options.strings b/src/TulsiGenerator/en.lproj/Options.strings
index 88b46995..7a929e3e 100644
--- a/src/TulsiGenerator/en.lproj/Options.strings
+++ b/src/TulsiGenerator/en.lproj/Options.strings
@@ -47,9 +47,15 @@
 "Use64BitWatchSimulator" = "Building for watchOS simulator on Xcode 12";
 "Use4BitWatchSimulator_DESC" = "Enable this option if you are using Xcode 12 or greater and building watchOS apps for the simulator OR building iOS apps that include a watchOS app. The default architecture when building an iOS app with a watchOS app is incompatible with Xcode 12.";
 
+"UseLegacyBuildSystem" = "Use legacy build system";
+"UseLegacyBuildSystem_DESC" = "Swaps between Xcode's legacy build system and new build system.";
+
 "DisableCustomLLDBInit" = "Disable project-level lldbinit";
 "DisableCustomLLDBInit_DESC" = "When this option is enabled, Tulsi will revert to using and modifying the global lldbinit to import the shared ~/.lldbinit-tulsiproj file. When this option is disabled (default), Tulsi will generate a dedicated lldbinit and bundle it with an Xcode project. The dedicated lldbinit will import the global lldbinit file.";
 
+"UseBazelCacheReader" = "Enable fallback dSYM searches";
+"UseBazelCacheReader_DESC" = "When this option is enabled, Tulsi will maintain a SQL database to track dSYMs and query the table for each executable/library in all debug sessions. This may result in a hit on debugging attach times, so enable this option only when dSYMs are required and Spotlight is unable to find dSYMs automatically.";
+
 "CLANG_CXX_LANGUAGE_STANDARD" = "C++ language standard";
 "CLANG_CXX_LANGUAGE_STANDARD_DESC" = "Sets the C++ language standard project wide to prevent any false live issue errors involving certain C++ features.";
 
diff --git a/src/tools/generate_xcodeproj.sh b/src/tools/generate_xcodeproj.sh
index dcb12a69..cb52c14a 100755
--- a/src/tools/generate_xcodeproj.sh
+++ b/src/tools/generate_xcodeproj.sh
@@ -30,21 +30,21 @@ else
 fi
 
 if [[ "${app_bundle_path}" == "" ]]; then
-  if [[ -f "/Applications/Tulsi.app/Contents/MacOS/Tulsi" ]]; then
-    readonly app_bundle_path="/Applications/Tulsi.app"
+  if [[ -f "/Applications/Tulsi++.app/Contents/MacOS/Tulsi++" ]]; then
+    readonly app_bundle_path="/Applications/Tulsi++.app"
   else
-    echo "Tulsi.app could not be located. Please ensure that you have built\
+    echo "Tulsi++.app could not be located. Please ensure that you have built\
  Tulsi and that it exists in an accessible location."
 
     exit 1
   fi
 fi
 
-readonly tulsi_path="${app_bundle_path}/Contents/MacOS/Tulsi"
+readonly tulsi_path="${app_bundle_path}/Contents/MacOS/Tulsi++"
 
 if [[ $# == 0 ]]; then
   exec "${tulsi_path}" -- -h
 else
-  echo "Using Tulsi at ${app_bundle_path}"
+  echo "Using Tulsi++ at ${app_bundle_path}"
   exec "${tulsi_path}" -- "$@"
 fi
diff --git a/src/tools/module_cache_pruner/BUILD b/src/tools/module_cache_pruner/BUILD
new file mode 100644
index 00000000..1eebe1b3
--- /dev/null
+++ b/src/tools/module_cache_pruner/BUILD
@@ -0,0 +1,22 @@
+load("@build_bazel_rules_apple//apple:macos.bzl", "macos_command_line_application")
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+licenses(["notice"])
+
+package(default_visibility = ["//:__subpackages__"])
+
+swift_library(
+    name = "module_cache_pruner_lib",
+    srcs = glob(["*.swift"]),
+    module_name = "ModuleCachePruner",
+)
+
+# This tool handles pruning the LLDB module cache of any modules that are found in a metadata file
+# that is intended to be created by a bazel aspect that collects explicit module build outputs. This
+# tool is needed to avoid a crash with LLDB that occurs when the LLDB module cache contains a module
+# that is also generated in a build as an explicit module.
+macos_command_line_application(
+    name = "module_cache_pruner",
+    minimum_os_version = "10.13",
+    deps = [":module_cache_pruner_lib"],
+)
diff --git a/src/tools/module_cache_pruner/ExplicitModules.swift b/src/tools/module_cache_pruner/ExplicitModules.swift
new file mode 100644
index 00000000..76b14a87
--- /dev/null
+++ b/src/tools/module_cache_pruner/ExplicitModules.swift
@@ -0,0 +1,42 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+import os
+
+/// The top level structure of the metadata file we need to parse.
+struct RawExplicitModulesMetadata: Codable {
+  var explicitModules: [RawExplicitModuleBody]
+
+  private enum CodingKeys : String, CodingKey {
+    case explicitModules = "explicit_modules"
+  }
+}
+
+/// An individual module in the metadata file we need to parse.
+struct RawExplicitModuleBody: Codable {
+  ///  The path to the explicit module in the bazel outputs directory.
+  var path: String
+  ///  The full name of the explicit module.
+  var name: String
+}
+
+/// Reads the given metadata file and returns a list of names of all explicit modules referenced in
+/// that file.
+func getExplicitModuleNames(fromMetadataFile metadataPath: String) throws -> [String] {
+  let metadataURL = URL(fileURLWithPath: metadataPath)
+  let data = try Data(contentsOf: metadataURL)
+  let jsonData = try JSONDecoder().decode(RawExplicitModulesMetadata.self, from: data)
+  return jsonData.explicitModules.map { $0.name }
+}
diff --git a/src/tools/module_cache_pruner/ImplicitModules.swift b/src/tools/module_cache_pruner/ImplicitModules.swift
new file mode 100644
index 00000000..cf453cbe
--- /dev/null
+++ b/src/tools/module_cache_pruner/ImplicitModules.swift
@@ -0,0 +1,125 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+import os
+
+private let fileManager = FileManager.default
+
+/// Reads the contents of the module cache and returns a dictionary that maps the name of a module
+/// to all pcm files in the module cache for that module.
+func getImplicitModules(moduleCacheURL: URL) -> [String: [URL]] {
+  let implicitModules = getModulesInModuleCache(moduleCacheURL)
+  return mapModuleNamesToModuleURLs(implicitModules)
+}
+
+/// Converts a list of precompiled module URLs into a dictionary that maps module names to the
+/// locations of pcm files for that module.
+private func mapModuleNamesToModuleURLs(_ moduleURLs: [URL]) -> [String: [URL]] {
+  var moduleNameToURLs: [String: [URL]] = [:]
+
+  for url in moduleURLs {
+    if let moduleName = moduleNameForImplicitPrecompiledModule(at: url) {
+      var urlsForModule = moduleNameToURLs[moduleName, default: []]
+      urlsForModule.append(url)
+      moduleNameToURLs[moduleName] = urlsForModule
+    }
+  }
+
+  return moduleNameToURLs
+}
+
+/// Reads the contents of the module cache and returns a list of paths to all the precompiled
+/// files in URL form.
+private func getModulesInModuleCache(_ moduleCacheURL: URL) -> [URL] {
+  let subdirectories = getDirectoriesInModuleCacheRoot(moduleCacheURL)
+  var moduleURLs = [URL]()
+
+  let moduleURLsWriteQueue = DispatchQueue(label: "module-cache-urls")
+  let directoryEnumeratingDispatchGroup = DispatchGroup()
+
+  for subdirectory in subdirectories {
+    directoryEnumeratingDispatchGroup.enter()
+
+    DispatchQueue.global(qos: .default).async {
+      let modulesInSubdirectory = getModulesInModuleCacheSubdirectory(subdirectory)
+      moduleURLsWriteQueue.async {
+        moduleURLs.append(contentsOf: modulesInSubdirectory)
+        directoryEnumeratingDispatchGroup.leave()
+      }
+    }
+  }
+
+  directoryEnumeratingDispatchGroup.wait()
+  return moduleURLs
+}
+
+/// Returns the directories in the root of the module cache directory. Precompiled modules are not
+/// found in the root of the module cache directory, they are only found within the subdirectories
+/// that are returned by this function.
+///
+/// ModuleCache.noindex/
+///   |- <HashA>/
+///   |- ...
+///   |- <HashZ>/
+///   |- <ModuleName-HashAA>.swiftmodule
+///   |- ...
+///   |- <ModuleName-HashZZ>.swiftmodule
+private func getDirectoriesInModuleCacheRoot(_ moduleCacheURL: URL) -> [URL] {
+  do {
+    let contents = try fileManager.contentsOfDirectory(
+      at: moduleCacheURL, includingPropertiesForKeys: nil, options: [])
+    return contents.filter { $0.hasDirectoryPath }
+  } catch {
+    os_log(
+      "Failed to read contents of module cache root at %@: %@", log: logger, type: .error,
+      moduleCacheURL.absoluteString, error.localizedDescription)
+    return []
+  }
+}
+
+/// Returns the precompiled module files found in the given subdirectory. Subdirectories will
+/// contain precompiled modules and temporary timestamps.
+///
+/// ModuleCache.noindex/
+///   |- <HashA>/
+///     |- <ModuleName-HashAA>.pcm
+///     |- ...
+///     |- <ModuleName-HashAZ>.pcm
+///   |- ...
+///   |- <HashZ>/
+///     |- <ModuleName-HashZA>.pcm
+///     |- ...
+///     |- <ModuleName-HashZZ>.pcm
+private func getModulesInModuleCacheSubdirectory(
+  _ directoryURL: URL
+) -> [URL] {
+  do {
+    let contents = try fileManager.contentsOfDirectory(
+      at: directoryURL, includingPropertiesForKeys: nil, options: [])
+    return contents.filter { !$0.hasDirectoryPath && $0.pathExtension == "pcm" }
+  } catch {
+    os_log(
+      "Failed to read contents of module cache subdirectory at %@: %@", log: logger, type: .error,
+      directoryURL.absoluteString, error.localizedDescription)
+    return []
+  }
+}
+
+/// Extracts the module name from an implicit module in LLDB's module cache. Implicit Modules are of
+/// the form "<ModuleName-HashAA>.pcm" e.g. "Foundation-3DFYNEBRQSXST.pcm".
+private func moduleNameForImplicitPrecompiledModule(at moduleURL: URL) -> String? {
+  let filename = moduleURL.lastPathComponent
+  return filename.components(separatedBy: "-").first
+}
diff --git a/src/tools/module_cache_pruner/Logger.swift b/src/tools/module_cache_pruner/Logger.swift
new file mode 100644
index 00000000..541b3ecd
--- /dev/null
+++ b/src/tools/module_cache_pruner/Logger.swift
@@ -0,0 +1,17 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import os
+
+public let logger = OSLog(subsystem: "com.google.ModuleCachePruner", category: "default")
diff --git a/src/tools/module_cache_pruner/ModuleCachePruner.swift b/src/tools/module_cache_pruner/ModuleCachePruner.swift
new file mode 100644
index 00000000..ed0b247c
--- /dev/null
+++ b/src/tools/module_cache_pruner/ModuleCachePruner.swift
@@ -0,0 +1,167 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import CommonCrypto
+import Foundation
+import os
+
+private let fileManager = FileManager.default
+let prunedModulesTokenFilename = "modules.hash"
+
+/// Prunes the implicit module cache of any modules that are also found in the explicit module
+/// metadata files. This avoids a crash when LLDB loads an implicit module which will be outdated if
+/// an explicit module counterpart exists.
+/// Returns: A list of URLs of the modules that were removed or nil if pruning was skipped all
+/// together.
+@discardableResult public func pruneModuleCache(
+  moduleCachePath: String, explicitModuleMetadataFile: String
+) -> [URL]? {
+  os_log(
+    "Pruning implicit module cache at %@ of explicit modules in %@.", log: logger, type: .default,
+    moduleCachePath, explicitModuleMetadataFile)
+  let moduleCacheURL = URL(fileURLWithPath: moduleCachePath)
+  let hashValueURL = moduleCacheURL.appendingPathComponent(prunedModulesTokenFilename)
+
+  let explicitModuleNames: [String]
+  do {
+    explicitModuleNames = try getExplicitModuleNames(fromMetadataFile: explicitModuleMetadataFile)
+  } catch {
+    os_log(
+      "Encountered an error while reading metadata file at %@: %@", log: logger, type: .error,
+      explicitModuleMetadataFile, error.localizedDescription)
+    return nil
+  }
+
+  let existingHashValue = readPrunedModulesToken(hashValueURL)
+  guard let computedHashValue = computePrunedModulesToken(explicitModuleNames) else {
+    os_log(
+      "Metadata file contains no explicit module outputs, skipping module cache pruning.",
+      log: logger,
+      type: .default)
+    return nil
+  }
+
+  if existingHashValue == computedHashValue {
+    os_log(
+      "Explicit module outputs have not changed, skipping module cache pruning.", log: logger,
+      type: .default)
+    return nil
+  } else {
+    let implicitModulesByName = getImplicitModules(moduleCacheURL: moduleCacheURL)
+    os_log(
+      "Found %d explicit modules in metadata file and %d unique implicit modules in the module cache.",
+      log: logger, type: .debug, explicitModuleNames.count, implicitModulesByName.count)
+    let removedModules = removeImplicitModulesWithExplicitModuleCounterparts(
+      implicitModulesByName: implicitModulesByName, explicitModuleNames: explicitModuleNames)
+    updatePrunedModulesToken(computedHashValue, hashValueURL: hashValueURL)
+    os_log(
+      "Removed %d implicit modules from the module cache.",
+      log: logger, type: .debug, removedModules.count)
+    return removedModules
+  }
+}
+
+private func removeImplicitModulesWithExplicitModuleCounterparts(
+  implicitModulesByName: [String: [URL]], explicitModuleNames: [String]
+) -> [URL] {
+  var removedModules: [URL] = []
+  let removedModulesWriteQueue = DispatchQueue(label: "pruned-modules")
+  let moduleRemovalDispatchGroup = DispatchGroup()
+
+  for moduleName in explicitModuleNames {
+    let implicitModuleURLs = implicitModulesByName[moduleName, default: []]
+
+    for url in implicitModuleURLs {
+      os_log("Will remove %@.", log: logger, type: .debug, url.absoluteString)
+      moduleRemovalDispatchGroup.enter()
+
+      DispatchQueue.global(qos: .default).async {
+        do {
+          try fileManager.removeItem(at: url)
+          os_log("Did remove %@.", log: logger, type: .debug, url.absoluteString)
+          removedModulesWriteQueue.async {
+            removedModules.append(url)
+            moduleRemovalDispatchGroup.leave()
+          }
+        } catch {
+          os_log(
+            "Failed to remove %@: %@.", log: logger, type: .error, url.absoluteString,
+            error.localizedDescription)
+          moduleRemovalDispatchGroup.leave()
+        }
+      }
+    }
+  }
+
+  moduleRemovalDispatchGroup.wait()
+  return removedModules
+}
+
+private func readPrunedModulesToken(_ hashValueURL: URL) -> String? {
+  do {
+    let hashValue = try Data(contentsOf: hashValueURL)
+    return String(data: hashValue, encoding: .utf8)
+  } catch {
+    if !error.isFileNotFound() {
+      os_log(
+        "Encountered an error while reading the stored explicit module hash at %@: %@", log: logger,
+        type: .error, hashValueURL.absoluteString, error.localizedDescription)
+    }
+    // Returning `nil` guarantees that we will prune the module cache again since the newly computed
+    // module cache will never be `nil` thus will never match this value.
+    return nil
+  }
+}
+
+private func updatePrunedModulesToken(_ hashValue: String, hashValueURL: URL) {
+  do {
+    let parentDirectoryURL = hashValueURL.deletingLastPathComponent()
+    try fileManager.createDirectory(
+      at: parentDirectoryURL, withIntermediateDirectories: true, attributes: [:])
+    try Data(hashValue.utf8).write(to: hashValueURL)
+  } catch {
+    // Failing to update the pruned module token means that the next run will compare the newly
+    // computed module cache token with an outdated token. At worst this will trigger an unnecessary
+    // module cache pruning.
+    os_log(
+      "Encountered an error while updating the stored explicit module hash at %@: %@", log: logger,
+      type: .error, hashValueURL.absoluteString, error.localizedDescription)
+  }
+}
+
+/// Computes a token to track what values were last pruned from the module cache. This can be used
+/// to skip pruning when no new explicit modules were built that haven't already been pruned from
+/// the implicit module cache. Returns nil when the array of modules is empty meaning that there is
+/// nothing to compute.
+private func computePrunedModulesToken(_ modules: [String]) -> String? {
+  guard !modules.isEmpty else {
+    return nil
+  }
+
+  let allModules = modules.sorted().joined(separator: ":")
+  let inputData = Data(allModules.utf8)
+
+  var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+  inputData.withUnsafeBytes {
+    _ = CC_SHA256($0.baseAddress, CC_LONG(inputData.count), &hash)
+  }
+  return Data(hash).base64EncodedString()
+}
+
+extension Error {
+  func isFileNotFound() -> Bool {
+    let nsError = self as NSError
+    return nsError.domain == NSCocoaErrorDomain && nsError.code == NSFileReadNoSuchFileError
+  }
+}
diff --git a/src/tools/module_cache_pruner/main.swift b/src/tools/module_cache_pruner/main.swift
new file mode 100644
index 00000000..9f3df3a2
--- /dev/null
+++ b/src/tools/module_cache_pruner/main.swift
@@ -0,0 +1,24 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+
+if CommandLine.arguments.count == 3 {
+  pruneModuleCache(
+    moduleCachePath: CommandLine.arguments[1], explicitModuleMetadataFile: CommandLine.arguments[2])
+} else {
+  print(
+    "USAGE: \(CommandLine.arguments[0]) </path/to/ModuleCache> </path/to/explicit/module/metadata.json>"
+  )
+}
diff --git a/src/tools/module_cache_pruner/tests/BUILD b/src/tools/module_cache_pruner/tests/BUILD
new file mode 100644
index 00000000..f080e5c1
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/BUILD
@@ -0,0 +1,21 @@
+load("@build_bazel_rules_apple//apple:macos.bzl", "macos_unit_test")
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+licenses(["notice"])
+
+package(default_visibility = ["//:__subpackages__"])
+
+swift_library(
+    name = "module_cache_pruner_tests_lib",
+    testonly = 1,
+    srcs = glob(["*.swift"]),
+    deps = [
+        "//src/tools/module_cache_pruner:module_cache_pruner_lib",
+    ],
+)
+
+macos_unit_test(
+    name = "module_cache_pruner_tests",
+    minimum_os_version = "10.13",
+    deps = [":module_cache_pruner_tests_lib"],
+)
diff --git a/src/tools/module_cache_pruner/tests/ExplicitModulesTest.swift b/src/tools/module_cache_pruner/tests/ExplicitModulesTest.swift
new file mode 100644
index 00000000..4f3e15ce
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/ExplicitModulesTest.swift
@@ -0,0 +1,52 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+import XCTest
+
+@testable import ModuleCachePruner
+
+class ExplicitModuleTests: XCTestCase {
+  let modules = FakeModules()
+  var fakeMetadataFile: URL?
+
+  override func tearDown() {
+    if let fakeMetadataFile = fakeMetadataFile {
+      try? FileManager.default.removeItem(at: fakeMetadataFile)
+    }
+  }
+
+  func testExtractingModuleNamesFromMetatdataFile() {
+    do {
+      fakeMetadataFile = try createFakeMetadataFile(
+        withExplicitModules: [
+          modules.system.foundation, modules.system.coreFoundation, modules.user.buttonsLib,
+          modules.user.buttonsIdentity,
+        ])
+    } catch {
+      XCTFail("Failed to create required fake metadata file: \(error)")
+      return
+    }
+
+    let expectedExplicitModuleNames = [
+      modules.system.foundation, modules.system.coreFoundation, modules.user.buttonsLib,
+      modules.user.buttonsIdentity,
+    ].map { $0.name }
+
+    XCTAssertEqual(
+      try? getExplicitModuleNames(fromMetadataFile: fakeMetadataFile!.path),
+      expectedExplicitModuleNames
+    )
+  }
+}
diff --git a/src/tools/module_cache_pruner/tests/FakeMetadataFile.swift b/src/tools/module_cache_pruner/tests/FakeMetadataFile.swift
new file mode 100644
index 00000000..70339339
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/FakeMetadataFile.swift
@@ -0,0 +1,37 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+
+@testable import ModuleCachePruner
+
+/// Writes a JSON metadata file to a temporary location and returns a URL to that location.
+func createFakeMetadataFile(contents: RawExplicitModulesMetadata) throws -> URL {
+  let temporaryFileURL = getTemporaryJSONFileURL()
+  let jsonData = try JSONEncoder().encode(contents)
+  try jsonData.write(to: temporaryFileURL)
+  return temporaryFileURL
+}
+
+/// Convenience function that abstracts away the need to provide the JSON data in the required
+/// format. Instead, this function accepts FakeModule objects and converts them into the required
+/// format.
+func createFakeMetadataFile(withExplicitModules modules: [FakeModule]) throws -> URL {
+  let fakeMetadataBody = modules.map {
+    RawExplicitModuleBody(
+      path: $0.explicitFilepath, name: $0.name)
+  }
+  let fakeMetadata = RawExplicitModulesMetadata(explicitModules: fakeMetadataBody)
+  return try createFakeMetadataFile(contents: fakeMetadata)
+}
diff --git a/src/tools/module_cache_pruner/tests/FakeModule.swift b/src/tools/module_cache_pruner/tests/FakeModule.swift
new file mode 100644
index 00000000..fdf8d320
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/FakeModule.swift
@@ -0,0 +1,64 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// Wraps values that may be needed to describe a module. This allows our tests to use wrapper
+/// functions to create fake module caches, metadata files, etc that take instances of these fake
+/// modules and extract any module related information needed for a specific function.
+struct FakeModule {
+  /// The name of the module. e.g. "Foundation"
+  let name: String
+  /// The filename of the clang module. e.g. "Foundation.swift.pcm"
+  let clangName: String
+  /// The filename of the swift module. e.g. "Foundation.swiftmodule"
+  let swiftName: String
+  /// The filepath to the explicit clang module.
+  /// e.g. "/private/var/.../bin/buttons/Foundation.swift.pcm"
+  let explicitFilepath: String
+  /// The filename of the implicit clang module. e.g. "Foundation-ABCDEFGH.pcm"
+  /// Note that implicit modules are in the format `<ModuleName>-<BuildOptionsHash>.pcm` and depend
+  /// on the build options used for the implicit compilation. This means that in a real implicit
+  /// module cache there can be multiple implicit PCMs for the same module.
+  let implicitFilename: String
+
+  private static let hashLength = 8
+  private static let outputDirectory =
+    "/private/var/tmp/_bazel_<user>/<workspace-hash>/execroot/<workspace-name>/bazel-out/ios_x86_64-dbg/bin/buttons"
+
+  init(_ name: String, hashCharacter: String) {
+    self.name = name
+    self.clangName = "\(name).swift.pcm"
+    self.swiftName = "\(name).swiftmodule"
+    self.explicitFilepath = "\(FakeModule.outputDirectory)/\(name).swift.pcm"
+    self.implicitFilename =
+      "\(name)-\(String(repeating: hashCharacter, count: FakeModule.hashLength)).pcm"
+  }
+}
+
+struct SystemModules {
+  let foundation = FakeModule("Foundation", hashCharacter: "A")
+  let coreFoundation = FakeModule("CoreFoundation", hashCharacter: "B")
+  let darwin = FakeModule("Darwin", hashCharacter: "C")
+}
+
+struct UserModules {
+  let buttonsLib = FakeModule("ButtonsLib", hashCharacter: "1")
+  let buttonsModel = FakeModule("ButtonsModel", hashCharacter: "2")
+  let buttonsIdentity = FakeModule("ButtonsIdentity", hashCharacter: "3")
+}
+
+/// Encapsulates various ready-to-use fake modules for tests.
+struct FakeModules {
+  let system = SystemModules()
+  let user = UserModules()
+}
diff --git a/src/tools/module_cache_pruner/tests/FakeModuleCache.swift b/src/tools/module_cache_pruner/tests/FakeModuleCache.swift
new file mode 100644
index 00000000..0fc8000c
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/FakeModuleCache.swift
@@ -0,0 +1,47 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+
+/// Creates a complete directory tree in a temporary directory with the given structure.
+func createFakeModuleCache(with contents: DirectoryStructure) -> URL? {
+  guard let temporaryDirectory = createTemporaryDirectory() else {
+    return nil
+  }
+
+  do {
+    try createDirectoryStructure(temporaryDirectory, withContents: contents)
+  } catch {
+    try? FileManager.default.removeItem(at: temporaryDirectory)
+    return nil
+  }
+  return temporaryDirectory
+}
+
+/// Convenience function that abstracts away the need to provide the exact directory tree structure.
+/// Instead, this function accepts FakeModule objects labeled as either swift or clang modules and
+/// computes the directory structure.
+func createFakeModuleCache(
+  withSwiftModules swiftModules: [FakeModule],
+  andClangModules clangModulesByDirectory: [String: [FakeModule]]
+) -> URL? {
+  var directories = [String: DirectoryStructure]()
+  for (directory, clangModules) in clangModulesByDirectory {
+    directories[directory] = DirectoryStructure(files: clangModules.map { $0.implicitFilename })
+  }
+  let files = swiftModules.map { $0.swiftName }
+
+  let contents = DirectoryStructure(files: files, directories: directories)
+  return createFakeModuleCache(with: contents)
+}
diff --git a/src/tools/module_cache_pruner/tests/FileUtils.swift b/src/tools/module_cache_pruner/tests/FileUtils.swift
new file mode 100644
index 00000000..c874bd63
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/FileUtils.swift
@@ -0,0 +1,103 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+
+private let fileManager = FileManager.default
+
+struct DirectoryStructure {
+  var files: [String]?
+  var directories: [String: DirectoryStructure]?
+}
+
+/// Creates a directory and any subdirectories + dummy files at the given location on the file
+/// system.
+func createDirectoryStructure(_ directory: URL, withContents contents: DirectoryStructure) throws {
+  if let files = contents.files {
+    for filename in files {
+      let filepath = directory.appendingPathComponent(filename)
+      try "".write(to: filepath, atomically: true, encoding: .utf8)
+    }
+  }
+
+  if let directories = contents.directories {
+    for (dirname, contents) in directories {
+      let subdirectory = directory.appendingPathComponent(dirname)
+      try fileManager.createDirectory(at: subdirectory, withIntermediateDirectories: true)
+      try createDirectoryStructure(subdirectory, withContents: contents)
+    }
+  }
+}
+
+/// Creates a directory with a random name in the macOS temporary directory.
+func createTemporaryDirectory() -> URL? {
+  let osTemporaryDirectory = URL(
+    fileURLWithPath: NSTemporaryDirectory(),
+    isDirectory: true)
+
+  guard
+    let temporaryDirectory = try? fileManager.url(
+      for: .itemReplacementDirectory,
+      in: .userDomainMask,
+      appropriateFor: osTemporaryDirectory,
+      create: true)
+  else {
+    return nil
+  }
+
+  // The macOS temporary directory is located under the `/var` root directory. `/var` is a symlink
+  // to `/private/var` which can cause problems when testing for equal values since equality will
+  // depend on whether prod code resolves the realpath or leaves it as the symlink. To avoid issues,
+  // return the realpath so test and prod code will only ever handle one version of the path.
+  guard let temporaryDirectoryRealPath = realpath(temporaryDirectory.path, nil) else {
+    return nil
+  }
+
+  return URL(fileURLWithPath: String(cString: temporaryDirectoryRealPath), isDirectory: true)
+}
+
+/// Returns a URL to a location for a JSON file with a random filename under the macOS temporary
+/// directory. This function does not create a file at that location.
+func getTemporaryJSONFileURL() -> URL {
+  let temporaryDirectoryURL = URL(
+    fileURLWithPath: NSTemporaryDirectory(),
+    isDirectory: true)
+  let temporaryFilename = ProcessInfo().globallyUniqueString
+  return temporaryDirectoryURL.appendingPathComponent("\(temporaryFilename).json")
+}
+
+/// Enumerates the full contents of a directory and returns a Set of the results containing only
+/// relative paths to the given directory.
+func getDirectoryContentsWithRelativePaths(directory: URL) -> Set<String> {
+  // The file manager enumerator function accepts an option that will enumerate with relative paths,
+  // i.e. FileManager.DirectoryEnumerationOptions.producesRelativePathURLs, but that options
+  // requires macOS 10.15 which is not guaranteed when building Tulsi. Instead, we create the
+  // relative paths ourselves.
+  guard let results = fileManager.enumerator(at: directory, includingPropertiesForKeys: nil) else {
+    return []
+  }
+
+  let directoryPath = directory.path
+  var relativeResults = Set<String>()
+  for result in results {
+    if let resultUrl = result as? URL {
+      let resultPath = resultUrl.path
+      let path =
+        resultPath.hasPrefix(directoryPath)
+        ? String(resultPath.dropFirst(directoryPath.count + 1)) : resultPath
+      relativeResults.insert(path)
+    }
+  }
+  return relativeResults
+}
diff --git a/src/tools/module_cache_pruner/tests/ImplicitModulesTest.swift b/src/tools/module_cache_pruner/tests/ImplicitModulesTest.swift
new file mode 100644
index 00000000..f374c8b0
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/ImplicitModulesTest.swift
@@ -0,0 +1,80 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+import XCTest
+
+@testable import ModuleCachePruner
+
+/// Converts a Dictionary that uses Arrays for the values into a nearly identical Dictionary that
+/// instead uses Sets for the values. This allows us to test for Dictionary equality without
+/// needing to worry about the ordering in the values.
+func convertArrayValuesToSetValues(_ input: [String: [URL]]) -> [String: Set<URL>] {
+  return Dictionary(uniqueKeysWithValues: input.map { ($0, Set($1)) })
+}
+
+class ImplicitModuleTests: XCTestCase {
+  let modules = FakeModules()
+  var fakeModuleCacheURL: URL?
+
+  override func tearDown() {
+    if let moduleCacheURL = fakeModuleCacheURL {
+      try? FileManager.default.removeItem(at: moduleCacheURL)
+    }
+  }
+
+  func testMappingModulesInModuleCache() {
+    guard
+      let moduleCacheURL = createFakeModuleCache(
+        withSwiftModules: [
+          modules.system.foundation, modules.system.coreFoundation, modules.system.darwin,
+        ],
+        andClangModules: [
+          "DirectoryHash1": [
+            modules.user.buttonsLib, modules.user.buttonsIdentity, modules.user.buttonsModel,
+          ],
+          "DirectoryHash2": [
+            modules.user.buttonsLib, modules.user.buttonsIdentity, modules.user.buttonsModel,
+          ],
+        ])
+    else {
+      XCTFail("Failed to create fake module cache required for test.")
+      return
+    }
+
+    fakeModuleCacheURL = moduleCacheURL
+
+    let subdirectory1 = moduleCacheURL.appendingPathComponent("DirectoryHash1")
+    let subdirectory2 = moduleCacheURL.appendingPathComponent("DirectoryHash2")
+    let expectedImplicitModuleMapping = [
+      modules.user.buttonsLib.name: [
+        subdirectory1.appendingPathComponent(modules.user.buttonsLib.implicitFilename),
+        subdirectory2.appendingPathComponent(modules.user.buttonsLib.implicitFilename),
+      ],
+      modules.user.buttonsIdentity.name: [
+        subdirectory1.appendingPathComponent(modules.user.buttonsIdentity.implicitFilename),
+        subdirectory2.appendingPathComponent(modules.user.buttonsIdentity.implicitFilename),
+      ],
+      modules.user.buttonsModel.name: [
+        subdirectory1.appendingPathComponent(modules.user.buttonsModel.implicitFilename),
+        subdirectory2.appendingPathComponent(modules.user.buttonsModel.implicitFilename),
+      ],
+    ]
+
+    let actualImplicitModuleMapping = getImplicitModules(moduleCacheURL: moduleCacheURL)
+    XCTAssertEqual(
+      convertArrayValuesToSetValues(actualImplicitModuleMapping),
+      convertArrayValuesToSetValues(expectedImplicitModuleMapping))
+  }
+}
diff --git a/src/tools/module_cache_pruner/tests/ModuleCachePrunerTest.swift b/src/tools/module_cache_pruner/tests/ModuleCachePrunerTest.swift
new file mode 100644
index 00000000..8289b053
--- /dev/null
+++ b/src/tools/module_cache_pruner/tests/ModuleCachePrunerTest.swift
@@ -0,0 +1,223 @@
+// Copyright 2021 The Tulsi Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Foundation
+import XCTest
+
+@testable import ModuleCachePruner
+
+/// Helper function that asserts that two sets are equal and prints the unique values in each set
+/// when they are not.
+func assertSetsEqual<T>(_ a: Set<T>, _ b: Set<T>) {
+  if a != b {
+    XCTFail(
+      """
+      Set A=\(a) is not equal to Set B=\(b).
+      Set A - B = \(a.subtracting(b)).
+      Set B - A = \(b.subtracting(a)).
+      """)
+  }
+}
+
+enum TestSetupError: Error {
+  case noMetadataFile(msg: String)
+  case noModuleCache(msg: String)
+}
+
+func createFakes(
+  metadataFileWithExplicitModules explicitModules: [FakeModule],
+  moduleCacheDirectoryWith moduleCache: (
+    swiftModules: [FakeModule], clangModules: [String: [FakeModule]]
+  )
+) throws -> (metadataFile: URL, moduleCache: URL) {
+  var fakeMetadataFile: URL
+  do {
+    fakeMetadataFile = try createFakeMetadataFile(withExplicitModules: explicitModules)
+  } catch {
+    throw TestSetupError.noMetadataFile(
+      msg: "Failed to create required fake metadata file: \(error)")
+  }
+
+  guard
+    let fakeModuleCache = createFakeModuleCache(
+      withSwiftModules: moduleCache.swiftModules,
+      andClangModules: moduleCache.clangModules)
+  else {
+    throw TestSetupError.noModuleCache(
+      msg: "Failed to create fake module cache required for test.")
+  }
+
+  return (fakeMetadataFile, fakeModuleCache)
+}
+
+class ModuleCachePrunerTests: XCTestCase {
+  let modules = FakeModules()
+  var fakeMetadataFile: URL?
+  var fakeModuleCacheURL: URL?
+
+  private let directoryHash1 = "ABCDEFGH"
+  private let directoryHash2 = "12345678"
+
+  override func tearDown() {
+    if let fakeMetadataFile = fakeMetadataFile {
+      try? FileManager.default.removeItem(at: fakeMetadataFile)
+    }
+    if let moduleCacheURL = fakeModuleCacheURL {
+      try? FileManager.default.removeItem(at: moduleCacheURL)
+    }
+  }
+
+  private func implicitModuleCacheURLs(
+    _ moduleCacheURL: URL, forModulesInDirectories modulesByDirectory: [String: [FakeModule]]
+  ) -> Set<URL> {
+    var result = Set<URL>()
+    for (subdirectoryName, modules) in modulesByDirectory {
+      let subdirectoryPath = moduleCacheURL.appendingPathComponent(subdirectoryName)
+      for module in modules {
+        result.insert(subdirectoryPath.appendingPathComponent(module.implicitFilename))
+      }
+    }
+    return result
+  }
+
+  func testModuleCachePruning() {
+    let fakes: (metadataFile: URL, moduleCache: URL)
+    do {
+      fakes = try createFakes(
+        metadataFileWithExplicitModules: [
+          modules.system.foundation, modules.system.coreFoundation, modules.user.buttonsLib,
+          modules.user.buttonsIdentity,
+        ],
+        moduleCacheDirectoryWith: (
+          swiftModules: [
+            modules.system.foundation,
+            modules.system.coreFoundation,
+            modules.system.darwin,
+          ],
+          clangModules: [
+            directoryHash1: [
+              modules.user.buttonsLib, modules.user.buttonsIdentity,
+              modules.user.buttonsModel,
+            ],
+            directoryHash2: [
+              modules.system.foundation, modules.system.coreFoundation,
+              modules.system.darwin,
+            ],
+          ]
+        ))
+    } catch TestSetupError.noModuleCache(let msg), TestSetupError.noMetadataFile(let msg) {
+      XCTFail(msg)
+      return
+    } catch {
+      XCTFail(error.localizedDescription)
+      return
+    }
+
+    fakeMetadataFile = fakes.metadataFile
+    fakeModuleCacheURL = fakes.moduleCache
+
+    guard
+      let actualModulesRemovedFromModuleCache = pruneModuleCache(
+        moduleCachePath: fakes.moduleCache.path, explicitModuleMetadataFile: fakes.metadataFile.path
+      )
+    else {
+      XCTFail("Module cache pruning returned nil but expected a list")
+      return
+    }
+
+    let expectedModulesRemovedFromModuleCache = implicitModuleCacheURLs(
+      fakes.moduleCache,
+      forModulesInDirectories: [
+        directoryHash1: [modules.user.buttonsLib, modules.user.buttonsIdentity],
+        directoryHash2: [modules.system.foundation, modules.system.coreFoundation],
+      ])
+
+    assertSetsEqual(Set(actualModulesRemovedFromModuleCache), expectedModulesRemovedFromModuleCache)
+
+    let actualFilenamesRemainingInModuleCache = getDirectoryContentsWithRelativePaths(
+      directory: fakes.moduleCache)
+    let expectedFilenamesRemainingInModuleCache = Set([
+      modules.system.foundation.swiftName, modules.system.coreFoundation.swiftName,
+      modules.system.darwin.swiftName,
+      "\(directoryHash1)/\(modules.user.buttonsModel.implicitFilename)",
+      "\(directoryHash2)/\(modules.system.darwin.implicitFilename)",
+      directoryHash1, directoryHash2, prunedModulesTokenFilename,
+    ])
+
+    assertSetsEqual(actualFilenamesRemainingInModuleCache, expectedFilenamesRemainingInModuleCache)
+  }
+
+  func testModuleCachePruningNegativeCases() {
+    let fakes: (metadataFile: URL, moduleCache: URL)
+
+    do {
+      // For this test, ensure that there should be no overlap between explicit modules and implicit
+      // modules.
+      fakes = try createFakes(
+        metadataFileWithExplicitModules: [
+          modules.system.foundation, modules.user.buttonsLib,
+        ],
+        moduleCacheDirectoryWith: (
+          swiftModules: [],
+          clangModules: [
+            directoryHash1: [
+              modules.user.buttonsIdentity, modules.user.buttonsModel,
+            ],
+            directoryHash2: [
+              modules.system.coreFoundation, modules.system.darwin,
+            ],
+          ]
+        ))
+    } catch TestSetupError.noModuleCache(let msg), TestSetupError.noMetadataFile(let msg) {
+      XCTFail(msg)
+      return
+    } catch {
+      XCTFail(error.localizedDescription)
+      return
+    }
+
+    fakeMetadataFile = fakes.metadataFile
+    fakeModuleCacheURL = fakes.moduleCache
+
+    guard
+      let modulesRemovedFromModuleCache1 = pruneModuleCache(
+        moduleCachePath: fakes.moduleCache.path, explicitModuleMetadataFile: fakes.metadataFile.path
+      )
+    else {
+      XCTFail("Module cache pruning returned nil but expected an empty list")
+      return
+    }
+    // There was no overlap so nothing should have been removed.
+    XCTAssertEqual(modulesRemovedFromModuleCache1.count, 0)
+
+    let modulesRemovedFromModuleCache2 = pruneModuleCache(
+      moduleCachePath: fakes.moduleCache.path, explicitModuleMetadataFile: fakes.metadataFile.path)
+    // Explicit module outputs did not change so we should have skipped pruning altogether.
+    XCTAssertNil(modulesRemovedFromModuleCache2)
+
+    let metadataFileWithNoExplicitModules: URL
+    do {
+      metadataFileWithNoExplicitModules = try createFakeMetadataFile(withExplicitModules: [])
+    } catch {
+      XCTFail("Failed to create required fake metadata file: \(error)")
+      return
+    }
+    let modulesRemovedFromModuleCache3 = pruneModuleCache(
+      moduleCachePath: fakes.moduleCache.path,
+      explicitModuleMetadataFile: metadataFileWithNoExplicitModules.path)
+    // Metadata file did not contain any explicit modules so we should have skipped pruning
+    // altogether.
+    XCTAssertNil(modulesRemovedFromModuleCache3)
+  }
+}