Skip to content

Commit f466568

Browse files
ahoppenahoppen
committed
Add infrastructure to write tests for Swift macros
Add a default package manifest that defines two targets: - A macro target named `MyMacro` - And executable target named `MyMacroClient` It builds the macro using the swift-syntax that was already built as part of the SourceKit-LSP build. Re-using the SwiftSyntax modules that are already built is significantly faster than building swift-syntax in each test case run and does not require internet access.
1 parent 505f4cf commit f466568

File tree

6 files changed

+245
-23
lines changed

6 files changed

+245
-23
lines changed

‎Package.swift‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -381,6 +381,10 @@ let package = Package(
381381
.product(name: "SwiftParser", package: "swift-syntax"),
382382
.product(name: "SwiftSyntax", package: "swift-syntax"),
383383
.product(name: "SwiftToolsSupport-auto", package: "swift-tools-support-core"),
384+
// Depend on `SwiftCompilerPlugin` and `SwiftSyntaxMacros` so the modules are built before running tests and can
385+
// be used by test cases that test macros (see `SwiftPMTestProject.macroPackageManifest`).
386+
.product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
387+
.product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
384388
]
385389
),
386390
]

‎Sources/SKTestSupport/SkipUnless.swift‎

Lines changed: 56 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -58,17 +58,11 @@ public actor SkipUnless {
5858
line: UInt,
5959
featureCheck: () async throws -> Bool
6060
) async throws {
61-
let checkResult: FeatureCheckResult
62-
if let cachedResult = checkCache[featureName] {
63-
checkResult = cachedResult
64-
} else if ProcessEnv.block["SWIFTCI_USE_LOCAL_DEPS"] != nil {
65-
// Never skip tests in CI. Toolchain should be up-to-date
66-
checkResult = .featureSupported
67-
} else {
61+
return try await skipUnlessSupported(featureName: featureName, file: file, line: line) {
6862
let toolchainSwiftVersion = try await unwrap(ToolchainRegistry.forTesting.default).swiftVersion
6963
let requiredSwiftVersion = SwiftVersion(swiftVersion.major, swiftVersion.minor)
7064
if toolchainSwiftVersion < requiredSwiftVersion {
71-
checkResult = .featureUnsupported(
65+
return .featureUnsupported(
7266
skipMessage: """
7367
Skipping because toolchain has Swift version \(toolchainSwiftVersion) \
7468
but test requires at least \(requiredSwiftVersion)
@@ -77,15 +71,32 @@ public actor SkipUnless {
7771
} else if toolchainSwiftVersion == requiredSwiftVersion {
7872
logger.info("Checking if feature '\(featureName)' is supported")
7973
if try await !featureCheck() {
80-
checkResult = .featureUnsupported(skipMessage: "Skipping because toolchain doesn't contain \(featureName)")
74+
return .featureUnsupported(skipMessage: "Skipping because toolchain doesn't contain \(featureName)")
8175
} else {
82-
checkResult = .featureSupported
76+
return .featureSupported
8377
}
8478
logger.info("Done checking if feature '\(featureName)' is supported")
8579
} else {
86-
checkResult = .featureSupported
80+
return .featureSupported
8781
}
8882
}
83+
}
84+
85+
private func skipUnlessSupported(
86+
featureName: String = #function,
87+
file: StaticString,
88+
line: UInt,
89+
featureCheck: () async throws -> FeatureCheckResult
90+
) async throws {
91+
let checkResult: FeatureCheckResult
92+
if let cachedResult = checkCache[featureName] {
93+
checkResult = cachedResult
94+
} else if ProcessEnv.block["SWIFTCI_USE_LOCAL_DEPS"] != nil {
95+
// Never skip tests in CI. Toolchain should be up-to-date
96+
checkResult = .featureSupported
97+
} else {
98+
checkResult = try await featureCheck()
99+
}
89100
checkCache[featureName] = checkResult
90101

91102
if case .featureUnsupported(let skipMessage) = checkResult {
@@ -272,6 +283,40 @@ public actor SkipUnless {
272283
}
273284
#endif
274285
}
286+
287+
/// Check if we can use the build artifacts in the sourcekit-lsp build directory to build a macro package without
288+
/// re-building swift-syntax.
289+
public static func canBuildMacroUsingSwiftSyntaxFromSourceKitLSPBuild(
290+
file: StaticString = #filePath,
291+
line: UInt = #line
292+
) async throws {
293+
return try await shared.skipUnlessSupported(file: file, line: line) {
294+
do {
295+
let project = try await SwiftPMTestProject(
296+
files: [
297+
"MyMacros/MyMacros.swift": #"""
298+
import SwiftCompilerPlugin
299+
import SwiftSyntax
300+
import SwiftSyntaxBuilder
301+
import SwiftSyntaxMacros
302+
"""#,
303+
"MyMacroClient/MyMacroClient.swift": """
304+
""",
305+
],
306+
manifest: SwiftPMTestProject.macroPackageManifest
307+
)
308+
try await SwiftPMTestProject.build(at: project.scratchDirectory)
309+
return .featureSupported
310+
} catch {
311+
return .featureUnsupported(
312+
skipMessage: """
313+
Skipping because macro could not be built using build artifacts in the sourcekit-lsp build directory. \
314+
This usually happens if sourcekit-lsp was built using a different toolchain than the one used at test-time.
315+
"""
316+
)
317+
}
318+
}
319+
}
275320
}
276321

277322
// MARK: - Parsing Swift compiler version

‎Sources/SKTestSupport/SwiftPMTestProject.swift‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,8 @@ import LanguageServerProtocol
1616
import SourceKitLSP
1717
import TSCBasic
1818

19+
private struct SwiftSyntaxCShimsModulemapNotFoundError: Error {}
20+
1921
public class SwiftPMTestProject: MultiFileTestProject {
2022
enum Error: Swift.Error {
2123
/// The `swift` executable could not be found.
@@ -33,6 +35,117 @@ public class SwiftPMTestProject: MultiFileTestProject {
3335
)
3436
"""
3537

38+
/// A manifest that defines two targets:
39+
/// - A macro target named `MyMacro`
40+
/// - And executable target named `MyMacroClient`
41+
///
42+
/// It builds the macro using the swift-syntax that was already built as part of the SourceKit-LSP build.
43+
/// Re-using the SwiftSyntax modules that are already built is significantly faster than building swift-syntax in
44+
/// each test case run and does not require internet access.
45+
public static var macroPackageManifest: String {
46+
get async throws {
47+
// build directory is `.build/debug/arm64-apple-macosx` or the platform-specific equivalent
48+
let buildDirectory = testBundle.bundleURL.deletingLastPathComponent()
49+
50+
// Directories that we should search for the swift-syntax package.
51+
// We prefer a checkout in the build folder. If that doesn't exist, we are probably using local dependencies
52+
// (SWIFTCI_USE_LOCAL_DEPS), so search next to the sourcekit-lsp source repo
53+
let swiftSyntaxSearchPaths = [
54+
buildDirectory
55+
.deletingLastPathComponent() // arm64-apple-macosx
56+
.deletingLastPathComponent() // debug
57+
.appendingPathComponent("checkouts"),
58+
URL(fileURLWithPath: #filePath)
59+
.deletingLastPathComponent() // SwiftPMTestProject.swift
60+
.deletingLastPathComponent() // SKTestSupport
61+
.deletingLastPathComponent() // Sources
62+
.deletingLastPathComponent(), // sourcekit-lsp
63+
]
64+
65+
let swiftSyntaxCShimsModulemap =
66+
swiftSyntaxSearchPaths.map { swiftSyntaxSearchPath in
67+
swiftSyntaxSearchPath
68+
.appendingPathComponent("swift-syntax")
69+
.appendingPathComponent("Sources")
70+
.appendingPathComponent("_SwiftSyntaxCShims")
71+
.appendingPathComponent("include")
72+
.appendingPathComponent("module.modulemap")
73+
}
74+
.first { FileManager.default.fileExists(atPath: $0.path) }
75+
76+
guard let swiftSyntaxCShimsModulemap else {
77+
throw SwiftSyntaxCShimsModulemapNotFoundError()
78+
}
79+
80+
let swiftSyntaxModulesToLink = [
81+
"SwiftBasicFormat",
82+
"SwiftCompilerPlugin",
83+
"SwiftCompilerPluginMessageHandling",
84+
"SwiftDiagnostics",
85+
"SwiftOperators",
86+
"SwiftParser",
87+
"SwiftParserDiagnostics",
88+
"SwiftSyntax",
89+
"SwiftSyntaxBuilder",
90+
"SwiftSyntaxMacroExpansion",
91+
"SwiftSyntaxMacros",
92+
]
93+
94+
var objectFiles: [String] = []
95+
for moduleName in swiftSyntaxModulesToLink {
96+
let dir = buildDirectory.appendingPathComponent("\(moduleName).build")
97+
let enumerator = FileManager.default.enumerator(at: dir, includingPropertiesForKeys: nil)
98+
while let file = enumerator?.nextObject() as? URL {
99+
if file.pathExtension == "o" {
100+
objectFiles.append(file.path)
101+
}
102+
}
103+
}
104+
105+
let linkerFlags = objectFiles.map {
106+
"""
107+
"-l", "\($0)",
108+
"""
109+
}.joined(separator: "\n")
110+
111+
let moduleSearchPath: String
112+
if let toolchainVersion = try await ToolchainRegistry.forTesting.default?.swiftVersion,
113+
toolchainVersion < SwiftVersion(6, 0)
114+
{
115+
moduleSearchPath = buildDirectory.path
116+
} else {
117+
moduleSearchPath = "\(buildDirectory.path)/Modules"
118+
}
119+
120+
return """
121+
// swift-tools-version: 5.10
122+
123+
import PackageDescription
124+
import CompilerPluginSupport
125+
126+
let package = Package(
127+
name: "MyMacro",
128+
platforms: [.macOS(.v10_15)],
129+
targets: [
130+
.macro(
131+
name: "MyMacros",
132+
swiftSettings: [.unsafeFlags([
133+
"-I", "\(moduleSearchPath)",
134+
"-Xcc", "-fmodule-map-file=\(swiftSyntaxCShimsModulemap.path)"
135+
])],
136+
linkerSettings: [
137+
.unsafeFlags([
138+
\(linkerFlags)
139+
])
140+
]
141+
),
142+
.executableTarget(name: "MyMacroClient", dependencies: ["MyMacros"]),
143+
]
144+
)
145+
"""
146+
}
147+
}
148+
36149
/// Create a new SwiftPM package with the given files.
37150
///
38151
/// If `index` is `true`, then the package will be built, indexing all modules within the package.

‎Sources/SKTestSupport/TestBundle.swift‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
//===----------------------------------------------------------------------===//
2+
//
3+
// This source file is part of the Swift.org open source project
4+
//
5+
// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
6+
// Licensed under Apache License v2.0 with Runtime Library Exception
7+
//
8+
// See https://swift.org/LICENSE.txt for license information
9+
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
10+
//
11+
//===----------------------------------------------------------------------===//
12+
13+
import Foundation
14+
15+
/// The bundle of the currently executing test.
16+
public let testBundle: Bundle = {
17+
#if os(macOS)
18+
if let bundle = Bundle.allBundles.first(where: { $0.bundlePath.hasSuffix(".xctest") }) {
19+
return bundle
20+
}
21+
fatalError("couldn't find the test bundle")
22+
#else
23+
return Bundle.main
24+
#endif
25+
}()

‎Tests/SKCoreTests/BuildServerBuildSystemTests.swift‎

Lines changed: 0 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -20,18 +20,6 @@ import SKTestSupport
2020
import TSCBasic
2121
import XCTest
2222

23-
/// The bundle of the currently executing test.
24-
private let testBundle: Bundle = {
25-
#if os(macOS)
26-
if let bundle = Bundle.allBundles.first(where: { $0.bundlePath.hasSuffix(".xctest") }) {
27-
return bundle
28-
}
29-
fatalError("couldn't find the test bundle")
30-
#else
31-
return Bundle.main
32-
#endif
33-
}()
34-
3523
/// The path to the built products directory.
3624
private let productsDirectory: URL = {
3725
#if os(macOS)

‎Tests/SKSwiftPMWorkspaceTests/SwiftPMBuildSystemTests.swift‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -772,6 +772,53 @@ final class SwiftPMBuildSystemTests: XCTestCase {
772772
assertArgumentsContain(aswift.pathString, arguments: arguments)
773773
}
774774
}
775+
776+
func testBuildMacro() async throws {
777+
try await SkipUnless.canBuildMacroUsingSwiftSyntaxFromSourceKitLSPBuild()
778+
// This test is just a dummy to show how to create a `SwiftPMTestProject` that builds a macro using the SwiftSyntax
779+
// modules that were already built during the build of SourceKit-LSP.
780+
// It should be removed once we have a real test that tests macros (like macro expansion).
781+
let project = try await SwiftPMTestProject(
782+
files: [
783+
"MyMacros/MyMacros.swift": #"""
784+
import SwiftCompilerPlugin
785+
import SwiftSyntax
786+
import SwiftSyntaxBuilder
787+
import SwiftSyntaxMacros
788+
789+
public struct StringifyMacro: ExpressionMacro {
790+
public static func expansion(
791+
of node: some FreestandingMacroExpansionSyntax,
792+
in context: some MacroExpansionContext
793+
) -> ExprSyntax {
794+
guard let argument = node.argumentList.first?.expression else {
795+
fatalError("compiler bug: the macro does not have any arguments")
796+
}
797+
798+
return "(\(argument), \(literal: argument.description))"
799+
}
800+
}
801+
802+
@main
803+
struct MyMacroPlugin: CompilerPlugin {
804+
let providingMacros: [Macro.Type] = [
805+
StringifyMacro.self,
806+
]
807+
}
808+
"""#,
809+
"MyMacroClient/MyMacroClient.swift": """
810+
@freestanding(expression)
811+
public macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MyMacros", type: "StringifyMacro")
812+
813+
func test() {
814+
#stringify(1 + 2)
815+
}
816+
""",
817+
],
818+
manifest: SwiftPMTestProject.macroPackageManifest
819+
)
820+
try await SwiftPMTestProject.build(at: project.scratchDirectory)
821+
}
775822
}
776823

777824
private func assertArgumentsDoNotContain(

0 commit comments

Comments
 (0)