Only enable unsafe flags if version 6.2 or newer. (#8951)

As we disable checking for unsafe flags, make sure they are still
checked when the swift-tools-version is earlier than 6.2. This ensures
consumers of the package don't get unsafe flags errors when using older
toolchains. They will need to upgrade their toolchains to use packages
with unsafe flags.

Author: dschaefer2

Sources/PackageLoading/PackageBuilder.swift

@@ -1079,7 +1079,8 @@ public final class PackageBuilder {
                 declaredSwiftVersions: self.declaredSwiftVersions(),
                 buildSettings: buildSettings,
                 buildSettingsDescription: manifestTarget.settings,
-                usesUnsafeFlags: manifestTarget.usesUnsafeFlags,
+                // unsafe flags check disabled in 6.2
+                usesUnsafeFlags: manifest.toolsVersion >= .v6_2 ? false : manifestTarget.usesUnsafeFlags,
                 implicit: false
             )
         } else {
@@ -1125,7 +1126,8 @@ public final class PackageBuilder {
                 dependencies: dependencies,
                 buildSettings: buildSettings,
                 buildSettingsDescription: manifestTarget.settings,
-                usesUnsafeFlags: manifestTarget.usesUnsafeFlags,
+                // unsafe flags check disabled in 6.2
+                usesUnsafeFlags: manifest.toolsVersion >= .v6_2 ? false : manifestTarget.usesUnsafeFlags,
                 implicit: false
             )
         }
@@ -2024,8 +2026,7 @@ extension Sequence {
 
 extension TargetDescription {
     fileprivate var usesUnsafeFlags: Bool {
-        // We no longer restrict unsafe flags
-        false
+        settings.filter(\.kind.isUnsafeFlags).isEmpty == false
     }
 
     fileprivate func isMacroTest(in manifest: Manifest) -> Bool {

Tests/PackageGraphTests/ModulesGraphTests.swift

@@ -2058,7 +2058,7 @@ final class ModulesGraphTests: XCTestCase {
         }
     }
 
-    func testUnsafeFlags() throws {
+    func loadUnsafeModulesGraph(toolsVersion: ToolsVersion) throws -> TestingObservability {
         let fs = InMemoryFileSystem(
             emptyFiles:
             "/Foo/Sources/Foo/foo.swift",
@@ -2071,6 +2071,7 @@ final class ModulesGraphTests: XCTestCase {
         )
 
         let observability = ObservabilitySystem.makeForTesting()
+
         _ = try loadModulesGraph(
             fileSystem: fs,
             manifests: [
@@ -2088,6 +2089,7 @@ final class ModulesGraphTests: XCTestCase {
                 Manifest.createFileSystemManifest(
                     displayName: "Bar",
                     path: "/Bar",
+                    toolsVersion: toolsVersion,
                     products: [
                         ProductDescription(name: "Bar", type: .library(.automatic), targets: ["Bar", "Bar2", "Bar3"]),
                         ProductDescription(
@@ -2127,10 +2129,41 @@ final class ModulesGraphTests: XCTestCase {
             observabilityScope: observability.topScope
         )
 
+        return observability
+    }
+
+    func testUnsafeFlagsDisabled() throws {
+        let observability = try loadUnsafeModulesGraph(toolsVersion: .v6_2)
+
         // We have turned off the unsafe flags check
         XCTAssertEqual(observability.diagnostics.count, 0)
     }
 
+    func testUnsafeFlagsEnabled() throws {
+        let observability = try loadUnsafeModulesGraph(toolsVersion: .v6_1)
+
+        XCTAssertEqual(observability.diagnostics.count, 3)
+        testDiagnostics(observability.diagnostics) { result in
+            var expectedMetadata = ObservabilityMetadata()
+            expectedMetadata.moduleName = "Foo2"
+            let diagnostic1 = result.checkUnordered(
+                diagnostic: .contains("the target 'Bar2' in product 'TransitiveBar' contains unsafe build flags"),
+                severity: .error
+            )
+            XCTAssertEqual(diagnostic1?.metadata?.moduleName, "Foo2")
+            let diagnostic2 = result.checkUnordered(
+                diagnostic: .contains("the target 'Bar' in product 'Bar' contains unsafe build flags"),
+                severity: .error
+            )
+            XCTAssertEqual(diagnostic2?.metadata?.moduleName, "Foo")
+            let diagnostic3 = result.checkUnordered(
+                diagnostic: .contains("the target 'Bar2' in product 'Bar' contains unsafe build flags"),
+                severity: .error
+            )
+            XCTAssertEqual(diagnostic3?.metadata?.moduleName, "Foo")
+        }
+    }
+
     func testConditionalTargetDependency() throws {
         let fs = InMemoryFileSystem(
             emptyFiles:

Tests/WorkspaceTests/WorkspaceTests.swift

@@ -5745,7 +5745,7 @@ final class WorkspaceTests: XCTestCase {
                     products: [
                         MockProduct(name: "Bar", modules: ["Bar"]),
                     ],
-                    versions: ["1.0.0", nil]
+                    versions: ["1.0.0", nil],
                 ),
                 MockPackage(
                     name: "Foo",
@@ -5768,7 +5768,7 @@ final class WorkspaceTests: XCTestCase {
                     products: [
                         MockProduct(name: "Bar", modules: ["Bar"]),
                     ],
-                    versions: ["1.0.0", nil]
+                    versions: ["1.0.0", nil],
                 ),
                 MockPackage(
                     name: "Baz",
@@ -5785,15 +5785,27 @@ final class WorkspaceTests: XCTestCase {
                     dependencies: [
                         .sourceControl(path: "./Bar", requirement: .upToNextMajor(from: "1.0.0")),
                     ],
-                    versions: ["1.0.0", "1.5.0"]
+                    versions: ["1.0.0", "1.5.0"],
+                    toolsVersion: .minimumRequired
                 ),
             ]
         )
 
         // We should only see errors about use of unsafe flag in the version-based dependency.
         try await workspace.checkPackageGraph(roots: ["Foo", "Bar"]) { _, diagnostics in
             // We have disabled the check so there shouldn't be any errors.
-            XCTAssert(diagnostics.filter({ $0.severity == .error }).isEmpty)
+            testDiagnostics(diagnostics) { result in
+                let diagnostic1 = result.checkUnordered(
+                    diagnostic: .equal("the target 'Baz' in product 'Baz' contains unsafe build flags"),
+                    severity: .error
+                )
+                XCTAssertEqual(diagnostic1?.metadata?.packageIdentity, .plain("foo"))
+                XCTAssertEqual(diagnostic1?.metadata?.moduleName, "Foo")
+
+                // since Bar is using the current tools version and we've disabled the check since 6.2,
+                // the result should now be empty.
+                result.checkIsEmpty()
+            }
         }
     }