Add DeclModifierRemover for ConvertStoredPropertyToComputed and new tests

Author: myaumura

Sources/SwiftRefactor/CMakeLists.txt

@@ -14,6 +14,7 @@ add_swift_syntax_library(SwiftRefactor
   ConvertComputedPropertyToZeroParameterFunction.swift
   ConvertStoredPropertyToComputed.swift
   ConvertZeroParameterFunctionToComputedProperty.swift
+  DeclModifierRemover.swift
   ExpandEditorPlaceholder.swift
   FormatRawStringLiteral.swift
   IntegerLiteralUtilities.swift

Sources/SwiftRefactor/ConvertStoredPropertyToComputed.swift

@@ -22,6 +22,14 @@ public struct ConvertStoredPropertyToComputed: SyntaxRefactoringProvider {
       throw RefactoringNotApplicableError("unsupported variable declaration")
     }
 
+    var syntax = syntax
+
+    if let lazyKeyword = syntax.modifiers.first(where: { $0.name.tokenKind == .keyword(.lazy) }) {
+      syntax = DeclModifierRemover { $0.id == lazyKeyword.id }
+        .rewrite(syntax)
+        .cast(VariableDeclSyntax.self)
+    }
+
     var codeBlockSyntax: CodeBlockItemListSyntax
 
     if let functionExpression = initializer.value.as(FunctionCallExprSyntax.self),

Sources/SwiftRefactor/DeclModifierRemover.swift

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2026 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
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(RawSyntax) import SwiftSyntax
+
+final class DeclModifierRemover: SyntaxRewriter {
+  private let predicate: (DeclModifierSyntax) -> Bool
+
+  private var triviaToAttachToNextToken: Trivia = Trivia()
+
+  /// Initializes a modifier remover with a given predicate to determine which modifiers to remove.
+  ///
+  /// - Parameter predicate: A closure that determines whether a given `AttributeSyntax` should be removed.
+  ///   If this closure returns `true` for an attribute, that attribute will be removed.
+  public init(removingWhere predicate: @escaping (DeclModifierSyntax) -> Bool) {
+    self.predicate = predicate
+    super.init()
+  }
+
+  public override func visit(_ node: DeclModifierListSyntax) -> DeclModifierListSyntax {
+    var filteredModifiers: [DeclModifierListSyntax.Element] = []
+
+    for modifier in node {
+      guard self.predicate(modifier) else {
+        filteredModifiers.append(prependAndClearAccumulatedTrivia(to: modifier))
+        continue
+      }
+
+      // Removing modifier before comment leaves space before comment intact — doesn’t merge with following trivia.
+      let trailingTrivia = modifier.trailingTrivia.trimmingPrefix(while: \.isSpaceOrTab)
+      triviaToAttachToNextToken += modifier.leadingTrivia.merging(trailingTrivia)
+    }
+
+    if !triviaToAttachToNextToken.isEmpty, !filteredModifiers.isEmpty {
+      filteredModifiers[filteredModifiers.count - 1].trailingTrivia = filteredModifiers[filteredModifiers.count - 1]
+        .trailingTrivia
+        .merging(triviaToAttachToNextToken)
+      triviaToAttachToNextToken = Trivia()
+    }
+
+    return DeclModifierListSyntax(filteredModifiers)
+  }
+
+  public override func visit(_ token: TokenSyntax) -> TokenSyntax {
+    return prependAndClearAccumulatedTrivia(to: token)
+  }
+
+  /// Prepends the accumulated trivia to the given node's leading trivia.
+  ///
+  /// To preserve correct formatting after attribute removal, this function reassigns
+  /// significant trivia accumulated from removed attributes to the provided subsequent node.
+  /// Once attached, the accumulated trivia is cleared.
+  ///
+  /// - Parameter node: The syntax node receiving the accumulated trivia.
+  /// - Returns: The modified syntax node with the prepended trivia.
+  private func prependAndClearAccumulatedTrivia<T: SyntaxProtocol>(to syntaxNode: T) -> T {
+    guard !triviaToAttachToNextToken.isEmpty else { return syntaxNode }
+    defer { triviaToAttachToNextToken = Trivia() }
+    return syntaxNode.with(\.leadingTrivia, triviaToAttachToNextToken.merging(syntaxNode.leadingTrivia))
+  }
+}

Sources/SwiftSyntax/Trivia.swift

@@ -215,3 +215,27 @@ extension RawTriviaPiece: CustomDebugStringConvertible {
     TriviaPiece(raw: self).debugDescription
   }
 }
+
+@_spi(RawSyntax)
+public extension Trivia {
+  func trimmingPrefix(
+    while predicate: (TriviaPiece) -> Bool
+  ) -> Trivia {
+    Trivia(pieces: self.drop(while: predicate))
+  }
+
+  func trimmingSuffix(
+    while predicate: (TriviaPiece) -> Bool
+  ) -> Trivia {
+    Trivia(
+      pieces: self[...]
+        .reversed()
+        .drop(while: predicate)
+        .reversed()
+    )
+  }
+
+  var startsWithNewline: Bool {
+    self.first?.isNewline ?? false
+  }
+}

Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift

@@ -14,14 +14,14 @@
 internal import SwiftDiagnostics
 internal import SwiftOperators
 @_spi(MacroExpansion) internal import SwiftParser
-public import SwiftSyntax
+@_spi(RawSyntax) public import SwiftSyntax
 internal import SwiftSyntaxBuilder
 @_spi(MacroExpansion) @_spi(ExperimentalLanguageFeature) public import SwiftSyntaxMacros
 #else
 import SwiftDiagnostics
 import SwiftOperators
 @_spi(MacroExpansion) import SwiftParser
-import SwiftSyntax
+@_spi(RawSyntax) import SwiftSyntax
 import SwiftSyntaxBuilder
 @_spi(MacroExpansion) @_spi(ExperimentalLanguageFeature) import SwiftSyntaxMacros
 #endif
@@ -533,6 +533,7 @@ public class AttributeRemover: SyntaxRewriter {
   ///   If this closure returns `true` for an attribute, that attribute will be removed.
   public init(removingWhere predicate: @escaping (AttributeSyntax) -> Bool) {
     self.predicate = predicate
+    super.init()
   }
 
   public override func visit(_ node: AttributeListSyntax) -> AttributeListSyntax {
@@ -611,34 +612,12 @@ public class AttributeRemover: SyntaxRewriter {
   /// - Parameter node: The syntax node receiving the accumulated trivia.
   /// - Returns: The modified syntax node with the prepended trivia.
   private func prependAndClearAccumulatedTrivia<T: SyntaxProtocol>(to syntaxNode: T) -> T {
+    guard !triviaToAttachToNextToken.isEmpty else { return syntaxNode }
     defer { triviaToAttachToNextToken = Trivia() }
     return syntaxNode.with(\.leadingTrivia, triviaToAttachToNextToken + syntaxNode.leadingTrivia)
   }
 }
 
-private extension Trivia {
-  func trimmingPrefix(
-    while predicate: (TriviaPiece) -> Bool
-  ) -> Trivia {
-    Trivia(pieces: self.drop(while: predicate))
-  }
-
-  func trimmingSuffix(
-    while predicate: (TriviaPiece) -> Bool
-  ) -> Trivia {
-    Trivia(
-      pieces: self[...]
-        .reversed()
-        .drop(while: predicate)
-        .reversed()
-    )
-  }
-
-  var startsWithNewline: Bool {
-    self.first?.isNewline ?? false
-  }
-}
-
 let diagnosticDomain: String = "SwiftSyntaxMacroExpansion"
 
 private enum MacroApplicationError: DiagnosticMessage, Error {

Tests/SwiftRefactorTest/ConvertStoredPropertyToComputedTest.swift

@@ -170,6 +170,130 @@ final class ConvertStoredPropertyToComputedTest: XCTestCase {
 
     try assertRefactorConvert(baseline, expected: nil)
   }
+
+  func testRefactoringStoredPropertyWithLazyKeyword() throws {
+    let baseline: DeclSyntax = """
+      lazy var defaultColor: Color = .red
+      """
+
+    let expected: DeclSyntax = """
+      var defaultColor: Color { .red }
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStoredPropertyWithModifiers() throws {
+    let baseline: DeclSyntax = """
+      private lazy var defaultColor: Color = .red
+      """
+
+    let expected: DeclSyntax = """
+      private var defaultColor: Color { .red }
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStoredPropertyWithModifiers2() throws {
+    let baseline: DeclSyntax = """
+      lazy private var defaultColor: Color = .red
+      """
+
+    let expected: DeclSyntax = """
+      private var defaultColor: Color { .red }
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStoredPropertyWithModifiersAndComment() throws {
+    let baseline: DeclSyntax = """
+      lazy /* some comment */ private var defaultColor: Color = .red
+      """
+
+    let expected: DeclSyntax = """
+      /* some comment */ private var defaultColor: Color { .red }
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStoredPropertyWithModifiersAndComment2() throws {
+    let baseline: DeclSyntax = """
+      private /* comment */ lazy var defaultColor: Color = .red
+      """
+
+    let expected: DeclSyntax = """
+      private /* comment */ var defaultColor: Color { .red }
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStoredPropertyWithModifierAndComment() throws {
+    let baseline: DeclSyntax = """
+      lazy /* comment */ var defaultColor: Color = .red
+      """
+
+    let expected: DeclSyntax = """
+      /* comment */ var defaultColor: Color { .red }
+      """
+
+    try assertRefactorConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStructStoredPropertiyWithModifiers() throws {
+    let baseline: DeclSyntax = """
+      struct Foo {
+        lazy private var defaultColor: Color = .red
+      }
+      """
+
+    let expected: DeclSyntax = """
+      struct Foo {
+        private var defaultColor: Color { .red }
+      }
+      """
+
+    try assertRefactorStructConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStructStoredPropertiyWithModifiers2() throws {
+    let baseline: DeclSyntax = """
+      struct Foo {
+        private
+        /* comment */ lazy var defaultColor: Color = .red
+      }
+      """
+
+    let expected: DeclSyntax = """
+      struct Foo {
+        private
+        /* comment */ var defaultColor: Color { .red }
+      }
+      """
+
+    try assertRefactorStructConvert(baseline, expected: expected)
+  }
+
+  func testRefactoringStructStoredPropertiyWithModifiers3() throws {
+    let baseline: DeclSyntax = """
+      struct Foo {
+        private /* comment */
+        /* another comment */ lazy var defaultColor: Color = .red
+      }
+      """
+
+    let expected: DeclSyntax = """
+      struct Foo {
+        private /* comment */
+        /* another comment */ var defaultColor: Color { .red }
+      }
+      """
+
+    try assertRefactorStructConvert(baseline, expected: expected)
+  }
 }
 
 private func assertRefactorConvert(
@@ -187,3 +311,23 @@ private func assertRefactorConvert(
     line: line
   )
 }
+
+private func assertRefactorStructConvert(
+  _ callDecl: DeclSyntax,
+  expected: DeclSyntax,
+  file: StaticString = #filePath,
+  line: UInt = #line
+) throws {
+
+  let structCallDecl = try XCTUnwrap(callDecl.as(StructDeclSyntax.self))
+  let variable = try XCTUnwrap(structCallDecl.memberBlock.members.first?.decl.as(VariableDeclSyntax.self))
+  let refactored = try ConvertStoredPropertyToComputed.refactor(syntax: variable, in: ())
+
+  let members = MemberBlockItemListSyntax {
+    MemberBlockItemSyntax(decl: DeclSyntax(refactored))
+  }
+
+  let refactoredMemberBlock = structCallDecl.memberBlock.with(\.members, members)
+  let refactoredStruct = structCallDecl.with(\.memberBlock, refactoredMemberBlock)
+  assertStringsEqualWithDiff(refactoredStruct.description, expected.description)
+}