Simplify implementation of dependency verification dynamic default

Author: Luke Daley

Sources/SWBCore/Dependencies.swift

@@ -16,15 +16,15 @@ public import SWBMacro
 import Foundation
 
 // Global/target dependency settings
-public struct DependencySettings : Serializable, Sendable, Encodable {
-    public let dependencies: OrderedSet<String>
+public struct DependencySettings: Serializable, Sendable, Encodable {
+    public let dependencies: [String]  // lexicographically ordered and uniqued
     public let verification: Bool
 
     public init(
         dependencies: any Sequence<String>,
         verification: Bool
     ) {
-        self.dependencies = OrderedSet(dependencies)
+        self.dependencies = Array(OrderedSet(dependencies).sorted())
         self.verification = verification
     }
 
@@ -45,21 +45,16 @@ public struct DependencySettings : Serializable, Sendable, Encodable {
 extension DependencySettings {
     public init(_ scope: MacroEvaluationScope) {
         let dependencies = scope.evaluate(BuiltinMacros.DEPENDENCIES)
-
-        // We cannot distinguish between "DEPENDENCIES" not set and set to an empty list.
-        // Turn verification off it we have an empty list, assuming that it is not set.
-        // This means that there is no way at the moment to declare that a project with no dependencies should have verification enabled.
-        let verification = !dependencies.isEmpty && scope.evaluate(BuiltinMacros.DEPENDENCIES_VERIFICATION)
-
         self.init(
             dependencies: dependencies,
-            verification: verification
+            verification: scope.evaluate(BuiltinMacros.DEPENDENCIES_VERIFICATION)
+                .isEnabled(onNotSet: !dependencies.isEmpty),
         )
     }
 }
 
 // Task-specific settings
-public struct TaskDependencySettings : Serializable, Sendable, Encodable {
+public struct TaskDependencySettings: Serializable, Sendable, Encodable {
 
     public let traceFile: Path
     public let dependencySettings: DependencySettings

Sources/SWBCore/Settings/BuiltinMacros.swift

@@ -585,7 +585,7 @@ public final class BuiltinMacros {
     public static let DEFAULT_KEXT_INSTALL_PATH = BuiltinMacros.declareStringMacro("DEFAULT_KEXT_INSTALL_PATH")
     public static let DEFINES_MODULE = BuiltinMacros.declareBooleanMacro("DEFINES_MODULE")
     public static let DEPENDENCIES = BuiltinMacros.declareStringListMacro("DEPENDENCIES")
-    public static let DEPENDENCIES_VERIFICATION = BuiltinMacros.declareBooleanMacro("DEPENDENCIES_VERIFICATION")
+    public static let DEPENDENCIES_VERIFICATION = BuiltinMacros.declareEnumMacro("DEPENDENCIES_VERIFICATION") as EnumMacroDeclaration<DependenciesVerificationSetting>
     public static let DEPENDENCY_SCOPE_INCLUDES_DIRECT_DEPENDENCIES = BuiltinMacros.declareBooleanMacro("DEPENDENCY_SCOPE_INCLUDES_DIRECT_DEPENDENCIES")
     public static let DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER = BuiltinMacros.declareBooleanMacro("DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER")
     public static let __DIAGNOSE_DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER_ERROR = BuiltinMacros.declareBooleanMacro("__DIAGNOSE_DERIVE_MACCATALYST_PRODUCT_BUNDLE_IDENTIFIER_ERROR")
@@ -2832,3 +2832,22 @@ extension BuildVersion.Platform {
         return dtsn
     }
 }
+
+public enum DependenciesVerificationSetting: String, Equatable, Hashable, EnumerationMacroType {
+    public static let defaultValue = DependenciesVerificationSetting.notset
+
+    case notset = "NOT_SET"
+    case enabled = "YES"
+    case disabled = "NO"
+
+    func isEnabled(onNotSet: Bool) -> Bool {
+        return switch self {
+        case .notset:
+            onNotSet
+        case .enabled:
+            true
+        case .disabled:
+            false
+        }
+    }
+}

Sources/SWBCore/Specs/CoreBuildSystem.xcspec

@@ -4536,11 +4536,6 @@ When this setting is enabled:
                 Name = "DEPENDENCIES";
                 Type = StringList;
             },
-            {
-                Name = "DEPENDENCIES_VERIFICATION";
-                Type = Boolean;
-                DefaultValue = YES;
-            },
         );
     },
 )

Tests/SWBCoreTests/DependencySettingsTests.swift

@@ -22,16 +22,29 @@ import SWBMacro
 
     @Test
     func emptyDependenciesValueDisablesVerification() throws {
-        var table1 = MacroValueAssignmentTable(namespace: BuiltinMacros.namespace)
-        table1.push(BuiltinMacros.DEPENDENCIES_VERIFICATION, literal: true)
-        let scope1 = MacroEvaluationScope(table: table1)
-        #expect(!DependencySettings(scope1).verification)
-
-        var table2 = MacroValueAssignmentTable(namespace: BuiltinMacros.namespace)
-        table2.push(BuiltinMacros.DEPENDENCIES_VERIFICATION, literal: true)
-        table2.push(BuiltinMacros.DEPENDENCIES, literal: ["Foo"])
-        let scope2 = MacroEvaluationScope(table: table2)
-        #expect(DependencySettings(scope2).verification)
+        #expect(!settings().verification)
+        #expect(settings(dependencies: ["Foo"]).verification)
+        #expect(settings(verification: .enabled).verification)
+        #expect(!settings(dependencies: ["Foo"], verification: .disabled).verification)
+    }
+
+    @Test
+    func dependenciesAreOrderedAndUnique() throws {
+        #expect(Array(settings(dependencies: ["B", "A", "B", "A"]).dependencies) == ["A", "B"])
+    }
+
+    func settings(dependencies: [String]? = nil, verification: DependenciesVerificationSetting? = nil) -> DependencySettings {
+        var table = MacroValueAssignmentTable(namespace: BuiltinMacros.namespace)
+        if let verification {
+            table.push(BuiltinMacros.DEPENDENCIES_VERIFICATION, literal: verification)
+        }
+        if let dependencies {
+            table.push(BuiltinMacros.DEPENDENCIES, literal: dependencies)
+        }
+
+        let scope = MacroEvaluationScope(table: table)
+        return DependencySettings(scope)
+
     }
 
 }

Tests/SWBTaskConstructionTests/DependencyVerificationTaskConstructionTests.swift

@@ -31,7 +31,7 @@ fileprivate struct DependencyVerificationTaskConstructionTests: CoreBasedTests {
 
     @Test
     func addsTraceArgsWhenDependenciesDeclared() async throws {
-        try await testWith(dependencies: ["Foo"]) { tester, srcroot in
+        try await testWith(["DEPENDENCIES": "Foo"]) { tester, srcroot in
             await tester.checkBuild(runDestination: .macOS) { results in
                 results.checkTask(.matchRuleType("Ld")) { task in
                     task.checkCommandLineContains([
@@ -44,7 +44,7 @@ fileprivate struct DependencyVerificationTaskConstructionTests: CoreBasedTests {
                         "-Xclang", "-header-include-file",
                         "-Xclang", outputFile(srcroot, "\(sourceBaseName).o.trace.json"),
                         "-Xclang", "-header-include-filtering=only-direct-system",
-                        "-Xclang", "-header-include-format=json"
+                        "-Xclang", "-header-include-format=json",
                     ])
                 }
             }
@@ -53,7 +53,7 @@ fileprivate struct DependencyVerificationTaskConstructionTests: CoreBasedTests {
 
     @Test
     func noTraceArgsWhenDependenciesDeclared() async throws {
-        try await testWith(dependencies: []) { tester, srcroot in
+        try await testWith([:]) { tester, srcroot in
             await tester.checkBuild(runDestination: .macOS) { results in
                 results.checkTask(.matchRuleType("Ld")) { task in
                     task.checkCommandLineDoesNotContain("-trace_file")
@@ -65,7 +65,21 @@ fileprivate struct DependencyVerificationTaskConstructionTests: CoreBasedTests {
         }
     }
 
-    private func testWith(dependencies: [String], _ assertions: (_ tester: TaskConstructionTester, _ srcroot: Path) async throws -> Void) async throws {
+    @Test
+    func canEnableVerificationOfNoDependencies() async throws {
+        try await testWith(["DEPENDENCIES_VERIFICATION": "YES"]) { tester, srcroot in
+            await tester.checkBuild(runDestination: .macOS) { results in
+                results.checkTask(.matchRuleType("Ld")) { task in
+                    task.checkCommandLineContains(["-Xlinker", "-trace_file",])
+                }
+            }
+        }
+    }
+
+    private func testWith(
+        _ buildSettings: [String: String],
+        _ assertions: (_ tester: TaskConstructionTester, _ srcroot: Path) async throws -> Void
+    ) async throws {
         let testProject = TestProject(
             project,
             groupTree: TestGroup(
@@ -77,11 +91,11 @@ fileprivate struct DependencyVerificationTaskConstructionTests: CoreBasedTests {
                 TestBuildConfiguration(
                     "Debug",
                     buildSettings: [
-                        "DEPENDENCIES": dependencies.joined(separator: " "),
                         "PRODUCT_NAME": "$(TARGET_NAME)",
                         "GENERATE_INFOPLIST_FILE": "YES",
-                        "CLANG_ENABLE_MODULES": "YES"
-                    ])
+                        "CLANG_ENABLE_MODULES": "YES",
+                    ].merging(buildSettings) { _, new in new }
+                )
             ],
             targets: [
                 TestStandardTarget(