Add capability to convert computed property to stored property

Author: antigluten

Sources/SwiftRefactor/CMakeLists.txt

@@ -9,6 +9,7 @@
 add_swift_syntax_library(SwiftRefactor
   AddSeparatorsToIntegerLiteral.swift
   CallToTrailingClosures.swift
+  ConvertComputedPropertyToStored.swift
   ConvertStoredPropertyToComputed.swift
   ExpandEditorPlaceholder.swift
   FormatRawStringLiteral.swift

Sources/SwiftRefactor/ConvertComputedPropertyToStored.swift

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if swift(>=6)
+public import SwiftSyntax
+#else
+import SwiftSyntax
+#endif
+
+public struct ConvertComputedPropertyToStored: SyntaxRefactoringProvider {
+  public static func refactor(syntax: VariableDeclSyntax, in context: ()) -> VariableDeclSyntax? {
+    guard syntax.bindings.count == 1, let binding = syntax.bindings.first,
+      let accessorBlock = binding.accessorBlock, case let .getter(body) = accessorBlock.accessors, !body.isEmpty
+    else {
+      return nil
+    }
+
+    var initializer: InitializerClauseSyntax?
+
+    if body.count > 1 {
+      let closure = ClosureExprSyntax(
+        statements: body.with(\.trailingTrivia, .newline)
+      )
+
+      initializer = InitializerClauseSyntax(
+        value: FunctionCallExprSyntax(
+          leadingTrivia: .space,
+          callee: closure
+        )
+      )
+    } else if let item = body.first?.item.as(ExprSyntax.self) {
+      initializer = InitializerClauseSyntax(
+        value: item.with(\.leadingTrivia, .space).with(\.trailingTrivia, Trivia())
+      )
+    }
+
+    guard let initializer else { return nil }
+
+    let newBinding =
+      binding
+      .with(\.initializer, initializer)
+      .with(\.accessorBlock, nil)
+
+    let bindingSpecifier = syntax.bindingSpecifier
+      .with(\.tokenKind, .keyword(.let))
+
+    return
+      syntax
+      .with(\.bindingSpecifier, bindingSpecifier)
+      .with(\.bindings, PatternBindingListSyntax([newBinding]))
+  }
+}
+
+fileprivate extension FunctionCallExprSyntax {
+
+  init(
+    leadingTrivia: Trivia? = nil,
+    callee: some ExprSyntaxProtocol,
+    argumentList: () -> LabeledExprListSyntax = { [] },
+    trailingTrivia: Trivia? = nil
+  ) {
+    let argumentList = argumentList()
+    self.init(
+      leadingTrivia: leadingTrivia,
+      calledExpression: callee,
+      leftParen: .leftParenToken(),
+      arguments: argumentList,
+      rightParen: .rightParenToken(),
+      trailingTrivia: trailingTrivia
+    )
+  }
+}

Sources/SwiftRefactor/ConvertStoredPropertyToComputed.swift

@@ -17,28 +17,29 @@ import SwiftSyntax
 #endif
 
 public struct ConvertStoredPropertyToComputed: SyntaxRefactoringProvider {
-  
   public static func refactor(syntax: VariableDeclSyntax, in context: ()) -> VariableDeclSyntax? {
     guard syntax.bindings.count == 1, let binding = syntax.bindings.first, let initializer = binding.initializer else {
       return nil
     }
-    
+
     let body = CodeBlockItemSyntax(
       item: .expr(initializer.value)
     )
-    
-    let newBinding = binding
+
+    let newBinding =
+      binding
       .with(\.initializer, nil)
       .with(
         \.accessorBlock,
-         AccessorBlockSyntax(
+        AccessorBlockSyntax(
           leftBrace: .leftBraceToken(trailingTrivia: .space),
           accessors: .getter(CodeBlockItemListSyntax([body])),
           rightBrace: .rightBraceToken(leadingTrivia: .space)
-         )
+        )
       )
-    
-    return syntax
+
+    return
+      syntax
       .with(\.bindingSpecifier, .keyword(.var, trailingTrivia: .space))
       .with(\.bindings, PatternBindingListSyntax([newBinding]))
   }

Tests/SwiftRefactorTest/ConvertComputedPropertyToStoredTest.swift

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SwiftRefactor
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import XCTest
+import _SwiftSyntaxTestSupport
+
+final class ConvertComputedPropertyToStoredTest: XCTestCase {
+  func testToStored() throws {
+    let baseline: DeclSyntax = """
+      var defaultColor: Color { Color() }
+      """
+
+    let expected: DeclSyntax = """
+      let defaultColor: Color = Color()
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testToStoredWithMultipleStatementsInAccessor() throws {
+    let baseline: DeclSyntax = """
+      var defaultColor: Color {
+        let color = Color()
+        return color
+      }
+      """
+
+    let expected: DeclSyntax = """
+      let defaultColor: Color = {
+        let color = Color()
+        return color
+      }()
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+}
+
+fileprivate func assertRefactorConvert(
+  _ callDecl: DeclSyntax,
+  expected: DeclSyntax?,
+  file: StaticString = #filePath,
+  line: UInt = #line
+) throws {
+  try assertRefactor(
+    callDecl,
+    context: (),
+    provider: ConvertComputedPropertyToStored.self,
+    expected: expected,
+    file: file,
+    line: line
+  )
+}

Tests/SwiftRefactorTest/ConvertStoredPropertyToComputed.swift renamed to Tests/SwiftRefactorTest/ConvertStoredPropertyToComputedTest.swift

@@ -17,52 +17,51 @@ import XCTest
 import _SwiftSyntaxTestSupport
 
 final class ConvertStoredPropertyToComputedTest: XCTestCase {
-  
   func testRefactoringStoredPropertyWithInitializer1() throws {
     let baseline: DeclSyntax = """
       static let defaultColor: Color = .red
       """
-    
+
     let expected: DeclSyntax = """
       static var defaultColor: Color { .red }
       """
-    
+
     try assertRefactorConvert(baseline, expected: expected)
   }
-  
+
   func testRefactoringStoredPropertyWithInitializer2() throws {
     let baseline: DeclSyntax = """
       static let defaultColor: Color = Color.red
       """
-    
+
     let expected: DeclSyntax = """
       static var defaultColor: Color { Color.red }
       """
-    
+
     try assertRefactorConvert(baseline, expected: expected)
   }
-  
+
   func testRefactoringStoredPropertyWithInitializer3() throws {
     let baseline: DeclSyntax = """
       var defaultColor: Color = Color.red
       """
-    
+
     let expected: DeclSyntax = """
       var defaultColor: Color { Color.red }
       """
-    
+
     try assertRefactorConvert(baseline, expected: expected)
   }
-  
+
   func testRefactoringStoredPropertyWithInitializer4() throws {
     let baseline: DeclSyntax = """
       var defaultColor: Color = Color()
       """
-    
+
     let expected: DeclSyntax = """
       var defaultColor: Color { Color() }
       """
-    
+
     try assertRefactorConvert(baseline, expected: expected)
   }
 }