[Refactoring] SR-5743 Try To Force Try Refactor implementation

include/swift/IDE/RefactoringKinds.def

@@ -42,6 +42,8 @@ CURSOR_REFACTORING(CollapseNestedIfExpr, "Collapse Nested If Expression", collap
 
 CURSOR_REFACTORING(ConvertToDoCatch, "Convert To Do/Catch", convert.do.catch)
 
+CURSOR_REFACTORING(ConvertToForceTry, "Convert To Force Try", convert.force.try)
+
 RANGE_REFACTORING(ExtractExpr, "Extract Expression", extract.expr)
 
 RANGE_REFACTORING(ExtractFunction, "Extract Method", extract.function)

lib/IDE/Refactoring.cpp

@@ -1973,6 +1973,89 @@ bool RefactoringActionConvertToDoCatch::performChange() {
   return false;
 }
 
+struct TryExpressionConversionInfo {
+  TryExpr &TE;
+  DoCatchStmt *Stmt;
+  unsigned int NumberOfTriesInDoCatch;
+  TryExpressionConversionInfo(TryExpr &TE, DoCatchStmt *Stmt,
+                              unsigned int NumberOfTriesInDoCatch):
+                              TE(TE),
+                              Stmt(Stmt),
+                              NumberOfTriesInDoCatch(NumberOfTriesInDoCatch) {}
+  TryExpressionConversionInfo(TryExpr &TE): TE(TE), Stmt(nullptr),
+                              NumberOfTriesInDoCatch(0) {}
+};
+
+static TryExpressionConversionInfo findTryConversion(ResolvedCursorInfo Info,
+                                                     SourceFile *TheFile,
+                                                     SourceManager &SM) {
+  auto *TE = dyn_cast<TryExpr>(Info.TrailingExpr);
+  assert(TE);
+  auto Node = ASTNode(TE);
+  auto NodeChecker = [](ASTNode N) {
+    return N.isStmt(StmtKind::DoCatch);
+  };
+  ContextFinder Finder(*TheFile, Node, NodeChecker);
+  Finder.resolve();
+  auto Contexts = Finder.getContexts();
+  if (Contexts.size() == 0) {
+    return TryExpressionConversionInfo(*TE);
+  }
+  auto StmtNode = Contexts.back();
+  DoCatchStmt *DCStmt = dyn_cast<DoCatchStmt>(StmtNode.dyn_cast<Stmt*>());
+
+  struct TryExprCounter: public SourceEntityWalker {
+    unsigned int Count = 0;
+    bool walkToExprPre(Expr *E) {
+      if (auto *FE = dyn_cast<TryExpr>(E)) {
+        Count += 1;
+      }
+      return true;
+    }
+  } Counter;
+  Counter.walk(DCStmt);
+
+  return TryExpressionConversionInfo(*TE, DCStmt, Counter.Count);
+}
+
+bool RefactoringActionConvertToForceTry::
+isApplicable(ResolvedCursorInfo Tok, DiagnosticEngine &Diag) {
+  if (!Tok.TrailingExpr)
+    return false;
+  return isa<TryExpr>(Tok.TrailingExpr);
+}
+
+bool RefactoringActionConvertToForceTry::performChange() {
+  auto ConversionInfo = findTryConversion(CursorInfo, TheFile, SM);
+  auto *DCStmt = ConversionInfo.Stmt;
+  // Add exclamation to the call.
+  auto TryLoc = ConversionInfo.TE.getTryLoc();
+  auto TryEndLoc = TryLoc.getAdvancedLocOrInvalid(getKeywordLen(tok::kw_try));
+  EditConsumer.accept(SM, TryEndLoc, "!");
+
+  if (DCStmt && ConversionInfo.NumberOfTriesInDoCatch == 1) {
+    //It's the only try in do catch block, remove the block.
+    auto *BodyStmt = DCStmt->getBody();
+    auto *BCStmt = dyn_cast<BraceStmt>(BodyStmt);
+    auto FirstNodeStartLoc = BCStmt->getElements().front().getStartLoc();
+    auto BeforeBodyRange = CharSourceRange(
+                                      SM,
+                                      DCStmt->getStartLoc(),
+                                      FirstNodeStartLoc);
+    EditConsumer.accept(SM, BeforeBodyRange, "");
+    auto LastNodePastEndLoc = BCStmt->getElements()
+      .back().getEndLoc().getAdvancedLocOrInvalid(1);
+    auto CatchRBraceLoc = DCStmt->getEndLoc()
+      .getAdvancedLocOrInvalid(getKeywordLen(tok::r_paren));
+    auto AfterBodyRange = CharSourceRange(
+                                    SM,
+                                    LastNodePastEndLoc,
+                                    CatchRBraceLoc);
+    EditConsumer.accept(SM, AfterBodyRange, "");
+  }
+  return false;
+}
+
 /// Given a cursor position, this function tries to collect a number literal
 /// expression immediately following the cursor.
 static NumberLiteralExpr *getTrailingNumberLiteral(ResolvedCursorInfo Tok) {

test/refactoring/ConvertTryToForceTry/Outputs/multiple_tries/L4.swift.expected

@@ -0,0 +1,9 @@
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  do {
+    let _ = try! throwingFunc()
+    let _ = try throwingFunc()
+  } catch {
+    let _ = error
+  }
+}

test/refactoring/ConvertTryToForceTry/Outputs/only_try/L3.swift.expected

@@ -0,0 +1,4 @@
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  let _ = try! throwingFunc()
+}

test/refactoring/ConvertTryToForceTry/Outputs/try_without_do/L3.swift.expected

@@ -0,0 +1,4 @@
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  let _ = try! throwingFunc()
+}

test/refactoring/ConvertTryToForceTry/multiple_tries.swift

@@ -0,0 +1,12 @@
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  do {
+    let _ = try throwingFunc()
+    let _ = try throwingFunc()
+  } catch {
+    let _ = error
+  }
+}
+// RUN: rm -rf %t.result && mkdir -p %t.result
+// RUN: %refactor -convert-to-force-try -source-filename %s -pos=4:14 > %t.result/L4.swift
+// RUN: diff -u %S/Outputs/multiple_tries/L4.swift.expected %t.result/L4.swift

test/refactoring/ConvertTryToForceTry/only_try.swift

@@ -0,0 +1,11 @@
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  do {
+    let _ = try throwingFunc()
+  } catch {
+    let _ = error
+  }
+}
+// RUN: rm -rf %t.result && mkdir -p %t.result
+// RUN: %refactor -convert-to-force-try -source-filename %s -pos=4:14 > %t.result/L3.swift
+// RUN: diff -u %S/Outputs/only_try/L3.swift.expected %t.result/L3.swift

test/refactoring/ConvertTryToForceTry/try_without_do.swift

@@ -0,0 +1,7 @@
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  let _ = try throwingFunc()
+}
+// RUN: rm -rf %t.result && mkdir -p %t.result
+// RUN: %refactor -convert-to-force-try -source-filename %s -pos=3:12 > %t.result/L3.swift
+// RUN: diff -u %S/Outputs/try_without_do/L3.swift.expected %t.result/L3.swift

test/refactoring/RefactoringKind/basic.swift

@@ -216,6 +216,15 @@ func testForceTry() {
   func throwingFunc() throws -> Int { return 3 }
   let _ = try! throwingFunc()
 }
+
+func testTryToForceTry() {
+  func throwingFunc() throws -> Int { return 3 }
+  do {
+    let _ = try throwingFunc()
+  } catch {
+    let _ = error
+  }
+}
 // RUN: %refactor -source-filename %s -pos=2:1 -end-pos=5:13 | %FileCheck %s -check-prefix=CHECK1
 // RUN: %refactor -source-filename %s -pos=3:1 -end-pos=5:13 | %FileCheck %s -check-prefix=CHECK1
 // RUN: %refactor -source-filename %s -pos=4:1 -end-pos=5:13 | %FileCheck %s -check-prefix=CHECK1
@@ -301,6 +310,10 @@ func testForceTry() {
 // RUN: %refactor -source-filename %s -pos=217:13 | %FileCheck %s -check-prefix=CHECK-TRY-CATCH
 // RUN: %refactor -source-filename %s -pos=217:14 | %FileCheck %s -check-prefix=CHECK-TRY-CATCH
 
+// RUN: %refactor -source-filename %s -pos=223:13 | %FileCheck %s -check-prefix=CHECK-FORCE-TRY
+// RUN: %refactor -source-filename %s -pos=223:14 | %FileCheck %s -check-prefix=CHECK-FORCE-TRY
+// RUN: %refactor -source-filename %s -pos=223:15 | %FileCheck %s -check-prefix=CHECK-FORCE-TRY
+
 // CHECK1: Action begins
 // CHECK1-NEXT: Extract Method
 // CHECK1-NEXT: Action ends
@@ -342,3 +355,5 @@ func testForceTry() {
 
 // CHECK-TRY-CATCH: Convert To Do/Catch
 
+// CHECK-FORCE-TRY: Convert To Force Try
+

tools/swift-refactor/swift-refactor.cpp

@@ -42,6 +42,8 @@ Action(llvm::cl::desc("kind:"), llvm::cl::init(RefactoringKind::None),
                       "collapse-nested-if", "Perform collapse nested if statements"),
            clEnumValN(RefactoringKind::ConvertToDoCatch,
                       "convert-to-do-catch", "Perform force try to do try catch refactoring"),
+           clEnumValN(RefactoringKind::ConvertToForceTry,
+                      "convert-to-force-try", "Perform try to force try refactoring"),
            clEnumValN(RefactoringKind::SimplifyNumberLiteral,
                       "simplify-long-number", "Perform simplify long number literal refactoring"),
            clEnumValN(RefactoringKind::ConvertStringsConcatenationToInterpolation,