Add samples and update CI

Author: marcprux

.github/workflows/ci.yml

@@ -29,5 +29,5 @@ jobs:
         with:
           api-level: 28
           arch: x86_64
-          script: runall.sh
+          script: ./runall.sh
 

macro-sample/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

macro-sample/Package.swift

@@ -0,0 +1,51 @@
+// swift-tools-version: 6.1
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+import CompilerPluginSupport
+
+let package = Package(
+    name: "MacrosDemo",
+    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .watchOS(.v6), .macCatalyst(.v13)],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "MacrosDemo",
+            targets: ["MacrosDemo"]
+        ),
+        .executable(
+            name: "MacrosDemoClient",
+            targets: ["MacrosDemoClient"]
+        ),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "600.0.0-latest"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        // Macro implementation that performs the source transformation of a macro.
+        .macro(
+            name: "MacrosDemoMacros",
+            dependencies: [
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
+            ]
+        ),
+
+        // Library that exposes a macro as part of its API, which is used in client programs.
+        .target(name: "MacrosDemo", dependencies: ["MacrosDemoMacros"]),
+
+        // A client of the library, which is able to use the macro in its own code.
+        .executableTarget(name: "MacrosDemoClient", dependencies: ["MacrosDemo"]),
+
+        // A test target used to develop the macro implementation.
+        .testTarget(
+            name: "MacrosDemoTests",
+            dependencies: [
+                "MacrosDemoMacros",
+                .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
+            ]
+        ),
+    ]
+)

macro-sample/Sources/MacrosDemo/MacrosDemo.swift

@@ -0,0 +1,11 @@
+// The Swift Programming Language
+// https://docs.swift.org/swift-book
+
+/// A macro that produces both a value and a string containing the
+/// source code that generated the value. For example,
+///
+///     #stringify(x + y)
+///
+/// produces a tuple `(x + y, "x + y")`.
+@freestanding(expression)
+public macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MacrosDemoMacros", type: "StringifyMacro")

macro-sample/Sources/MacrosDemoClient/main.swift

@@ -0,0 +1,8 @@
+import MacrosDemo
+
+let a = 17
+let b = 25
+
+let (result, code) = #stringify(a + b)
+
+print("The value \(result) was produced by the code \"\(code)\"")

macro-sample/Sources/MacrosDemoMacros/MacrosDemoMacro.swift

@@ -0,0 +1,33 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+/// Implementation of the `stringify` macro, which takes an expression
+/// of any type and produces a tuple containing the value of that expression
+/// and the source code that produced the value. For example
+///
+///     #stringify(x + y)
+///
+///  will expand to
+///
+///     (x + y, "x + y")
+public struct StringifyMacro: ExpressionMacro {
+    public static func expansion(
+        of node: some FreestandingMacroExpansionSyntax,
+        in context: some MacroExpansionContext
+    ) -> ExprSyntax {
+        guard let argument = node.arguments.first?.expression else {
+            fatalError("compiler bug: the macro does not have any arguments")
+        }
+
+        return "(\(argument), \(literal: argument.description))"
+    }
+}
+
+@main
+struct MacrosDemoPlugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        StringifyMacro.self,
+    ]
+}

macro-sample/Tests/MacrosDemoTests/MacrosDemoTests.swift

@@ -0,0 +1,48 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import SwiftSyntaxMacrosTestSupport
+import XCTest
+
+// Macro implementations build for the host, so the corresponding module is not available when cross-compiling. Cross-compiled tests may still make use of the macro itself in end-to-end tests.
+#if canImport(MacrosDemoMacros)
+import MacrosDemoMacros
+
+let testMacros: [String: Macro.Type] = [
+    "stringify": StringifyMacro.self,
+]
+#endif
+
+final class MacrosDemoTests: XCTestCase {
+    func testMacro() throws {
+        #if canImport(MacrosDemoMacros)
+        assertMacroExpansion(
+            """
+            #stringify(a + b)
+            """,
+            expandedSource: """
+            (a + b, "a + b")
+            """,
+            macros: testMacros
+        )
+        #else
+        throw XCTSkip("macros are only supported when running tests for the host platform")
+        #endif
+    }
+
+    func testMacroWithStringLiteral() throws {
+        #if canImport(MacrosDemoMacros)
+        assertMacroExpansion(
+            #"""
+            #stringify("Hello, \(name)")
+            """#,
+            expandedSource: #"""
+            ("Hello, \(name)", #""Hello, \(name)""#)
+            """#,
+            macros: testMacros
+        )
+        #else
+        throw XCTSkip("macros are only supported when running tests for the host platform")
+        #endif
+    }
+}

macro-sample/run.sh

@@ -0,0 +1,2 @@
+#!/bin/sh -ex
+skip android test

testing-sample/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

testing-sample/Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version: 6.1
+import PackageDescription
+
+let package = Package(
+    name: "LibraryDemo",
+    products: [
+        .library(
+            name: "LibraryDemo",
+            targets: ["LibraryDemo"]
+        ),
+    ],
+    targets: [
+        .target(
+            name: "LibraryDemo"
+        ),
+        .testTarget(
+            name: "LibraryDemoTests",
+            dependencies: ["LibraryDemo"]
+        ),
+    ]
+)