[IDE] SR-5745 Refactoring: converting strings concatenation expression to strings interpolation (#11944)

Author: Kacper20

include/swift/AST/ASTContext.h

@@ -440,6 +440,9 @@ class ASTContext {
   /// Get the '+' function on two RangeReplaceableCollection.
   FuncDecl *getPlusFunctionOnRangeReplaceableCollection() const;
 
+  /// Get the '+' function on two String.
+  FuncDecl *getPlusFunctionOnString() const;
+
   /// Check whether the standard library provides all the correct
   /// intrinsic support for Optional<T>.
   ///

include/swift/IDE/RefactoringKinds.def

@@ -46,6 +46,7 @@ RANGE_REFACTORING(ExtractFunction, "Extract Method", extract.function)
 
 RANGE_REFACTORING(ExtractRepeatedExpr, "Extract Repeated Expression", extract.expr.repeated)
 
+RANGE_REFACTORING(ConvertStringsConcatenationToInterpolation, "Convert to String Interpolation", convert.string-concatenation.interpolation)
 #undef CURSOR_REFACTORING
 #undef RANGE_REFACTORING
 #undef SEMANTIC_REFACTORING

lib/AST/ASTContext.cpp

@@ -132,6 +132,9 @@ struct ASTContext::Implementation {
   /// The declaration of '+' function for two RangeReplaceableCollection.
   FuncDecl *PlusFunctionOnRangeReplaceableCollection = nullptr;
 
+  /// The declaration of '+' function for two String.
+  FuncDecl *PlusFunctionOnString = nullptr;
+
   /// The declaration of Swift.Optional<T>.Some.
   EnumElementDecl *OptionalSomeDecl = nullptr;
 
@@ -557,7 +560,7 @@ FuncDecl *ASTContext::getPlusFunctionOnRangeReplaceableCollection() const {
   lookupInSwiftModule("+", Results);
   for (auto Result : Results) {
     if (auto *FD = dyn_cast<FuncDecl>(Result)) {
-      if(!FD->getOperatorDecl())
+      if (!FD->getOperatorDecl())
         continue;
       for (auto Req: FD->getGenericRequirements()) {
         if (Req.getKind() == RequirementKind::Conformance &&
@@ -571,6 +574,36 @@ FuncDecl *ASTContext::getPlusFunctionOnRangeReplaceableCollection() const {
   return Impl.PlusFunctionOnRangeReplaceableCollection;
 }
 
+FuncDecl *ASTContext::getPlusFunctionOnString() const {
+  if (Impl.PlusFunctionOnString) {
+    return Impl.PlusFunctionOnString;
+  }
+  // Find all of the declarations with this name in the Swift module.
+  SmallVector<ValueDecl *, 1> Results;
+  lookupInSwiftModule("+", Results);
+  for (auto Result : Results) {
+    if (auto *FD = dyn_cast<FuncDecl>(Result)) {
+      if (!FD->getOperatorDecl())
+        continue;
+      auto ResultType = FD->getResultInterfaceType();
+      if (ResultType->getNominalOrBoundGenericNominal() != getStringDecl())
+        continue;
+      auto ParamLists = FD->getParameterLists();
+      if (ParamLists.size() != 2 || ParamLists[1]->size() != 2)
+        continue;
+      auto CheckIfStringParam = [this](ParamDecl* Param) {
+        auto Type = Param->getInterfaceType()->getNominalOrBoundGenericNominal();
+        return Type == getStringDecl();
+      };
+      if (CheckIfStringParam(ParamLists[1]->get(0)) &&
+          CheckIfStringParam(ParamLists[1]->get(1))) {
+        Impl.PlusFunctionOnString = FD;
+        break;
+      }
+    }
+  }
+  return Impl.PlusFunctionOnString;
+}
 
 #define KNOWN_STDLIB_TYPE_DECL(NAME, DECL_CLASS, NUM_GENERIC_PARAMS) \
   DECL_CLASS *ASTContext::get##NAME##Decl() const { \

lib/IDE/Refactoring.cpp

@@ -1555,6 +1555,116 @@ bool RefactoringActionCollapseNestedIfExpr::performChange() {
   return false;
 }
 
+static std::unique_ptr<llvm::SetVector<Expr*>>
+  findConcatenatedExpressions(ResolvedRangeInfo Info, ASTContext &Ctx) {
+  if (Info.Kind != RangeKind::SingleExpression
+      && Info.Kind != RangeKind::PartOfExpression)
+    return nullptr;
+  Expr *E = Info.ContainedNodes[0].get<Expr*>();
+
+  struct StringInterpolationExprFinder: public SourceEntityWalker {
+    std::unique_ptr<llvm::SetVector<Expr*>> Bucket = llvm::
+    make_unique<llvm::SetVector<Expr*>>();
+    ASTContext &Ctx;
+
+    bool IsValidInterpolation = true;
+    StringInterpolationExprFinder(ASTContext &Ctx): Ctx(Ctx) {}
+
+    bool isConcatenationExpr(DeclRefExpr* Expr) {
+      if (!Expr)
+        return false;
+      auto *FD = dyn_cast<FuncDecl>(Expr->getDecl());
+      if (FD == nullptr || (FD != Ctx.getPlusFunctionOnString() &&
+          FD != Ctx.getPlusFunctionOnRangeReplaceableCollection())) {
+        return false;
+      }
+      return true;
+    }
+
+    bool walkToExprPre(Expr *E) {
+      if (E->isImplicit())
+        return true;
+      auto ExprType = E->getType()->getNominalOrBoundGenericNominal();
+      //Only binary concatenation operators should exist in expression
+      if (E->getKind() == ExprKind::Binary) {
+        auto *BE = dyn_cast<BinaryExpr>(E);
+        auto *OperatorDeclRef = BE->getSemanticFn()->getMemberOperatorRef();
+        if (!(isConcatenationExpr(OperatorDeclRef)
+            && ExprType == Ctx.getStringDecl())) {
+          IsValidInterpolation = false;
+          return false;
+        }
+        return true;
+      }
+      // Everything that evaluates to string should be gathered.
+      if (ExprType == Ctx.getStringDecl()) {
+        Bucket->insert(E);
+        return false;
+      }
+      if (auto *DR = dyn_cast<DeclRefExpr>(E)) {
+        // Checks whether all function references in expression are concatenations.
+        auto *FD = dyn_cast<FuncDecl>(DR->getDecl());
+        auto IsConcatenation = isConcatenationExpr(DR);
+        if (FD && IsConcatenation) {
+          return false;
+        }
+      }
+      // There was non-expected expression, it's not valid interpolation then.
+      IsValidInterpolation = false;
+      return false;
+    }
+  } Walker(Ctx);
+  Walker.walk(E);
+
+  // There should be two or more expressions to convert.
+  if (!Walker.IsValidInterpolation || Walker.Bucket->size() < 2)
+    return nullptr;
+
+  return std::move(Walker.Bucket);
+}
+
+static void interpolatedExpressionForm(Expr *E, SourceManager &SM,
+                                              llvm::raw_ostream &OS) {
+  if (auto *Literal = dyn_cast<StringLiteralExpr>(E)) {
+    OS << Literal->getValue();
+    return;
+  }
+  auto ExpStr = Lexer::getCharSourceRangeFromSourceRange(SM,
+    E->getSourceRange()).str().str();
+  if (isa<InterpolatedStringLiteralExpr>(E)) {
+    ExpStr.erase(0, 1);
+    ExpStr.pop_back();
+    OS << ExpStr;
+    return;
+  }
+  OS << "\\(" << ExpStr << ")";
+}
+
+bool RefactoringActionConvertStringsConcatenationToInterpolation::
+isApplicable(ResolvedRangeInfo Info, DiagnosticEngine &Diag) {
+  auto RangeContext = Info.RangeContext;
+  if (RangeContext) {
+    auto &Ctx = Info.RangeContext->getASTContext();
+    return findConcatenatedExpressions(Info, Ctx) != nullptr;
+  }
+  return false;
+}
+
+bool RefactoringActionConvertStringsConcatenationToInterpolation::performChange() {
+  auto Expressions = findConcatenatedExpressions(RangeInfo, Ctx);
+  if (!Expressions)
+    return true;
+  llvm::SmallString<64> Buffer;
+  llvm::raw_svector_ostream OS(Buffer);
+  OS << "\"";
+  for (auto It = Expressions->begin(); It != Expressions->end(); It++) {
+    interpolatedExpressionForm(*It, SM, OS);
+  }
+  OS << "\"";
+  EditConsumer.accept(SM, RangeInfo.ContentRange, Buffer);
+  return false;
+}
+
 /// The helper class analyzes a given nominal decl or an extension decl to
 /// decide whether stubs are required to filled in and the context in which
 /// these stubs should be filled.

test/refactoring/ConvertStringsConcatenationToInterpolation/Outputs/basic/L4.swift.expected

@@ -0,0 +1,5 @@
+func testStringConcatenation() {
+  let firstName = "Jason"
+  let bornYear = "1888"
+  let _ = "Mr. \(firstName)\(bornYear)"
+}

test/refactoring/ConvertStringsConcatenationToInterpolation/Outputs/func_calls/L5.swift.expected

@@ -0,0 +1,6 @@
+func testStringConcatenation() {
+  let firstName = "Jason"
+  let number = 3
+  let closure: () -> String = { return "FOO" }
+  let _ = "Mr. \(firstName.debugDescription)\(closure())number: \(number)"
+}

test/refactoring/ConvertStringsConcatenationToInterpolation/basic.swift

@@ -0,0 +1,8 @@
+func testStringConcatenation() {
+  let firstName = "Jason"
+  let bornYear = "1888"
+  let _ = "Mr. " + firstName + bornYear
+}
+// RUN: rm -rf %t.result && mkdir -p %t.result
+// RUN: %refactor -strings-concatenation-to-interpolation -source-filename %s -pos=4:11 -end-pos=4:40 > %t.result/L4.swift
+// RUN: diff -u %S/Outputs/basic/L4.swift.expected %t.result/L4.swift

test/refactoring/ConvertStringsConcatenationToInterpolation/func_calls.swift

@@ -0,0 +1,9 @@
+func testStringConcatenation() {
+  let firstName = "Jason"
+  let number = 3
+  let closure: () -> String = { return "FOO" }
+  let _ = "Mr. " + firstName.debugDescription + closure() + "number: \(number)"
+}
+// RUN: rm -rf %t.result && mkdir -p %t.result
+// RUN: %refactor -strings-concatenation-to-interpolation -source-filename %s -pos=5:11 -end-pos=5:80 > %t.result/L5.swift
+// RUN: diff -u %S/Outputs/func_calls/L5.swift.expected %t.result/L5.swift

test/refactoring/RefactoringKind/basic.swift

@@ -203,6 +203,14 @@ func testExtraIfNestedIf() {
     let b = 0
   }
 }
+
+func testStringInterpolation() -> String {
+  let name = "Jason"
+  let one = "\(1)"
+  let _ = "aaa" + "bbb"
+  let _ = name + "Bourne"
+  let _ = name + one
+}
 // 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
@@ -279,6 +287,10 @@ func testExtraIfNestedIf() {
 // RUN: %refactor -source-filename %s -pos=193:3 | %FileCheck %s -check-prefix=CHECK-NONE
 // RUN: %refactor -source-filename %s -pos=201:3 | %FileCheck %s -check-prefix=CHECK-NONE
 
+// RUN: %refactor -source-filename %s -pos=210:11 -end-pos=210:24 | %FileCheck %s -check-prefix=CHECK-STRINGS-INTERPOLATION
+// RUN: %refactor -source-filename %s -pos=211:11 -end-pos=211:26 | %FileCheck %s -check-prefix=CHECK-STRINGS-INTERPOLATION
+// RUN: %refactor -source-filename %s -pos=212:11 -end-pos=212:21 | %FileCheck %s -check-prefix=CHECK-STRINGS-INTERPOLATION
+
 // CHECK1: Action begins
 // CHECK1-NEXT: Extract Method
 // CHECK1-NEXT: Action ends
@@ -315,3 +327,6 @@ func testExtraIfNestedIf() {
 // CHECK-LOCALIZE-STRING: Localize String
 
 // CHECK-COLLAPSE-NESTED-IF-EXPRESSION: Collapse Nested If Expression
+
+// CHECK-STRINGS-INTERPOLATION: Convert to String Interpolation
+

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::SimplifyNumberLiteral,
                       "simplify-long-number", "Perform simplify long number literal refactoring"),
+           clEnumValN(RefactoringKind::ConvertStringsConcatenationToInterpolation,
+                     "strings-concatenation-to-interpolation", "Perform strings concatenation to interpolation refactoring"),
            clEnumValN(RefactoringKind::ExtractFunction,
                       "extract-function", "Perform extract function refactoring"),
            clEnumValN(RefactoringKind::GlobalRename,