Add a syntactic "Add Codable structs from JSON" code action

Add a syntactic action that takes JSON pasted into a Swift file or
placed in a string literal, then turns it into a set of Codable
structs that can represent the JSON. Our typical example starts like
this:

```
{
    "name": "Produce",
    "shelves": [
        {
            "name": "Discount Produce",
            "product": {
                "name": "Banana",
                "points": 200,
                "description": "A banana that's perfectly ripe."
            }
        }
    ]
}
```

and turns into this:

```swift
struct JSONValue: Codable {
    var name: String
    var shelves: [Shelves]

    struct Shelves: Codable {
        var name: String
        var product: Product

        struct Product: Codable {
            var description: String
            var name: String
            var points: Double
        }
    }
}
```

This code action can definitely be improved by doing more work in
analyzing the JSON to (for example) abstract over multiple elements in
an array to make fields optional (if they only show up in some
members) and perhaps even identify when we really have something
that's an enum. Such improvements can be done without changing the
general shape of this refactor.

The refactoring itself would live down in the swift-syntax package if
not for its dependency on Foundation. We'll move as appropriate.

Author: DougGregor

Sources/SourceKitLSP/CMakeLists.txt

@@ -23,6 +23,7 @@ target_sources(SourceKitLSP PRIVATE
 target_sources(SourceKitLSP PRIVATE
   Swift/AdjustPositionToStartOfIdentifier.swift
   Swift/CodeActions/ConvertIntegerLiteral.swift
+  Swift/CodeActions/ConvertJSONToCodableStruct.swift
   Swift/CodeActions/SyntaxCodeActionProvider.swift
   Swift/CodeActions/SyntaxCodeActions.swift
   Swift/CodeActions/SyntaxRefactoringCodeActionProvider.swift

Sources/SourceKitLSP/Swift/CodeActions/ConvertJSONToCodableStruct.swift

@@ -0,0 +1,316 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+import LanguageServerProtocol
+import SwiftRefactor
+import SwiftSyntax
+
+/// Convert JSON literals into corresponding Swift structs that conform to the
+/// `Codable` protocol.
+///
+/// ## Before
+///
+/// ```javascript
+/// {
+///     "name": "Produce",
+///     "shelves": [
+///         {
+///             "name": "Discount Produce",
+///             "product": {
+///                 "name": "Banana",
+///                 "points": 200,
+///                 "description": "A banana that's perfectly ripe."
+///             }
+///         }
+///     ]
+/// }
+/// ```
+///
+/// ## After
+///
+/// ```swift
+/// struct JSONValue: Codable {
+///   var name: String
+///   var shelves: [Shelves]
+///
+///   struct Shelves: Codable {
+///     var name: String
+///     var product: Product
+///
+///     struct Product: Codable {
+///       var description: String
+///       var name: String
+///       var points: Double
+///     }
+///   }
+/// }
+/// ```
+struct ConvertJSONToCodableStruct: EditRefactoringProvider {
+  static func textRefactor(
+    syntax: Syntax,
+    in context: Void
+  ) -> [SourceEdit] {
+    // Dig out a syntax node that looks like it might be JSON or have JSON
+    // in it.
+    guard let preflight = preflightRefactoring(syntax) else {
+      return []
+    }
+
+    // Dig out the text that we think might be JSON.
+    let text: String
+    switch preflight {
+    case let .closure(closure):
+      text = closure.trimmedDescription
+    case let .tail(closure, unexpected):
+      text = closure.trimmedDescription + unexpected.description
+    case .stringLiteral(_, let literalText):
+      text = literalText
+    }
+
+    // Try to process this as JSON.
+    guard
+      let object = try? JSONSerialization.jsonObject(with: text.data(using: .utf8)!),
+      let serial = object as? Dictionary<String, Any>
+    else {
+      return []
+    }
+
+    // Build the declarations from the JSON dictionary.
+    let decls = build(from: serial)
+
+    // Render the change into
+    switch preflight {
+    case .closure(let closure):
+      return [
+        SourceEdit(range: closure.trimmedRange, replacement: decls.description)
+      ]
+    case .tail(let closure, let unexpected):
+      return [
+        SourceEdit(range: closure.trimmedRange, replacement: decls.description),
+        SourceEdit(range: unexpected.range, replacement: ""),
+      ]
+    case .stringLiteral(let literal, _):
+      return [
+        SourceEdit(
+          range: literal.endPosition..<literal.endPosition,
+          replacement: "\n" + decls.description
+        )
+      ]
+    }
+  }
+}
+
+extension ConvertJSONToCodableStruct {
+  /// The result of preflighting a syntax node to try to find potential JSON
+  /// in it.
+  public enum Preflight {
+    /// A closure, which is what a JSON dictionary looks like when pasted
+    /// into Swift.
+    case closure(ClosureExprSyntax)
+
+    /// A closure at the end of a source file, which might have extra JSON.
+    case tail(ClosureExprSyntax, UnexpectedNodesSyntax)
+
+    /// A string literal that may contain JSON.
+    case stringLiteral(StringLiteralExprSyntax, String)
+  }
+
+  /// Look for either a closure or a string literal that might have JSON in it.
+  public static func preflightRefactoring(_ syntax: Syntax) -> Preflight? {
+    // Preflight a closure.
+    //
+    // A blob of JSON dropped into a Swift source file will look like a
+    // closure due to the curly braces. The internals might be a syntactic
+    // disaster, but we don't actually care.
+    if let closure = syntax.as(ClosureExprSyntax.self) {
+      if let file = closure.parent?.parent?.parent?.as(SourceFileSyntax.self),
+        let unexpected = file.unexpectedBetweenStatementsAndEndOfFileToken
+      {
+        return .tail(closure, unexpected)
+      }
+
+      return .closure(closure)
+    }
+
+    // We found a string literal; its contents might be JSON.
+    if let stringLit = syntax.as(StringLiteralExprSyntax.self) {
+      guard let text = stringLit.representedLiteralValue else {
+        return nil
+      }
+
+      return .stringLiteral(stringLit, text)
+    }
+
+    // Look further up the syntax tree.
+    if let parent = syntax.parent {
+      return preflightRefactoring(parent)
+    }
+
+    return nil
+  }
+}
+
+extension ConvertJSONToCodableStruct: SyntaxRefactoringCodeActionProvider {
+  static var title = "Create Codable structs from JSON"
+}
+
+extension ConvertJSONToCodableStruct {
+  fileprivate static let indentation = 4
+
+  private static func build(from jsonDictionary: Dictionary<String, Any>) -> DeclSyntax {
+    return
+      """
+      \(raw: self.buildStruct(from: jsonDictionary))
+      """
+  }
+
+  private static func buildStruct(
+    named name: String = "JSONValue",
+    at depth: Int = 0,
+    from jsonDictionary: Dictionary<String, Any>
+  ) -> String {
+    let members = self.buildStructMembers(at: depth + 1, from: jsonDictionary)
+    return
+      """
+      \(String(repeating: " ", count: depth * indentation))struct \(name): Codable {
+      \(members.joined(separator: "\n"))
+      \(String(repeating: " ", count: depth * indentation))}
+      """
+  }
+
+  private static func buildStructMembers(
+    at depth: Int,
+    from jsonDictionary: Dictionary<String, Any>
+  ) -> [String] {
+    var members: [String] = []
+
+    var uniquer: Set<String> = []
+    var nestedTypes: [(String, Dictionary<String, Any>)] = []
+    func addNestedType(_ name: String, object: Dictionary<String, Any>) {
+      guard uniquer.insert(name).inserted else {
+        return
+      }
+      nestedTypes.append((name, object))
+    }
+
+    for key in jsonDictionary.keys.sorted() {
+      guard let value = jsonDictionary[key] else {
+        continue
+      }
+
+      let type = self.jsonType(of: value, suggestion: key)
+      if case let .object(name) = type, let subObject = value as? Dictionary<String, Any> {
+        addNestedType(name, object: subObject)
+      } else if case let .array(innerType) = type,
+        let array = value as? [Any],
+        let (nesting, elementType) = innerType.outermostObject
+      {
+        if let subObject = array.unwrap(nesting) {
+          addNestedType(elementType, object: subObject)
+        }
+      }
+
+      let member = "\(String(repeating: " ", count: depth * indentation))var \(key): \(type.stringValue)"
+      members.append(member)
+    }
+
+    if !nestedTypes.isEmpty {
+      members.append("")
+      for (name, nestedType) in nestedTypes {
+        members.append(self.buildStruct(named: name, at: depth, from: nestedType))
+      }
+    }
+    return members
+  }
+
+  indirect enum JSONType {
+    case string
+    case double
+    case array(JSONType)
+    case null
+    case object(String)
+
+    var outermostObject: (Int, String)? {
+      var unwraps = 1
+      var value = self
+      while case let .array(inner) = value {
+        value = inner
+        unwraps += 1
+      }
+
+      if case let .object(typeName) = value {
+        return (unwraps, typeName)
+      } else {
+        return nil
+      }
+    }
+
+    var stringValue: String {
+      switch self {
+      case .string:
+        return "String"
+      case .double:
+        return "Double"
+      case .array(let ty):
+        return "[\(ty.stringValue)]"
+      case .null:
+        return "Void?"
+      case let .object(name):
+        return name
+      }
+    }
+  }
+
+  private static func jsonType(of value: Any, suggestion name: String) -> JSONType {
+    switch Swift.type(of: value) {
+    case is NSString.Type:
+      return .string
+    case is NSNumber.Type:
+      return .double
+    case is NSArray.Type:
+      guard let firstValue = (value as! [Any]).first else {
+        return .array(.null)
+      }
+      let innerType = self.jsonType(of: firstValue, suggestion: name)
+      return .array(innerType)
+    case is NSNull.Type:
+      return .null
+    case is NSDictionary.Type:
+      return .object(name.capitalized)
+    default:
+      return .string
+    }
+  }
+}
+
+extension Array where Element == Any {
+  fileprivate func unwrap(_ depth: Int) -> Dictionary<String, Any>? {
+    var values: [Any] = self
+    for i in 0..<depth {
+      if values.isEmpty {
+        return nil
+      }
+
+      if i + 1 == depth {
+        return values[0] as? Dictionary<String, Any>
+      }
+
+      guard let moreValues = values[0] as? [Any] else {
+        return nil
+      }
+
+      values = moreValues
+    }
+    return nil
+  }
+}

Sources/SourceKitLSP/Swift/CodeActions/SyntaxCodeActions.swift

@@ -17,6 +17,7 @@ import SwiftRefactor
 let allSyntaxCodeActions: [SyntaxCodeActionProvider.Type] = [
   AddSeparatorsToIntegerLiteral.self,
   ConvertIntegerLiteral.self,
+  ConvertJSONToCodableStruct.self,
   FormatRawStringLiteral.self,
   MigrateToNewIfLetSyntax.self,
   OpaqueParameterToGeneric.self,

Tests/SourceKitLSPTests/CodeActionTests.swift

@@ -292,6 +292,48 @@ final class CodeActionTests: XCTestCase {
     XCTAssertTrue(codeActions.contains(expectedCodeAction))
   }
 
+  func testJSONCodableCodeActionResult() async throws {
+    let testClient = try await TestSourceKitLSPClient(capabilities: clientCapabilitiesWithCodeActionSupport())
+    let uri = DocumentURI.for(.swift)
+    let positions = testClient.openDocument(
+      """
+         1️⃣{
+         "name": "Produce",
+         "shelves": [
+             {
+                 "name": "Discount Produce",
+                 "product": {
+                     "name": "Banana",
+                     "points": 200,
+                     "description": "A banana that's perfectly ripe."
+                 }
+             }
+         ]
+      }
+      """,
+      uri: uri
+    )
+
+    let testPosition = positions["1️⃣"]
+    let request = CodeActionRequest(
+      range: Range(testPosition),
+      context: .init(),
+      textDocument: TextDocumentIdentifier(uri)
+    )
+    let result = try await testClient.send(request)
+
+    guard case .codeActions(let codeActions) = result else {
+      XCTFail("Expected code actions")
+      return
+    }
+
+    // Make sure we get a JSON conversion action.
+    let codableAction = codeActions.first { action in
+      return action.title == "Create Codable structs from JSON"
+    }
+    XCTAssertNotNil(codableAction)
+  }
+
   func testSemanticRefactorRangeCodeActionResult() async throws {
     let testClient = try await TestSourceKitLSPClient(capabilities: clientCapabilitiesWithCodeActionSupport())
     let uri = DocumentURI.for(.swift)