Initial commit

Author: fruitcoder

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,14 @@
+{
+  "pins" : [
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-syntax.git",
+      "state" : {
+        "revision" : "165fc6d22394c1168ff76ab5d951245971ef07e5",
+        "version" : "509.0.0-swift-DEVELOPMENT-SNAPSHOT-2023-06-05-a"
+      }
+    }
+  ],
+  "version" : 2
+}

Package.resolved

@@ -0,0 +1,52 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+import CompilerPluginSupport
+
+let package = Package(
+  name: "ExtractCaseValue",
+  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: "ExtractCaseValue",
+      targets: ["ExtractCaseValue"]
+    ),
+    .executable(
+      name: "ExtractCaseValueClient",
+      targets: ["ExtractCaseValueClient"]
+    ),
+  ],
+  dependencies: [
+    // Depend on the latest Swift 5.9 prerelease of SwiftSyntax
+    .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0-swift-5.9-DEVELOPMENT-SNAPSHOT-2023-04-25-b"),
+  ],
+  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: "ExtractCaseValueMacros",
+      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: "ExtractCaseValue", dependencies: ["ExtractCaseValueMacros"]),
+
+    // A client of the library, which is able to use the macro in its own code.
+    .executableTarget(name: "ExtractCaseValueClient", dependencies: ["ExtractCaseValue"]),
+
+    // A test target used to develop the macro implementation.
+    .testTarget(
+      name: "ExtractCaseValueTests",
+      dependencies: [
+        "ExtractCaseValueMacros",
+        .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
+      ]
+    ),
+  ]
+)

Package.swift

@@ -0,0 +1,43 @@
+# ExtractCaseValue
+
+The `ExtractCaseValue` package provides a macro to expose assiocated values from enum cases as a computed property. 
+
+@Metadata {
+  @PageColor(blue)
+}
+
+## Overview
+
+@Row {
+  @Column {
+    To extract a simple value annotate an enum with the `ExtractCaseValue` macro and provide the expected type as a generic along with a name for the comuted property. This will use the `firstMatchingType` as a default to use the first associated value in a case that matches the expected type (in this case `String`).
+  }
+  @Column {
+    ![Screenshot of Xcode showing the marco expansion on a Path enum with a String as return type](sample-one)
+  }
+}
+
+@Row {
+  @Column {
+    If the return type is optional the macro will infer `nil` as the default value.
+  }
+  @Column {
+    ![Screenshot of Xcode showing the marco expansion on a JSON enum with an optional String as return type](sample-two)
+  }
+}
+  
+@Row {
+  @Column {
+    ![Screenshot of Xcode showing the fix-it](fix-it)		
+  }
+  @Column {
+    Otherwise, you will get a fix-it that recommends to use a default value.	
+  }
+}
+    
+@Row {
+  @Column {
+    You can also add mutliple `ExtractCaseValue` macros.
+    ![Screenshot of Xcode showing the marco expansion on a Coordinate enum which uses multiple macros](sample-three)
+  }
+}

Sources/Documentation.docc/Documentation.md

@@ -0,0 +1,67 @@
+import ExtractCaseValueMacros
+
+/// A macro that extracts an associated value from enum cases using a default value if
+/// extraction is not possible.
+///
+/// For exampleDiesr codu
+///
+/// ```swift
+/// @ExtractCaseValue<String>(name: "path", kind: CaseExtractionKind.position(0), defaultValue: "")
+/// enum Path {
+///   case relative(String)
+///   case absolute(String)
+///   case root
+/// }
+/// ```
+/// produces
+///
+/// ```swift
+/// enum Path {
+///   case relative(String)
+///   case absolute(String)
+///   case root
+///   var path: String {
+///     switch self {
+///     case let .relative(__macro_local_4pathfMu_):
+///       return __macro_local_4pathfMu_
+///     case let .absolute(__macro_local_4pathfMu0_):
+///       return __macro_local_4pathfMu0_
+///     case .root:
+///       return ""
+///     }
+///   }
+/// }
+/// ```
+@attached(member, names: arbitrary)
+public macro ExtractCaseValue<T>(name: String, kind: CaseExtractionKind = .default, defaultValue: T) = #externalMacro(module: "ExtractCaseValueMacros", type: "ExtractCaseValueMacro")
+
+/// A macro that extracts an associated value from enum cases.
+///
+/// For example
+///
+/// ```swift
+/// @ExtractCaseValue<String>(name: "path", kind: CaseExtractionKind.position(0))
+/// enum Path {
+///   case relative(String)
+///   case absolute(String)
+/// }
+/// ```
+/// produces
+///
+/// ```swift
+/// enum Path {
+///   case relative(String)
+///   case absolute(String)
+///   case root
+///   var path: String {
+///     switch self {
+///     case let .relative(__macro_local_4pathfMu_):
+///       return __macro_local_4pathfMu_
+///     case let .absolute(__macro_local_4pathfMu0_):
+///       return __macro_local_4pathfMu0_
+///     }
+///   }
+/// }
+/// ```
+@attached(member, names: arbitrary)
+public macro ExtractCaseValue<T>(name: String, kind: CaseExtractionKind = .default) = #externalMacro(module: "ExtractCaseValueMacros", type: "ExtractCaseValueMacro")

Sources/Documentation.docc/Resources/[email protected]

@@ -0,0 +1,25 @@
+import ExtractCaseValue
+
+@ExtractCaseValue<Double>(name: "x", kind: .associatedValueName("x"))
+@ExtractCaseValue<Double>(name: "y", kind: .associatedValueName("y"))
+@ExtractCaseValue<Double?>(name: "z", kind: .associatedValueName("z"), defaultValue: nil)
+enum Coordinate {
+  case twoDee(x: Double, y: Double)
+  case threeDee(x: Double, y: Double, z: Double)
+}
+
+@ExtractCaseValue<String?>(name: "string", kind: .firstMatchingType)
+enum JSON {
+  case string(String)
+  case number(Double)
+  case object([String: JSON])
+  case array([JSON])
+  case bool(Bool)
+  case null
+}
+
+@ExtractCaseValue<String>(name: "path")
+enum Path {
+  case absolute(String)
+  case relative(String)
+}

Sources/Documentation.docc/Resources/[email protected]

@@ -0,0 +1,40 @@
+import SwiftSyntax
+
+/// The available kinds of case value extractions.
+public enum CaseExtractionKind {
+  /// Extract a value at a position in the associated values.
+  case position(Int)
+
+  /// Extract a value with a certain name.
+  case associatedValueName(String)
+
+  /// Extract the first value with a matching type.
+  case firstMatchingType
+
+  public static let `default` = Self.firstMatchingType
+}
+
+extension CaseExtractionKind {
+  init?(expr: ExprSyntax) {
+    guard
+      let functionCall = expr.as(FunctionCallExprSyntax.self),
+      let memberAccessExpr = functionCall.calledExpression.as(MemberAccessExprSyntax.self)
+    else { return nil }
+
+    let firstIntArgument = (functionCall.argumentList.first?.expression.as(IntegerLiteralExprSyntax.self)?.digits.text).flatMap(Int.init)
+    let firstStringArgument = functionCall.argumentList.first?.expression.stringLiteralSegment
+
+    switch memberAccessExpr.name.text {
+    case "position" :
+      guard let position = firstIntArgument else { return nil }
+      self = .position(position)
+    case "associatedValueName":
+      guard let name = firstStringArgument?.content.text else { return nil }
+      self = .associatedValueName(name)
+    case "firstMatchingType":
+      self = .firstMatchingType
+    default:
+      return nil
+    }
+  }
+}

Sources/Documentation.docc/Resources/[email protected]

@@ -0,0 +1,76 @@
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+enum ExtractCaseValueMacroDiagnostic {
+  case requiresEnum
+  case requiresArgs
+  case requiresPropertyNameArg
+  case requiresPropertyNameStringLiteral
+  case requiresGenericType
+  case noValue(case: String, index: Int)
+  case noMatchingType(type: String, case: String)
+  case noAssociatedValues(case: String)
+  case noAssociatedValueForName(name: String, case: String)
+  case typeMismatch(case: String, index: Int)
+  case typeMismatchNamed(name: String, case: String)
+}
+
+extension ExtractCaseValueMacroDiagnostic: DiagnosticMessage {
+  func diagnose(at node: some SyntaxProtocol, fixIts: [FixIt] = []) -> Diagnostic {
+    Diagnostic(node: Syntax(node), message: self, fixIts: fixIts)
+  }
+
+  var message: String {
+    switch self {
+    case .requiresEnum:
+      return "'ExtractCaseValue' macro can only be applied to an enum"
+
+    case .requiresArgs:
+      return "'ExtractCaseValue' macro requires arguments"
+
+    case .requiresPropertyNameArg:
+      return "'ExtractCaseValue' macro requires `\(caseParamExtractionPropertyNameArgumentLabel)` argument"
+
+    case .requiresPropertyNameStringLiteral:
+      return "'ExtractCaseValue' macro argument `\(caseParamExtractionPropertyNameArgumentLabel)` must be a string literal"
+
+    case .requiresGenericType:
+      return "'ExtractCaseValue' macro requires a generic type for the computed property"
+
+    case let .noValue(caseName, index):
+      return "'ExtractCaseValue' macro could not find an associated value for `\(caseName)` at index \(index). Consider using a default value."
+
+    case let .noMatchingType(type, caseName):
+      return "'ExtractCaseValue' macro found no associated value of type \(type) in `\(caseName)`. Consider using a default value."
+
+    case let .noAssociatedValues(caseName):
+      return "'ExtractCaseValue' macro could not find associated values for `\(caseName)`. Consider using a default value."
+
+    case let .noAssociatedValueForName(name, caseName):
+      return "'ExtractCaseValue' macro found no associated value named \(name) in `\(caseName)`. Consider using a default value."
+
+    case let .typeMismatch(caseName, index):
+      return "'ExtractCaseValue' macro found a mismatching type for `\(caseName)` at index \(index)"
+
+    case let .typeMismatchNamed(paramName, caseName):
+      return "'ExtractCaseValue' macro found a mismatching type for \(paramName) in the `\(caseName)` case"
+    }
+  }
+
+  var severity: DiagnosticSeverity { .error }
+
+  var diagnosticID: MessageID {
+    MessageID(domain: "Swift", id: "ExtractCaseValue.\(self)")
+  }
+}
+
+struct InsertDefaultValueItMessage: FixItMessage {
+  var message: String {
+    "Insert default value"
+  }
+
+  var fixItID: MessageID {
+    MessageID(domain: "Swift", id: "ExtractCaseValue.\(self)")
+  }
+}