Implement methods not only from the selected template but also from its ancestry.

Author: pfcoperez

src/main/scala/scala/tools/refactoring/implementations/ImplementMethods.scala

@@ -35,24 +35,47 @@ abstract class ImplementMethods extends MultiStageRefactoring with analysis.Inde
     }
   }
 
+  private def templateAncestry(template: Template): List[Template] =
+    template :: {
+      for {
+        parent <- template.parents
+        parentImp <- index.declaration(parent.symbol).toList collect {
+          case ClassDef(_, _, _, impl) => impl
+        }
+        ancestor <- templateAncestry(parentImp)
+      } yield ancestor
+    }
+
   override def prepare(s: Selection): Either[PreparationError, PreparationResult] = {
 
 
     // Expand the selection to the concrete type when a kind was initially selected.
     val maybeSelectedTemplate = (s::s.expandToNextEnclosingTree.toList) flatMap { sel: Selection =>
       index.declaration(sel.enclosingTree.symbol)
     } collectFirst {
-      case templateDeclaration: ClassDef => templateDeclaration
+      case templateDeclaration: ClassDef => templateDeclaration.impl
     }
 
     // Get a sequence of methods found in the selected mixed trait.
-    val methodsToImplement = for {
-      selectedTemplateDeclaration <- maybeSelectedTemplate.toList
-      unimplementedMethod <- selectedTemplateDeclaration.impl.body collect {
-        case methodDeclaration: DefDef if methodDeclaration.rhs.isEmpty =>
-          methodDeclaration
-      }
-    } yield unimplementedMethod
+    val methodsToImplement = {
+
+      val rawList = for {
+        selectedTemplate <- maybeSelectedTemplate.toList
+        selectedDeclaration <- templateAncestry(selectedTemplate)
+        unimplementedMethod <- selectedDeclaration.body collect {
+          case methodDeclaration: DefDef if methodDeclaration.rhs.isEmpty =>
+            methodDeclaration
+        }
+      } yield unimplementedMethod;
+
+      val (uniqueMethods, _) =
+        rawList.foldRight((List.empty[DefDef], Set.empty[OverloadedMethod])) {
+          case (method, (l, visited)) if !visited.contains(method) =>
+            (method::l, visited + method)
+          case (_, st) => st
+        }
+      uniqueMethods
+    }
 
     // Use the selection to find the template where the methods should be implemented.
     val targetTemplate = s.expandToNextEnclosingTree.flatMap {

src/test/scala/scala/tools/refactoring/tests/implementations/ImplementMethodsTest.scala

@@ -223,4 +223,110 @@ class ImplementMethodsTest extends TestHelper with TestRefactoring {
   } applyRefactoring implementMethods
 
 
+  @Test
+  def implementMethodFromAncestry() = new FileSet() {
+    """
+      |package implementMethods
+      |
+      |trait R {
+      |  def k: Unit
+      |}
+      |
+      |trait T {
+      |  def f(x: Int): String
+      |}
+      |
+      |trait S extends T {
+      |  def g(x: Int): Int
+      |}
+      |
+      |object Obj extends /*(*/S/*)*/ with R {
+      |  val x: Int = ???
+      |}
+    """.stripMargin becomes
+    """
+      |package implementMethods
+      |
+      |trait R {
+      |  def k: Unit
+      |}
+      |
+      |trait T {
+      |  def f(x: Int): String
+      |}
+      |
+      |trait S extends T {
+      |  def g(x: Int): Int
+      |}
+      |
+      |object Obj extends /*(*/S/*)*/ with R {
+      |  val x: Int = ???
+      |
+      |  def g(x: Int): Int = {
+      |    ???
+      |  }
+      |
+      |  def f(x: Int): String = {
+      |    ???
+      |  }
+      |}
+    """.stripMargin
+
+  } applyRefactoring implementMethods
+
+  @Test
+  def implementMethodFromCyclicAncestry() = new FileSet() {
+    """
+      |package implementMethods
+      |
+      |trait R {
+      |  def k: Unit
+      |}
+      |
+      |trait T extends R {
+      |  def f(x: Int): String
+      |}
+      |
+      |trait S extends T with R {
+      |  def g(x: Int): Int
+      |}
+      |
+      |object Obj extends /*(*/S/*)*/ with R {
+      |  val x: Int = ???
+      |}
+    """.stripMargin becomes
+    """
+      |package implementMethods
+      |
+      |trait R {
+      |  def k: Unit
+      |}
+      |
+      |trait T extends R {
+      |  def f(x: Int): String
+      |}
+      |
+      |trait S extends T with R {
+      |  def g(x: Int): Int
+      |}
+      |
+      |object Obj extends /*(*/S/*)*/ with R {
+      |  val x: Int = ???
+      |
+      |  def g(x: Int): Int = {
+      |    ???
+      |  }
+      |
+      |  def f(x: Int): String = {
+      |    ???
+      |  }
+      |
+      |  def k: Unit = {
+      |    ???
+      |  }
+      |}
+    """.stripMargin
+
+  } applyRefactoring implementMethods
+
 }