[IDE] Refactoring: conversion from “force try” to error handled version (swiftlang#12063)

* [IDE] Refactoring: conversion from “force try” do error handled version

* Removed unnecessary empty line

* Changed name of the refactor

* Review fixes

* Fixed recognizing try_! location by CursorResolver

* Review fixes

Author: Kacper20

include/swift/IDE/RefactoringKinds.def

@@ -40,6 +40,8 @@ CURSOR_REFACTORING(SimplifyNumberLiteral, "Simplify Long Number Literal", simpli
 
 CURSOR_REFACTORING(CollapseNestedIfExpr, "Collapse Nested If Expression", collapse.nested.if.expr)
 
+CURSOR_REFACTORING(ConvertToDoCatch, "Convert To Do/Catch", convert.do.catch)
+
 RANGE_REFACTORING(ExtractExpr, "Extract Expression", extract.expr)
 
 RANGE_REFACTORING(ExtractFunction, "Extract Method", extract.function)

lib/IDE/Refactoring.cpp

@@ -12,6 +12,7 @@
 
 #include "swift/IDE/Refactoring.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsRefactoring.h"
 #include "swift/AST/Expr.h"
@@ -1923,6 +1924,60 @@ bool RefactoringActionLocalizeString::performChange() {
   return false;
 }
 
+static CharSourceRange
+  findSourceRangeToWrapInCatch(ResolvedCursorInfo CursorInfo,
+                               SourceFile *TheFile,
+                               SourceManager &SM) {
+  Expr *E = CursorInfo.TrailingExpr;
+  if (!E)
+    return CharSourceRange();
+  auto Node = ASTNode(E);
+  auto NodeChecker = [](ASTNode N) { return N.isStmt(StmtKind::Brace); };
+  ContextFinder Finder(*TheFile, Node, NodeChecker);
+  Finder.resolve();
+  auto Contexts = Finder.getContexts();
+  if (Contexts.size() == 0)
+    return CharSourceRange();
+  auto TargetNode = Contexts.back();
+  BraceStmt *BStmt = dyn_cast<BraceStmt>(TargetNode.dyn_cast<Stmt*>());
+  auto ConvertToCharRange = [&SM](SourceRange SR) {
+    return Lexer::getCharSourceRangeFromSourceRange(SM, SR);
+  };
+  assert(BStmt);
+  auto ExprRange = ConvertToCharRange(E->getSourceRange());
+  // Check elements of the deepest BraceStmt, pick one that covers expression.
+  for (auto Elem: BStmt->getElements()) {
+    auto ElemRange = ConvertToCharRange(Elem.getSourceRange());
+    if (ElemRange.contains(ExprRange))
+      TargetNode = Elem;
+  }
+  return ConvertToCharRange(TargetNode.getSourceRange());
+}
+
+bool RefactoringActionConvertToDoCatch::isApplicable(ResolvedCursorInfo Tok) {
+  if (!Tok.TrailingExpr)
+    return false;
+  return isa<ForceTryExpr>(Tok.TrailingExpr);
+}
+
+bool RefactoringActionConvertToDoCatch::performChange() {
+  auto *TryExpr = dyn_cast<ForceTryExpr>(CursorInfo.TrailingExpr);
+  if (!TryExpr)
+    return true;
+  auto Range = findSourceRangeToWrapInCatch(CursorInfo, TheFile, SM);
+  if (!Range.isValid())
+    return true;
+  // Wrap given range in do catch block.
+  EditConsumer.accept(SM, Range.getStart(), "do {\n");
+  EditorConsumerInsertStream OS(EditConsumer, SM, Range.getEnd());
+  OS << "\n} catch {\n" << getCodePlaceholder() << "\n}";
+
+  // Delete ! from try! expression
+  auto ExclaimRange = CharSourceRange(TryExpr->getExclaimLoc(), 1);
+  EditConsumer.accept(SM, ExclaimRange, "");
+  return false;
+}
+
 /// Given a cursor position, this function tries to collect a number literal
 /// expression immediately following the cursor.
 static NumberLiteralExpr *getTrailingNumberLiteral(ResolvedCursorInfo Tok) {

lib/IDE/SwiftSourceDocInfo.cpp

@@ -188,9 +188,14 @@ bool CursorInfoResolver::walkToExprPre(Expr *E) {
         ContainerType = ME->getBase()->getType();
       }
     }
-
+    auto IsProperCursorLocation = E->getStartLoc() == LocToResolve;
+    // Handle cursor placement between try and ! in ForceTryExpr.
+    if (auto *FTE = dyn_cast<ForceTryExpr>(E)) {
+      IsProperCursorLocation = LocToResolve == FTE->getExclaimLoc() ||
+      IsProperCursorLocation;
+    }
     // Keep track of trailing expressions.
-    if (!E->isImplicit() && E->getStartLoc() == LocToResolve)
+    if (!E->isImplicit() && IsProperCursorLocation)
       TrailingExprStack.push_back(E);
   }
   return true;

test/refactoring/ConvertForceTryToTryCatch/Outputs/basic/L5.swift.expected

@@ -0,0 +1,8 @@
+func throwingFunc() throws {
+    return
+}
+do {
+try throwingFunc()
+} catch {
+<#code#>
+}

test/refactoring/ConvertForceTryToTryCatch/Outputs/basic_in_func/L5.swift.expected

@@ -0,0 +1,10 @@
+func throwingFunc() throws {
+    return
+}
+func foo() {
+    do {
+try throwingFunc()
+} catch {
+<#code#>
+}
+}

test/refactoring/ConvertForceTryToTryCatch/Outputs/for_loop/L5.swift.expected

@@ -0,0 +1,10 @@
+func throwingFunc() throws -> [Int] {
+    return []
+}
+do {
+for num in try throwingFunc() {
+    let _ = num
+}
+} catch {
+<#code#>
+}

test/refactoring/ConvertForceTryToTryCatch/Outputs/in_if_clause/L5.swift.expected

@@ -0,0 +1,10 @@
+func throwingFunc() throws -> Bool {
+    return true
+}
+do {
+if try throwingFunc() { 
+    let _ = 3
+}
+} catch {
+<#code#>
+}

test/refactoring/ConvertForceTryToTryCatch/Outputs/in_if_clause_nested/L5.swift.expected

@@ -0,0 +1,12 @@
+func throwingFunc() throws -> Bool {
+    return true
+}
+if 4 > 3 {
+    do {
+if try throwingFunc() { 
+        let _ = 3
+    }
+} catch {
+<#code#>
+}
+}

test/refactoring/ConvertForceTryToTryCatch/Outputs/in_if_clause_with_let_binding/L5.swift.expected

@@ -0,0 +1,10 @@
+func throwingFunc() throws -> Int? {
+    return nil
+}
+do {
+if let val = try throwingFunc() { 
+    let _ = val
+}
+} catch {
+<#code#>
+}

test/refactoring/ConvertForceTryToTryCatch/Outputs/inside_constructor/L5.swift.expected

@@ -0,0 +1,9 @@
+func throwingFunc() throws -> [Int] {
+    return []
+}
+struct X { let array: [Int] }
+do {
+let _ = X(array: try throwingFunc())
+} catch {
+<#code#>
+}