[SwiftRefactor] EditRefactoringProvider: Make textRefactor and refactor requirements throwing

The result of both has been made non-optional as well. The idea
here is to be able to produce a description for every failure
instead of `nil` result, this is something that package model
refactoring actions already do.

The only error we currently have is "not applicable" but that's
just a start.

Author: xedin

EditorExtension/SwiftRefactorExtension/SourceEditorCommand.swift

@@ -40,18 +40,18 @@ final class SourceEditorCommand: NSObject, XCSourceEditorCommand {
       }
 
       override func visitAny(_ node: Syntax) -> Syntax? {
-        func withOpenedRefactoringProvider<T: SyntaxRefactoringProvider>(_ providerType: T.Type) -> Syntax? {
+        func withOpenedRefactoringProvider<T: SyntaxRefactoringProvider>(_ providerType: T.Type) throws -> Syntax? {
           guard
             let input = node.as(providerType.Input.self),
             providerType.Context.self == Void.self
           else {
             return nil
           }
           let context = unsafeBitCast(Void(), to: providerType.Context.self)
-          return providerType.refactor(syntax: input, in: context).map { Syntax($0) }
+          return try Syntax(providerType.refactor(syntax: input, in: context))
         }
 
-        return _openExistential(self.provider, do: withOpenedRefactoringProvider)
+        return try? _openExistential(self.provider, do: withOpenedRefactoringProvider)
       }
     }
 

Sources/SwiftRefactor/AddSeparatorsToIntegerLiteral.swift

@@ -37,11 +37,12 @@ import SwiftSyntax
 /// 0b1_010
 /// ```
 public struct AddSeparatorsToIntegerLiteral: SyntaxRefactoringProvider {
-  public static func refactor(syntax lit: IntegerLiteralExprSyntax, in context: Void) -> IntegerLiteralExprSyntax? {
+  public static func refactor(
+    syntax lit: IntegerLiteralExprSyntax,
+    in context: Void
+  ) throws -> IntegerLiteralExprSyntax {
     if lit.literal.text.contains("_") {
-      guard let strippedLiteral = RemoveSeparatorsFromIntegerLiteral.refactor(syntax: lit) else {
-        return nil
-      }
+      let strippedLiteral = try RemoveSeparatorsFromIntegerLiteral.refactor(syntax: lit)
       return self.addSeparators(to: strippedLiteral)
     } else {
       return self.addSeparators(to: lit)

Sources/SwiftRefactor/CallToTrailingClosures.swift

@@ -55,39 +55,43 @@ public struct CallToTrailingClosures: SyntaxRefactoringProvider {
 
   /// Apply the refactoring to a given syntax node. If either a
   /// non-function-like syntax node is passed, or the refactoring fails,
-  /// `nil` is returned.
-  // TODO: Rather than returning nil, we should consider throwing errors with
-  // appropriate messages instead.
+  /// error is thrown.
   public static func refactor(
     syntax: Syntax,
     in context: Context = Context()
-  ) -> Syntax? {
-    guard let call = syntax.asProtocol(CallLikeSyntax.self) else { return nil }
-    return Syntax(fromProtocol: _refactor(syntax: call, in: context))
+  ) throws -> Syntax {
+    guard let call = syntax.asProtocol(CallLikeSyntax.self) else {
+      throw RefactoringNotApplicableError("not a call")
+    }
+    return try Syntax(fromProtocol: _refactor(syntax: call, in: context))
   }
 
   @available(*, deprecated, message: "Pass a Syntax argument instead of FunctionCallExprSyntax")
   public static func refactor(
     syntax call: FunctionCallExprSyntax,
     in context: Context = Context()
-  ) -> FunctionCallExprSyntax? {
-    _refactor(syntax: call, in: context)
+  ) throws -> FunctionCallExprSyntax {
+    try _refactor(syntax: call, in: context)
   }
 
   internal static func _refactor<C: CallLikeSyntax>(
     syntax call: C,
     in context: Context = Context()
-  ) -> C? {
-    let converted = call.convertToTrailingClosures(from: context.startAtArgument)
-    return converted?.formatted().as(C.self)
+  ) throws -> C {
+    let converted = try call.convertToTrailingClosures(from: context.startAtArgument)
+
+    guard let formatted = converted.formatted().as(C.self) else {
+      throw RefactoringNotApplicableError("cannot cast formatted call to \(C.self)")
+    }
+
+    return formatted
   }
 }
 
 extension CallLikeSyntax {
-  fileprivate func convertToTrailingClosures(from startAtArgument: Int) -> Self? {
+  fileprivate func convertToTrailingClosures(from startAtArgument: Int) throws -> Self {
     guard trailingClosure == nil, additionalTrailingClosures.isEmpty, leftParen != nil, rightParen != nil else {
-      // Already have trailing closures
-      return nil
+      throw RefactoringNotApplicableError("call already uses trailing closures")
     }
 
     var closures = [(original: LabeledExprSyntax, closure: ClosureExprSyntax)]()
@@ -106,7 +110,7 @@ extension CallLikeSyntax {
     }
 
     guard !closures.isEmpty else {
-      return nil
+      throw RefactoringNotApplicableError("no arguments to convert to closures")
     }
 
     // First trailing closure won't have label/colon. Transfer their trivia.

Sources/SwiftRefactor/ConvertComputedPropertyToStored.swift

@@ -17,11 +17,15 @@ 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
+  public static func refactor(syntax: VariableDeclSyntax, in context: ()) throws -> VariableDeclSyntax {
+    guard syntax.bindings.count == 1, let binding = syntax.bindings.first else {
+      throw RefactoringNotApplicableError("unsupported variable declaration")
+    }
+
+    guard let accessorBlock = binding.accessorBlock,
+      case let .getter(body) = accessorBlock.accessors, !body.isEmpty
     else {
-      return nil
+      throw RefactoringNotApplicableError("getter is missing or empty")
     }
 
     let refactored = { (initializer: InitializerClauseSyntax) -> VariableDeclSyntax in
@@ -55,7 +59,7 @@ public struct ConvertComputedPropertyToStored: SyntaxRefactoringProvider {
     }
 
     guard body.count == 1, let item = body.first?.item else {
-      return nil
+      throw RefactoringNotApplicableError("getter body is not a single expression")
     }
 
     if let item = item.as(ReturnStmtSyntax.self), let expression = item.expression {
@@ -79,6 +83,6 @@ public struct ConvertComputedPropertyToStored: SyntaxRefactoringProvider {
       )
     }
 
-    return nil
+    throw RefactoringNotApplicableError("getter body is unsupported: \(item)")
   }
 }

Sources/SwiftRefactor/ConvertComputedPropertyToZeroParameterFunction.swift

@@ -17,25 +17,25 @@ import SwiftSyntax
 #endif
 
 public struct ConvertComputedPropertyToZeroParameterFunction: SyntaxRefactoringProvider {
-  public static func refactor(syntax: VariableDeclSyntax, in context: Void) -> FunctionDeclSyntax? {
+  public static func refactor(syntax: VariableDeclSyntax, in context: Void) throws -> FunctionDeclSyntax {
     guard syntax.bindings.count == 1,
       let binding = syntax.bindings.first,
       let identifierPattern = binding.pattern.as(IdentifierPatternSyntax.self)
-    else { return nil }
+    else { throw RefactoringNotApplicableError("unsupported variable declaration") }
 
     var statements: CodeBlockItemListSyntax
 
     guard let typeAnnotation = binding.typeAnnotation,
       var accessorBlock = binding.accessorBlock
-    else { return nil }
+    else { throw RefactoringNotApplicableError("no type annotation or stored") }
 
     var effectSpecifiers: AccessorEffectSpecifiersSyntax?
 
     switch accessorBlock.accessors {
     case .accessors(let accessors):
       guard accessors.count == 1, let accessor = accessors.first,
         accessor.accessorSpecifier.tokenKind == .keyword(.get), let codeBlock = accessor.body
-      else { return nil }
+      else { throw RefactoringNotApplicableError("not a getter-only declaration") }
       effectSpecifiers = accessor.effectSpecifiers
       statements = codeBlock.statements
       let accessorSpecifier = accessor.accessorSpecifier

Sources/SwiftRefactor/ConvertStoredPropertyToComputed.swift

@@ -17,17 +17,19 @@ import SwiftSyntax
 #endif
 
 public struct ConvertStoredPropertyToComputed: SyntaxRefactoringProvider {
-  public static func refactor(syntax: VariableDeclSyntax, in context: ()) -> VariableDeclSyntax? {
+  public static func refactor(syntax: VariableDeclSyntax, in context: ()) throws -> VariableDeclSyntax {
     guard syntax.bindings.count == 1, let binding = syntax.bindings.first, let initializer = binding.initializer else {
-      return nil
+      throw RefactoringNotApplicableError("unsupported variable declaration")
     }
 
     var codeBlockSyntax: CodeBlockItemListSyntax
 
     if let functionExpression = initializer.value.as(FunctionCallExprSyntax.self),
       let closureExpression = functionExpression.calledExpression.as(ClosureExprSyntax.self)
     {
-      guard functionExpression.arguments.isEmpty else { return nil }
+      guard functionExpression.arguments.isEmpty else {
+        throw RefactoringNotApplicableError("not a nullary call")
+      }
 
       codeBlockSyntax = closureExpression.statements
       codeBlockSyntax.leadingTrivia =

Sources/SwiftRefactor/ConvertZeroParameterFunctionToComputedProperty.swift

@@ -17,10 +17,10 @@ import SwiftSyntax
 #endif
 
 public struct ConvertZeroParameterFunctionToComputedProperty: SyntaxRefactoringProvider {
-  public static func refactor(syntax: FunctionDeclSyntax, in context: ()) -> VariableDeclSyntax? {
+  public static func refactor(syntax: FunctionDeclSyntax, in context: ()) throws -> VariableDeclSyntax {
     guard syntax.signature.parameterClause.parameters.isEmpty,
       let body = syntax.body
-    else { return nil }
+    else { throw RefactoringNotApplicableError("not a zero parameter function") }
 
     let variableName = PatternSyntax(
       IdentifierPatternSyntax(

Sources/SwiftRefactor/ExpandEditorPlaceholder.swift

@@ -275,13 +275,19 @@ public struct ExpandEditorPlaceholdersToLiteralClosures: SyntaxRefactoringProvid
   public static func refactor(
     syntax: Syntax,
     in context: Context = Context()
-  ) -> Syntax? {
-    guard let call = syntax.asProtocol(CallLikeSyntax.self) else { return nil }
-    let expanded = Self.expandClosurePlaceholders(
-      in: call,
-      ifIncluded: nil,
-      context: context
-    )
+  ) throws -> Syntax {
+    guard let call = syntax.asProtocol(CallLikeSyntax.self) else {
+      throw RefactoringNotApplicableError("not a call")
+    }
+    guard
+      let expanded = Self.expandClosurePlaceholders(
+        in: call,
+        ifIncluded: nil,
+        context: context
+      )
+    else {
+      throw RefactoringNotApplicableError("could not expand closure placeholders")
+    }
     return Syntax(fromProtocol: expanded)
   }
 
@@ -325,7 +331,7 @@ public struct ExpandEditorPlaceholdersToLiteralClosures: SyntaxRefactoringProvid
       let callToTrailingContext = CallToTrailingClosures.Context(
         startAtArgument: call.arguments.count - expanded.numClosures
       )
-      return CallToTrailingClosures._refactor(syntax: expanded.expr, in: callToTrailingContext)
+      return try? CallToTrailingClosures._refactor(syntax: expanded.expr, in: callToTrailingContext)
     }
   }
 }

Sources/SwiftRefactor/FormatRawStringLiteral.swift

@@ -35,7 +35,7 @@ import SwiftSyntax
 /// "Hello World"
 /// ```
 public struct FormatRawStringLiteral: SyntaxRefactoringProvider {
-  public static func refactor(syntax lit: StringLiteralExprSyntax, in context: Void) -> StringLiteralExprSyntax? {
+  public static func refactor(syntax lit: StringLiteralExprSyntax, in context: Void) -> StringLiteralExprSyntax {
     var maximumHashes = 0
     for segment in lit.segments {
       switch segment {

Sources/SwiftRefactor/MigrateToNewIfLetSyntax.swift

@@ -39,7 +39,7 @@ import SwiftSyntax
 ///   // ...
 /// }
 public struct MigrateToNewIfLetSyntax: SyntaxRefactoringProvider {
-  public static func refactor(syntax node: IfExprSyntax, in context: ()) -> IfExprSyntax? {
+  public static func refactor(syntax node: IfExprSyntax, in context: ()) -> IfExprSyntax {
     // Visit all conditions in the node.
     let newConditions = node.conditions.enumerated().map { (index, condition) -> ConditionElementListSyntax.Element in
       var conditionCopy = condition