Quality-of-life improvements (#153)

* wip

* wip

Author: stephencelis

Sources/CasePaths/Never+CasePathable.swift

@@ -5,7 +5,7 @@ extension Never: CasePathable {
   }
 }
 
-extension Case {
+extension Case where Value: CasePathable {
   /// A case path that can never embed or extract a value.
   ///
   /// This property can chain any case path into a `Never` value, which, as an uninhabited type,
@@ -15,3 +15,11 @@ extension Case {
     return Case<Never>(embed: absurd, extract: { (_: Value) in nil })
   }
 }
+
+extension Case {
+  @available(*, deprecated, message: "This enum must be '@CasePathable' to enable key path syntax")
+  public var never: Case<Never> {
+    func absurd<T>(_: Never) -> T {}
+    return Case<Never>(embed: absurd, extract: { (_: Value) in nil })
+  }
+}

Sources/CasePathsMacros/CasePathableMacro.swift

@@ -99,8 +99,8 @@ extension CasePathableMacro: MemberMacro {
     enumName: TokenSyntax
   ) -> [DeclSyntax] {
     elements.flatMap {
-      if let elements = $0.decl.as(EnumCaseDeclSyntax.self)?.elements {
-        return generateDeclSyntax(from: elements, enumName: enumName)
+      if let decl = $0.decl.as(EnumCaseDeclSyntax.self) {
+        return generateDeclSyntax(from: decl, enumName: enumName)
       }
       if let ifConfigDecl = $0.decl.as(IfConfigDeclSyntax.self) {
         let ifClauses = ifConfigDecl.clauses.flatMap { decl -> [DeclSyntax] in
@@ -118,10 +118,10 @@ extension CasePathableMacro: MemberMacro {
   }
 
   static func generateDeclSyntax(
-    from enumCaseDecls: EnumCaseElementListSyntax,
+    from decl: EnumCaseDeclSyntax,
     enumName: TokenSyntax
   ) -> [DeclSyntax] {
-    enumCaseDecls.map {
+    decl.elements.map {
       let caseName = $0.name.trimmed
       let associatedValueName = $0.trimmedTypeDescription
       let hasPayload = $0.parameterClause.map { !$0.parameters.isEmpty } ?? false
@@ -137,9 +137,18 @@ extension CasePathableMacro: MemberMacro {
         bindingNames = ""
         returnName = "()"
       }
-
+      let leadingTriviaLines = decl.leadingTrivia.description
+        .drop(while: \.isNewline)
+        .split(separator: "\n", omittingEmptySubsequences: false)
+      let indent = leadingTriviaLines
+        .compactMap { $0.isEmpty ? nil : $0.prefix(while: \.isWhitespace).count }
+        .min(by: { (lhs: Int, rhs: Int) -> Bool in lhs == 0 ? lhs > rhs : lhs < rhs })
+        ?? 0
+      let leadingTrivia = leadingTriviaLines
+        .map { String($0.dropFirst(indent)) }
+        .joined(separator: "\n")
       return """
-        public var \(caseName): \
+        \(raw: leadingTrivia)public var \(caseName): \
         \(raw: qualifiedCasePathTypeName)<\(enumName), \(raw: associatedValueName)> {
         \(raw: qualifiedCasePathTypeName)<\(enumName), \(raw: associatedValueName)>(
         embed: \(raw: hasPayload ? "\(enumName).\(caseName)" : "{ \(enumName).\(caseName) }"),

Tests/CasePaths copy.xctestplan

@@ -0,0 +1,18 @@
+{
+  "configurations" : [
+    {
+      "id" : "2400C241-35D6-4B6B-B6EA-A4105C2738D6",
+      "name" : "Configuration 1",
+      "options" : {
+
+      }
+    }
+  ],
+  "defaultOptions" : {
+
+  },
+  "testTargets" : [
+
+  ],
+  "version" : 1
+}

Tests/CasePathsMacrosTests/CasePathableMacroTests.swift

@@ -603,4 +603,122 @@ final class CasePathableMacroTests: XCTestCase {
       """
     }
   }
+
+  func testDocumentation() {
+    assertMacro {
+      """
+      @CasePathable
+      enum Foo {
+
+        /// The bar case.
+        case bar
+
+        /// The baz case.
+        ///
+        /// A case for baz.
+        case baz
+
+        /**
+         The fizz buzz case.
+
+         A case for fizz and buzz.
+         */
+        case fizz, buzz
+      }
+      """
+    } expansion: {
+      """
+      enum Foo {
+
+        /// The bar case.
+        case bar
+
+        /// The baz case.
+        ///
+        /// A case for baz.
+        case baz
+
+        /**
+         The fizz buzz case.
+
+         A case for fizz and buzz.
+         */
+        case fizz, buzz
+
+        public struct AllCasePaths {
+          /// The bar case.
+          public var bar: CasePaths.AnyCasePath<Foo, Void> {
+            CasePaths.AnyCasePath<Foo, Void>(
+              embed: {
+                Foo.bar
+              },
+              extract: {
+                guard case .bar = $0 else {
+                  return nil
+                }
+                return ()
+              }
+            )
+          }
+          /// The baz case.
+          ///
+          /// A case for baz.
+          public var baz: CasePaths.AnyCasePath<Foo, Void> {
+            CasePaths.AnyCasePath<Foo, Void>(
+              embed: {
+                Foo.baz
+              },
+              extract: {
+                guard case .baz = $0 else {
+                  return nil
+                }
+                return ()
+              }
+            )
+          }
+          /**
+         The fizz buzz case.
+
+         A case for fizz and buzz.
+         */
+          public var fizz: CasePaths.AnyCasePath<Foo, Void> {
+            CasePaths.AnyCasePath<Foo, Void>(
+              embed: {
+                Foo.fizz
+              },
+              extract: {
+                guard case .fizz = $0 else {
+                  return nil
+                }
+                return ()
+              }
+            )
+          }
+          /**
+         The fizz buzz case.
+
+         A case for fizz and buzz.
+         */
+          public var buzz: CasePaths.AnyCasePath<Foo, Void> {
+            CasePaths.AnyCasePath<Foo, Void>(
+              embed: {
+                Foo.buzz
+              },
+              extract: {
+                guard case .buzz = $0 else {
+                  return nil
+                }
+                return ()
+              }
+            )
+          }
+        }
+        public static var allCasePaths: AllCasePaths { AllCasePaths() }
+      }
+
+      extension Foo: CasePaths.CasePathable {
+      }
+      """
+    }
+  }
 }