Unfinished perform stage

Author: pfcoperez

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

@@ -1,32 +1,63 @@
 package scala.tools.refactoring.implementations
 
 import scala.tools.refactoring.common.InteractiveScalaCompiler
+import scala.tools.refactoring.transformation.TreeFactory
 import scala.tools.refactoring.{MultiStageRefactoring, analysis}
 
-abstract class ImplementMethods extends MultiStageRefactoring with analysis.Indexes with InteractiveScalaCompiler {
+abstract class ImplementMethods extends MultiStageRefactoring with analysis.Indexes with TreeFactory with InteractiveScalaCompiler {
 
   import global._
 
-  override type PreparationResult = Seq[DefDef]
+  case class PreparationResult(targetTemplate: Template, methodsToImplement: Seq[DefDef])
 
   override def prepare(s: Selection): Either[PreparationError, PreparationResult] = {
+
     val methodsToImplement = for {
-      selectedClassDeclaration <- index.declaration(s.enclosingTree.symbol).toSeq collect {
+      selectedTemplateDeclaration <- index.declaration(s.enclosingTree.symbol).toSeq collect {
         case traitDeclaration: ClassDef => traitDeclaration
       }
-      unimplementedMethod <- selectedClassDeclaration.impl.body collect {
+      unimplementedMethod <- selectedTemplateDeclaration.impl.body collect {
         case methodDeclaration: DefDef if methodDeclaration.rhs.isEmpty => methodDeclaration
       }
     } yield unimplementedMethod
-    if(methodsToImplement.isEmpty) Left {
+
+    val targetTemplate = s.expandToNextEnclosingTree.flatMap {
+      _.selectedSymbolTree collect {
+        case target: Template => target
+      }
+    }
+
+    if(targetTemplate.isEmpty) Left {
+      PreparationError("No target class in selection")
+    }
+    else if(methodsToImplement.isEmpty) Left {
       PreparationError("There are not methods to implement")
     }
-    else Right(methodsToImplement)
+    else Right(PreparationResult(targetTemplate.get, methodsToImplement))
   }
 
   override type RefactoringParameters = Unit
 
   override def perform(selection: Selection, prepared: PreparationResult, params: RefactoringParameters) = {
-    ???
+    import prepared._
+
+    val findTemplate = filter {
+      case t: Template => t == targetTemplate
+    }
+
+    val addMethods = transform {
+      case tpl @ Template(_,  _, body) if tpl == prepared.targetTemplate =>
+        val methodsBody = Block(Ident("???") :: Nil, EmptyTree)
+        val methodWithRhs = methodsToImplement.map(_ copy (rhs = methodsBody))
+        tpl.copy(body = body ++ methodWithRhs).replaces(tpl)
+    }
+
+    val transformation = topdown {
+      matchingChildren {
+        findTemplate &>
+        addMethods
+      }
+    }
+    Right(transformFile(selection.file, transformation))
   }
 }

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

@@ -9,40 +9,38 @@ class ImplementMethodsTest extends TestHelper with TestRefactoring {
 
   val fromSource =
     """
+      |package implementMethods
+      |
       |trait T {
-      | def f(x: Int): String
+      |  def f(x: Int): String
       |}
       |
       |object Obj extends /*(*/T/*)*/ {
+      |
+      |  def g(x: Int): Int = 1
+      |
       |}
     """.stripMargin
 
   val toSource =
     """
+      |package implementMethods
+      |
       |trait T {
-      | def f(x: Int): String
+      |  def f(x: Int): String
       |}
       |
-      |object Obj extends T {
-      |  def g(): Int = {
-      |    ???    Left(PreparationError("crash!"))
-
+      |object Obj extends /*(*/T/*)*/ {
+      |
+      |  def g(x: Int): Int = 1
+      |
+      |  def f(x: Int): String = {
+      |    ???
       |  }
+      |
       |}
     """.stripMargin
 
-  /*@Test
-  def addMethod() = {
-    global.ask { () =>
-      val refactoring = new AddMethod {
-        val global: Global = outer.global
-        val file = addToCompiler(UniqueNames.basename(), fromSource)
-        val change = addMethod(file, "Obj", "g", List(Nil), Nil, Some("Int"), AddToObject)
-      }
-      assertEquals(toSource, Change.applyChanges(refactoring.change, fromSource))
-    }
-  }*/
-
   def implementMethods(pro: FileSet) = new TestRefactoringImpl(pro) {
     override val refactoring = new ImplementMethods with TestProjectIndex
     val changes = performRefactoring(())