Allow sources anywhere in ./Sources when only one target is present

After getting some feedback about the added `path` argument for executable
packages generated with `swift package init` (#6144), this change allows a
target's sources to occupy the entire sources directory when there is only one
target in the package. All package types can benefit from this.

When there is more than one target in a package, the existing requirements for
target sources still apply.

This change should be compatible with existing layouts as well. If there is
only a single target in a package, then sources can of course continue to exist
in `./Sources/<target>`.

Amend the `executable` template's generated manifest to not include the `path`
argument anymore.

rdar://106829666

Author: bitjammer

CHANGELOG.md

@@ -20,6 +20,10 @@ Swift Next
 Swift 5.9
 -----------
 
+* [#6294]
+
+  When a package contains a single target, sources may be distributed anywhere within the `./Sources` directory. If sources are placed in a subdirectory under `./Sources/<target>`, or there is more than one target, the existing expectation for sources apply.
+
 * [#6114]
 
   Added a new `allowNetworkConnections(scope:reason:)` for giving a command plugin permissions to access the network. Permissions can be scoped to Unix domain sockets in general or specifically for Docker, as well as local or remote IP connections which can be limited by port. For non-interactive use cases, there is also a `--allow-network-connections` commandline flag to allow network connections for a particular scope.

Sources/PackageLoading/PackageBuilder.swift

@@ -526,6 +526,14 @@ public final class PackageBuilder {
                 return path
             }
 
+            // If there is only one target defined, it may be allowed to occupy the
+            // entire predefined target directory.
+            if self.manifest.toolsVersion >= .v5_9 {
+                if self.manifest.targets.count == 1 {
+                    return predefinedTargetDirectory.path
+                }
+            }
+
             // Otherwise, if the path "exists" then the case in manifest differs from the case on the file system.
             if fileSystem.isDirectory(path) {
                 self.observabilityScope.emit(.targetNameHasIncorrectCase(target: target.name))

Sources/Workspace/InitPackage.swift

@@ -257,8 +257,7 @@ public final class InitPackage {
                 if packageType == .executable {
                     param += """
                             .executableTarget(
-                                name: "\(pkgname)",
-                                path: "Sources"),
+                                name: "\(pkgname)")
                         ]
                     """
                 } else if packageType == .tool {

Tests/PackageLoadingTests/PackageBuilderTests.swift

@@ -998,23 +998,154 @@ class PackageBuilderTests: XCTestCase {
         }
     }
 
-    func testManifestTargetDeclErrors() throws {
+    /// Starting with tools version 5.9, packages are permitted to place
+    /// sources anywhere in ./Sources when a package has a single target.
+    func testRelaxedSourceLocationSingleTarget() throws {
         do {
-            // Reference a target which doesn't exist.
+            // Single target: Sources are expected in ./Sources.
             let fs = InMemoryFileSystem(emptyFiles:
-                "/Foo.swift")
+                "/Sources/Foo.swift")
 
             let manifest = Manifest.createRootManifest(
                 displayName: "pkg",
+                toolsVersion: .v5_9,
+                targets: [
+                    try TargetDescription(name: "Random"),
+                ]
+            )
+            PackageBuilderTester(manifest, in: fs) { package, diagnostics in
+                package.checkModule("Random") { result in
+                    XCTAssertEqual("/Sources", result.target.path)
+                }
+            }
+        }
+
+        do {
+            // Single target: Sources are expected in ./Sources.
+            // In this case, there is a stray source file at the top-level, and no sources
+            // under ./Sources, so the target Random has no sources.
+            // This results in a *warning* that there are no sources for the target.
+            let fs = InMemoryFileSystem(emptyFiles:
+                "/Stray.swift")
+
+            let manifest = Manifest.createRootManifest(
+                displayName: "pkg",
+                toolsVersion: .v5_9,
                 targets: [
                     try TargetDescription(name: "Random"),
                 ]
             )
             PackageBuilderTester(manifest, in: fs) { _, diagnostics in
-                diagnostics.check(diagnostic: .contains("Source files for target Random should be located under 'Sources/Random'"), severity: .error)
+                diagnostics.check(diagnostic: .contains("Source files for target Random should be located under /Sources"), severity: .warning)
+            }
+        }
+
+        do {
+            // Single target: Sources are expected in ./Sources. In this case,
+            // there is a stray source file at the top-level which is ignored.
+            let fs = InMemoryFileSystem(emptyFiles:
+                "/Stray.swift",
+                "/Sources/Random.swift")
+
+            let manifest = Manifest.createRootManifest(
+                displayName: "pkg",
+                toolsVersion: .v5_9,
+                targets: [
+                    try TargetDescription(name: "Random"),
+                ]
+            )
+            PackageBuilderTester(manifest, in: fs) { package, diagnostics in
+                package.checkModule("Random")
             }
         }
 
+        do {
+            // Single target: Sources can be expected in ./Sources/<target>.
+            // If that directory exists, stray sources inside ./Sources will
+            // not be included in the target.
+            let fs = InMemoryFileSystem(emptyFiles:
+                "/Sources/Stray.swift",
+                "/Sources/MyTarget/Foo.swift"
+            )
+            let manifest = Manifest.createRootManifest(
+                displayName: "pkg",
+                toolsVersion: .v5_9,
+                targets: [
+                    try TargetDescription(name: "MyTarget"),
+                ]
+            )
+            PackageBuilderTester(manifest, in: fs) { package, diagnostics in
+                package.checkModule("MyTarget") { result in
+                    result.checkSources(paths: "Foo.swift")
+                }
+            }
+        }
+
+        do {
+            // Multiple targets: Sources are expected in their respective subdirectories
+            // under Sources
+            let fs = InMemoryFileSystem(emptyFiles:
+                "/Foo.swift")
+
+            let manifest = Manifest.createRootManifest(
+                displayName: "pkg",
+                toolsVersion: .v5_9,
+                targets: [
+                    try TargetDescription(name: "TargetA"),
+                    try TargetDescription(name: "TargetB"),
+                ]
+            )
+            PackageBuilderTester(manifest, in: fs) { _, diagnostics in
+                diagnostics.check(diagnostic: .contains("Source files for target TargetA should be located under 'Sources/TargetA'" ), severity: .error)
+            }
+        }
+    }
+
+    func testStrictSourceLocation() throws {
+        do {
+            for fs in [
+                InMemoryFileSystem(emptyFiles:
+                                    "/Sources/Foo.swift"),
+                InMemoryFileSystem(emptyFiles:
+                                    "/Stray.swift"),
+                InMemoryFileSystem(emptyFiles:
+                                    "/Stray.swift",
+                                   "/Sources/Random.swift"),
+            ] {
+                let manifest = Manifest.createRootManifest(
+                    displayName: "pkg",
+                    targets: [
+                        try TargetDescription(name: "Random"),
+                    ]
+                )
+                PackageBuilderTester(manifest, in: fs) { _, diagnostics in
+                    diagnostics.check(diagnostic: .contains("Source files for target Random should be located under 'Sources/Random'"), severity: .error)
+                }
+            }
+        }
+
+        do {
+            // Multiple targets: Sources are expected in their respective subdirectories
+            // under Sources
+            let fs = InMemoryFileSystem(emptyFiles:
+                "/Foo.swift")
+
+            let manifest = Manifest.createRootManifest(
+                displayName: "pkg",
+                toolsVersion: .v5_9,
+                targets: [
+                    try TargetDescription(name: "TargetA"),
+                    try TargetDescription(name: "TargetB"),
+                ]
+            )
+            PackageBuilderTester(manifest, in: fs) { _, diagnostics in
+                diagnostics.check(diagnostic: .contains("Source files for target TargetA should be located under 'Sources/TargetA'" ), severity: .error)
+            }
+        }
+
+    }
+
+    func testManifestTargetDeclErrors() throws {
         do {
             let fs = InMemoryFileSystem(emptyFiles:
                 "/src/pkg/Foo.swift")
@@ -1060,21 +1191,6 @@ class PackageBuilderTests: XCTestCase {
             }
         }
 
-        do {
-            let fs = InMemoryFileSystem(emptyFiles:
-                "/Source/pkg/Foo.swift")
-            // Reference invalid target.
-            let manifest = Manifest.createRootManifest(
-                displayName: "pkg",
-                targets: [
-                    try TargetDescription(name: "foo"),
-                ]
-            )
-            PackageBuilderTester(manifest, in: fs) { _, diagnotics in
-                diagnotics.check(diagnostic: .contains("Source files for target foo should be located under 'Sources/foo'"), severity: .error)
-            }
-        }
-
         do {
             let fs = InMemoryFileSystem()
             // Binary target.