ModuleVerifier: Add blocklist for builtin module verifier

In hopes to migrate over to the EBM based module verifier, stage in a
blocklist for existing verification violations.

Author: cyndyishida

Sources/SWBCore/ToolInfo/ClangToolInfo.swift

@@ -27,6 +27,17 @@ public struct ClangBlocklists : Sendable {
 
     var caching: CachingBlocklistInfo? = nil
 
+    public struct BuiltinModuleVerifierInfo : ProjectFailuresBlockList, Codable, Sendable {
+        /// A blocklist of project names that do not support the `MODULE_VERIFIER_KIND=builtin` build setting.
+        let KnownFailures: [String]
+        enum CodingKeys: String, CodingKey {
+            case KnownFailures
+        }
+    }
+
+    var builtinModuleVerify: BuiltinModuleVerifierInfo? = nil
+
+    /// Helper method for determining if a given functionality is blocklisted for the active scope.
     func isBlocked<BlockListT: ProjectFailuresBlockList>(_ scope: MacroEvaluationScope, info: BlockListT?) -> Bool {
         guard let blocklistInfo = info else { return false }
         return blocklistInfo.isProjectListed(scope)
@@ -90,6 +101,10 @@ public struct DiscoveredClangToolSpecInfo: DiscoveredCommandLineToolSpecInfo {
     public func isCachingBlocked(_ scope: MacroEvaluationScope) -> Bool {
         return blocklists.isBlocked(scope, info: blocklists.caching)
      }
+
+    public func isBuiltinModuleVerifyBlocked(_ scope: MacroEvaluationScope) -> Bool {
+        return blocklists.isBlocked(scope, info: blocklists.builtinModuleVerify)
+    }
 }
 
 private let clangVersionRe = RegEx(patternLiteral: #""(?<llvm>[0-9]+(?:\.[0-9]+){0,}) \(clang-(?<clang>[0-9]+(?:\.[0-9]+){0,})\)(?: ((\[.+\])|(\(.+\)))+)?""#)
@@ -187,6 +202,8 @@ public func discoveredClangToolInfo(
         }
         var blocklists = ClangBlocklists()
         blocklists.caching = getBlocklist(type: ClangBlocklists.CachingBlocklistInfo.self, toolchainFilename: "clang-caching.json", delegate: delegate)
+        blocklists.builtinModuleVerify = getBlocklist(type: ClangBlocklists.BuiltinModuleVerifierInfo.self, toolchainFilename: "clang-builtin-module-verify.json", delegate: delegate)
+
 
         return DiscoveredClangToolSpecInfo(
             toolPath: toolPath,

Sources/SWBTaskConstruction/TaskProducers/OtherTaskProducers/ModuleVerifierTaskProducer.swift

@@ -149,6 +149,11 @@ final class ModuleVerifierTaskProducer: PhasedTaskProducer, TaskProducer {
                     fallbackToExternal = true
                     return
                 }
+                // Fallback to external verifier if current scope is blocklisted.
+                if clangInfo?.isBuiltinModuleVerifyBlocked(scope) == true {
+                    fallbackToExternal = true
+                    return
+                }
             } catch {
                 delegate.error(error)
                 return

Tests/SWBTaskConstructionTests/ModuleVerifierTaskConstructionTests.swift

@@ -659,6 +659,77 @@ fileprivate struct ModuleVerifierTaskConstructionTests: CoreBasedTests {
         }
     }
 
+    @Test(.requireSDKs(.macOS))
+    func builtinModuleVerifyList() async throws {
+        try await withTemporaryDirectory { tmpDirPath in
+            let blockListFilePath = tmpDirPath.join("clang-builtin-module-verify.json")
+            let targetName = "Orange"
+            let testProject =
+            TestProject(
+                "aProject",
+                sourceRoot: tmpDirPath.join("Test"),
+                groupTree: TestGroup(
+                    "Group",
+                    path: "Sources",
+                    children: [
+                        TestFile("Orange.h"),
+                        TestFile("Orange.defs"),
+                        TestFile("main.m"),
+                    ]),
+                targets: [
+                    TestStandardTarget(
+                        targetName,
+                        type: .framework,
+                        buildConfigurations: [
+                            TestBuildConfiguration("Debug", buildSettings: [
+                                "ARCHS": "arm64",
+                                "DEFINES_MODULE": "YES",
+                                "ENABLE_MODULE_VERIFIER": "YES",
+                                "MODULE_VERIFIER_KIND": "builtin",
+                                "GENERATE_INFOPLIST_FILE": "YES",
+                                "MODULE_VERIFIER_SUPPORTED_LANGUAGE_STANDARDS": "gnu11",
+                                "MODULE_VERIFIER_SUPPORTED_LANGUAGES": "objective-c",
+                                "MODULE_VERIFIER_VERBOSE": "YES",
+                                "PRODUCT_NAME": "$(TARGET_NAME)",
+                                "BLOCKLISTS_PATH": tmpDirPath.str,
+                            ]),
+                        ],
+                        buildPhases: [
+                            TestHeadersBuildPhase([
+                                TestBuildFile("Orange.h", headerVisibility: .public)
+                            ]),
+                            TestSourcesBuildPhase([
+                                "main.m",
+                            ]),
+                    ]),
+                ])
+
+                let core = try await getCore()
+                let tester = try await BuildOperationTester(core, testProject, simulated: false)
+                let SRCROOT = tester.workspace.projects[0].sourceRoot
+                for inputFile in ["Sources/Orange.h", "Sources/Orange.defs", "Sources/main.m"] {
+                    try await tester.fs.writeFileContents(SRCROOT.join(inputFile)) { stream in
+                        stream <<< ""
+                    }
+                }
+                try await tester.fs.writeFileContents(blockListFilePath) { file in
+                    file <<<
+                        """
+                        { "KnownFailures": ["aProject"]}
+                        """
+                }
+                /// Verify that while the project has enabled `MODULE_VERIFIER_KIND=builtin` the external module verifier is invoked because the project is on the blocklist.
+                try await tester.checkBuild(runDestination: .macOS) { results in
+                results.checkNoDiagnostics()
+                results.checkTask(.matchRuleType("VerifyModule")) { task in
+                        task.checkRuleInfo(["VerifyModule", "\(SRCROOT.str)/build/Debug/Orange.framework"])
+                        task.checkCommandLineMatches([.suffix("modules-verifier"), "\(SRCROOT.str)/build/Debug/Orange.framework", .anySequence, "--clang", .suffix("clang"), .anySequence])
+                }
+                results.checkNoErrors()
+            }
+        }
+    }
+
     @Test(.requireSDKs(.macOS))
     func externalModuleVerifier() async throws {
         let archs = ["arm64", "x86_64"]